2 PEIM to produce gPeiUsb2HostControllerPpiGuid based on gPeiUsbControllerPpiGuid
3 which is used to enable recovery function from USB Drivers.
5 Copyright (c) 2014 - 2015, Intel Corporation. All rights reserved.<BR>
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions
9 of the BSD License which accompanies this distribution. The
10 full text of the license may be found at
11 http://opensource.org/licenses/bsd-license.php
13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
14 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
21 Allocate a block of memory to be used by the buffer pool.
23 @param Pages How many pages to allocate.
25 @return Pointer to the allocated memory block or NULL if failed.
33 USBHC_MEM_BLOCK
*Block
;
36 EFI_PHYSICAL_ADDRESS TempPtr
;
38 PageNumber
= EFI_SIZE_TO_PAGES (sizeof (USBHC_MEM_BLOCK
));
39 Status
= PeiServicesAllocatePages (
45 if (EFI_ERROR (Status
)) {
48 ZeroMem ((VOID
*) (UINTN
) TempPtr
, EFI_PAGES_TO_SIZE (PageNumber
));
51 // each bit in the bit array represents USBHC_MEM_UNIT
52 // bytes of memory in the memory block.
54 ASSERT (USBHC_MEM_UNIT
* 8 <= EFI_PAGE_SIZE
);
56 Block
= (USBHC_MEM_BLOCK
*) (UINTN
) TempPtr
;
57 Block
->BufLen
= EFI_PAGES_TO_SIZE (Pages
);
58 Block
->BitsLen
= Block
->BufLen
/ (USBHC_MEM_UNIT
* 8);
60 PageNumber
= EFI_SIZE_TO_PAGES (Block
->BitsLen
);
61 Status
= PeiServicesAllocatePages (
67 if (EFI_ERROR (Status
)) {
70 ZeroMem ((VOID
*) (UINTN
) TempPtr
, EFI_PAGES_TO_SIZE (PageNumber
));
72 Block
->Bits
= (UINT8
*) (UINTN
) TempPtr
;
74 Status
= PeiServicesAllocatePages (
79 if (EFI_ERROR (Status
)) {
82 ZeroMem ((VOID
*) (UINTN
) TempPtr
, EFI_PAGES_TO_SIZE (Pages
));
84 Block
->BufHost
= (UINT8
*) (UINTN
) TempPtr
;;
85 Block
->Buf
= (UINT8
*) (UINTN
) TempPtr
;
92 Free the memory block from the memory pool.
94 @param Pool The memory pool to free the block from.
95 @param Block The memory block to free.
100 IN USBHC_MEM_POOL
*Pool
,
101 IN USBHC_MEM_BLOCK
*Block
104 ASSERT ((Pool
!= NULL
) && (Block
!= NULL
));
106 // No free memory in PEI.
111 Alloc some memory from the block.
113 @param Block The memory block to allocate memory from.
114 @param Units Number of memory units to allocate.
116 @return The pointer to the allocated memory.
117 If couldn't allocate the needed memory, the return value is NULL.
121 UsbHcAllocMemFromBlock (
122 IN USBHC_MEM_BLOCK
*Block
,
133 ASSERT ((Block
!= 0) && (Units
!= 0));
139 for (Byte
= 0, Bit
= 0; Byte
< Block
->BitsLen
;) {
141 // If current bit is zero, the corresponding memory unit is
142 // available, otherwise we need to restart our searching.
143 // Available counts the consective number of zero bit.
145 if (!USB_HC_BIT_IS_SET (Block
->Bits
[Byte
], Bit
)) {
148 if (Available
>= Units
) {
152 NEXT_BIT (Byte
, Bit
);
154 NEXT_BIT (Byte
, Bit
);
162 if (Available
< Units
) {
167 // Mark the memory as allocated
172 for (Count
= 0; Count
< Units
; Count
++) {
173 ASSERT (!USB_HC_BIT_IS_SET (Block
->Bits
[Byte
], Bit
));
175 Block
->Bits
[Byte
] = (UINT8
) (Block
->Bits
[Byte
] | (UINT8
) USB_HC_BIT (Bit
));
176 NEXT_BIT (Byte
, Bit
);
179 return Block
->BufHost
+ (StartByte
* 8 + StartBit
) * USBHC_MEM_UNIT
;
183 Calculate the corresponding pci bus address according to the Mem parameter.
185 @param Pool The memory pool of the host controller.
186 @param Mem The pointer to host memory.
187 @param Size The size of the memory region.
189 @return The pci memory address
193 UsbHcGetPciAddrForHostAddr (
194 IN USBHC_MEM_POOL
*Pool
,
199 USBHC_MEM_BLOCK
*Head
;
200 USBHC_MEM_BLOCK
*Block
;
202 EFI_PHYSICAL_ADDRESS PhyAddr
;
206 AllocSize
= USBHC_MEM_ROUND (Size
);
212 for (Block
= Head
; Block
!= NULL
; Block
= Block
->Next
) {
214 // scan the memory block list for the memory block that
215 // completely contains the allocated memory.
217 if ((Block
->BufHost
<= (UINT8
*) Mem
) && (((UINT8
*) Mem
+ AllocSize
) <= (Block
->BufHost
+ Block
->BufLen
))) {
222 ASSERT ((Block
!= NULL
));
224 // calculate the pci memory address for host memory address.
226 Offset
= (UINT8
*) Mem
- Block
->BufHost
;
227 PhyAddr
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) (Block
->Buf
+ Offset
);
232 Calculate the corresponding host address according to the pci address.
234 @param Pool The memory pool of the host controller.
235 @param Mem The pointer to pci memory.
236 @param Size The size of the memory region.
238 @return The host memory address
242 UsbHcGetHostAddrForPciAddr (
243 IN USBHC_MEM_POOL
*Pool
,
248 USBHC_MEM_BLOCK
*Head
;
249 USBHC_MEM_BLOCK
*Block
;
251 EFI_PHYSICAL_ADDRESS HostAddr
;
255 AllocSize
= USBHC_MEM_ROUND (Size
);
261 for (Block
= Head
; Block
!= NULL
; Block
= Block
->Next
) {
263 // scan the memory block list for the memory block that
264 // completely contains the allocated memory.
266 if ((Block
->Buf
<= (UINT8
*) Mem
) && (((UINT8
*) Mem
+ AllocSize
) <= (Block
->Buf
+ Block
->BufLen
))) {
271 ASSERT ((Block
!= NULL
));
273 // calculate the host memory address for pci memory address.
275 Offset
= (UINT8
*) Mem
- Block
->Buf
;
276 HostAddr
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) (Block
->BufHost
+ Offset
);
281 Insert the memory block to the pool's list of the blocks.
283 @param Head The head of the memory pool's block list.
284 @param Block The memory block to insert.
288 UsbHcInsertMemBlockToPool (
289 IN USBHC_MEM_BLOCK
*Head
,
290 IN USBHC_MEM_BLOCK
*Block
293 ASSERT ((Head
!= NULL
) && (Block
!= NULL
));
294 Block
->Next
= Head
->Next
;
299 Is the memory block empty?
301 @param Block The memory block to check.
303 @retval TRUE The memory block is empty.
304 @retval FALSE The memory block isn't empty.
308 UsbHcIsMemBlockEmpty (
309 IN USBHC_MEM_BLOCK
*Block
314 for (Index
= 0; Index
< Block
->BitsLen
; Index
++) {
315 if (Block
->Bits
[Index
] != 0) {
324 Unlink the memory block from the pool's list.
326 @param Head The block list head of the memory's pool.
327 @param BlockToUnlink The memory block to unlink.
331 UsbHcUnlinkMemBlock (
332 IN USBHC_MEM_BLOCK
*Head
,
333 IN USBHC_MEM_BLOCK
*BlockToUnlink
336 USBHC_MEM_BLOCK
*Block
;
338 ASSERT ((Head
!= NULL
) && (BlockToUnlink
!= NULL
));
340 for (Block
= Head
; Block
!= NULL
; Block
= Block
->Next
) {
341 if (Block
->Next
== BlockToUnlink
) {
342 Block
->Next
= BlockToUnlink
->Next
;
343 BlockToUnlink
->Next
= NULL
;
350 Initialize the memory management pool for the host controller.
352 @return Pointer to the allocated memory pool or NULL if failed.
360 USBHC_MEM_POOL
*Pool
;
363 EFI_PHYSICAL_ADDRESS TempPtr
;
365 PageNumber
= EFI_SIZE_TO_PAGES (sizeof (USBHC_MEM_POOL
));
366 Status
= PeiServicesAllocatePages (
371 if (EFI_ERROR (Status
)) {
374 ZeroMem ((VOID
*) (UINTN
) TempPtr
, EFI_PAGES_TO_SIZE (PageNumber
));
376 Pool
= (USBHC_MEM_POOL
*) ((UINTN
) TempPtr
);
377 Pool
->Head
= UsbHcAllocMemBlock (USBHC_MEM_DEFAULT_PAGES
);
379 if (Pool
->Head
== NULL
) {
381 // No free memory in PEI.
390 Release the memory management pool.
392 @param Pool The USB memory pool to free.
397 IN USBHC_MEM_POOL
*Pool
400 USBHC_MEM_BLOCK
*Block
;
402 ASSERT (Pool
->Head
!= NULL
);
405 // Unlink all the memory blocks from the pool, then free them.
406 // UsbHcUnlinkMemBlock can't be used to unlink and free the
409 for (Block
= Pool
->Head
->Next
; Block
!= NULL
; Block
= Pool
->Head
->Next
) {
410 //UsbHcUnlinkMemBlock (Pool->Head, Block);
411 UsbHcFreeMemBlock (Pool
, Block
);
414 UsbHcFreeMemBlock (Pool
, Pool
->Head
);
418 Allocate some memory from the host controller's memory pool
419 which can be used to communicate with host controller.
421 @param Pool The host controller's memory pool.
422 @param Size Size of the memory to allocate.
424 @return The allocated memory or NULL.
429 IN USBHC_MEM_POOL
*Pool
,
433 USBHC_MEM_BLOCK
*Head
;
434 USBHC_MEM_BLOCK
*Block
;
435 USBHC_MEM_BLOCK
*NewBlock
;
441 AllocSize
= USBHC_MEM_ROUND (Size
);
443 ASSERT (Head
!= NULL
);
446 // First check whether current memory blocks can satisfy the allocation.
448 for (Block
= Head
; Block
!= NULL
; Block
= Block
->Next
) {
449 Mem
= UsbHcAllocMemFromBlock (Block
, AllocSize
/ USBHC_MEM_UNIT
);
462 // Create a new memory block if there is not enough memory
463 // in the pool. If the allocation size is larger than the
464 // default page number, just allocate a large enough memory
465 // block. Otherwise allocate default pages.
467 if (AllocSize
> EFI_PAGES_TO_SIZE (USBHC_MEM_DEFAULT_PAGES
)) {
468 Pages
= EFI_SIZE_TO_PAGES (AllocSize
);
470 Pages
= USBHC_MEM_DEFAULT_PAGES
;
472 NewBlock
= UsbHcAllocMemBlock (Pages
);
474 if (NewBlock
== NULL
) {
479 // Add the new memory block to the pool, then allocate memory from it
481 UsbHcInsertMemBlockToPool (Head
, NewBlock
);
482 Mem
= UsbHcAllocMemFromBlock (NewBlock
, AllocSize
/ USBHC_MEM_UNIT
);
492 Free the allocated memory back to the memory pool.
494 @param Pool The memory pool of the host controller.
495 @param Mem The memory to free.
496 @param Size The size of the memory to free.
501 IN USBHC_MEM_POOL
*Pool
,
506 USBHC_MEM_BLOCK
*Head
;
507 USBHC_MEM_BLOCK
*Block
;
515 AllocSize
= USBHC_MEM_ROUND (Size
);
516 ToFree
= (UINT8
*) Mem
;
518 for (Block
= Head
; Block
!= NULL
; Block
= Block
->Next
) {
520 // scan the memory block list for the memory block that
521 // completely contains the memory to free.
523 if ((Block
->BufHost
<= ToFree
) && ((ToFree
+ AllocSize
) <= (Block
->BufHost
+ Block
->BufLen
))) {
525 // compute the start byte and bit in the bit array
527 Byte
= ((ToFree
- Block
->BufHost
) / USBHC_MEM_UNIT
) / 8;
528 Bit
= ((ToFree
- Block
->BufHost
) / USBHC_MEM_UNIT
) % 8;
531 // reset associated bits in bit arry
533 for (Count
= 0; Count
< (AllocSize
/ USBHC_MEM_UNIT
); Count
++) {
534 ASSERT (USB_HC_BIT_IS_SET (Block
->Bits
[Byte
], Bit
));
536 Block
->Bits
[Byte
] = (UINT8
) (Block
->Bits
[Byte
] ^ USB_HC_BIT (Bit
));
537 NEXT_BIT (Byte
, Bit
);
545 // If Block == NULL, it means that the current memory isn't
546 // in the host controller's pool. This is critical because
547 // the caller has passed in a wrong memory pointer
549 ASSERT (Block
!= NULL
);
552 // Release the current memory block if it is empty and not the head
554 if ((Block
!= Head
) && UsbHcIsMemBlockEmpty (Block
)) {
555 //UsbHcUnlinkMemBlock (Head, Block);
556 UsbHcFreeMemBlock (Pool
, Block
);
561 Allocates pages at a specified alignment.
563 If Alignment is not a power of two and Alignment is not zero, then ASSERT().
565 @param Pages The number of pages to allocate.
566 @param Alignment The requested alignment of the allocation. Must be a power of two.
567 @param HostAddress The system memory address to map to the PCI controller.
568 @param DeviceAddress The resulting map address for the bus master PCI controller to
569 use to access the hosts HostAddress.
571 @retval EFI_SUCCESS Success to allocate aligned pages.
572 @retval EFI_INVALID_PARAMETER Pages or Alignment is not valid.
573 @retval EFI_OUT_OF_RESOURCES Do not have enough resources to allocate memory.
577 UsbHcAllocateAlignedPages (
580 OUT VOID
**HostAddress
,
581 OUT EFI_PHYSICAL_ADDRESS
*DeviceAddress
585 EFI_PHYSICAL_ADDRESS Memory
;
591 // Alignment must be a power of two or zero.
593 ASSERT ((Alignment
& (Alignment
- 1)) == 0);
595 if ((Alignment
& (Alignment
- 1)) != 0) {
596 return EFI_INVALID_PARAMETER
;
600 return EFI_INVALID_PARAMETER
;
603 if (Alignment
> EFI_PAGE_SIZE
) {
605 // Calculate the total number of pages since alignment is larger than page size.
607 AlignmentMask
= Alignment
- 1;
608 RealPages
= Pages
+ EFI_SIZE_TO_PAGES (Alignment
);
610 // Make sure that Pages plus EFI_SIZE_TO_PAGES (Alignment) does not overflow.
612 ASSERT (RealPages
> Pages
);
614 Status
= PeiServicesAllocatePages (
619 if (EFI_ERROR (Status
)) {
620 return EFI_OUT_OF_RESOURCES
;
622 AlignedMemory
= ((UINTN
) Memory
+ AlignmentMask
) & ~AlignmentMask
;
625 // Do not over-allocate pages in this case.
627 Status
= PeiServicesAllocatePages (
632 if (EFI_ERROR (Status
)) {
633 return EFI_OUT_OF_RESOURCES
;
635 AlignedMemory
= (UINTN
) Memory
;
638 *HostAddress
= (VOID
*) AlignedMemory
;
639 *DeviceAddress
= (EFI_PHYSICAL_ADDRESS
) AlignedMemory
;
645 Frees memory that was allocated with UsbHcAllocateAlignedPages().
647 @param HostAddress The system memory address to map to the PCI controller.
648 @param Pages The number of pages to free.
652 UsbHcFreeAlignedPages (
653 IN VOID
*HostAddress
,
659 // No free memory in PEI.