3 Routine procedures for memory allocate/free.
5 Copyright (c) 2007 - 2009, Intel Corporation
6 All rights reserved. This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 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 Pool The buffer pool to allocate memory for.
24 @param Pages How many pages to allocate.
26 @return The allocated memory block or NULL if failed.
31 IN USBHC_MEM_POOL
*Pool
,
35 USBHC_MEM_BLOCK
*Block
;
36 EFI_PCI_IO_PROTOCOL
*PciIo
;
39 EFI_PHYSICAL_ADDRESS MappedAddr
;
45 Block
= AllocateZeroPool (sizeof (USBHC_MEM_BLOCK
));
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
->BufLen
= EFI_PAGES_TO_SIZE (Pages
);
57 Block
->BitsLen
= Block
->BufLen
/ (USBHC_MEM_UNIT
* 8);
58 Block
->Bits
= AllocateZeroPool (Block
->BitsLen
);
60 if (Block
->Bits
== NULL
) {
61 gBS
->FreePool (Block
);
66 // Allocate the number of Pages of memory, then map it for
67 // bus master read and write.
69 Status
= PciIo
->AllocateBuffer (
78 if (EFI_ERROR (Status
)) {
82 Bytes
= EFI_PAGES_TO_SIZE (Pages
);
85 EfiPciIoOperationBusMasterCommonBuffer
,
92 if (EFI_ERROR (Status
) || (Bytes
!= EFI_PAGES_TO_SIZE (Pages
))) {
97 // Check whether the data structure used by the host controller
98 // should be restricted into the same 4G
100 if (Pool
->Check4G
&& (Pool
->Which4G
!= USB_HC_HIGH_32BIT (MappedAddr
))) {
101 PciIo
->Unmap (PciIo
, Mapping
);
105 Block
->BufHost
= BufHost
;
106 Block
->Buf
= (UINT8
*) ((UINTN
) MappedAddr
);
107 Block
->Mapping
= Mapping
;
112 PciIo
->FreeBuffer (PciIo
, Pages
, BufHost
);
115 gBS
->FreePool (Block
->Bits
);
116 gBS
->FreePool (Block
);
122 Free the memory block from the memory pool.
124 @param Pool The memory pool to free the block from.
125 @param Block The memory block to free.
130 IN USBHC_MEM_POOL
*Pool
,
131 IN USBHC_MEM_BLOCK
*Block
134 EFI_PCI_IO_PROTOCOL
*PciIo
;
136 ASSERT ((Pool
!= NULL
) && (Block
!= NULL
));
141 // Unmap the common buffer then free the structures
143 PciIo
->Unmap (PciIo
, Block
->Mapping
);
144 PciIo
->FreeBuffer (PciIo
, EFI_SIZE_TO_PAGES (Block
->BufLen
), Block
->BufHost
);
146 gBS
->FreePool (Block
->Bits
);
147 gBS
->FreePool (Block
);
152 Alloc some memory from the block.
154 @param Block The memory block to allocate memory from.
155 @param Units Number of memory units to allocate.
157 @return The pointer to the allocated memory. If couldn't allocate the needed memory,
158 the return value is NULL.
162 UsbHcAllocMemFromBlock (
163 IN USBHC_MEM_BLOCK
*Block
,
174 ASSERT ((Block
!= 0) && (Units
!= 0));
180 for (Byte
= 0, Bit
= 0; Byte
< Block
->BitsLen
;) {
182 // If current bit is zero, the corresponding memory unit is
183 // available, otherwise we need to restart our searching.
184 // Available counts the consective number of zero bit.
186 if (!USB_HC_BIT_IS_SET (Block
->Bits
[Byte
], Bit
)) {
189 if (Available
>= Units
) {
193 NEXT_BIT (Byte
, Bit
);
196 NEXT_BIT (Byte
, Bit
);
204 if (Available
< Units
) {
209 // Mark the memory as allocated
214 for (Count
= 0; Count
< Units
; Count
++) {
215 ASSERT (!USB_HC_BIT_IS_SET (Block
->Bits
[Byte
], Bit
));
217 Block
->Bits
[Byte
] = (UINT8
) (Block
->Bits
[Byte
] | USB_HC_BIT (Bit
));
218 NEXT_BIT (Byte
, Bit
);
221 return Block
->Buf
+ (StartByte
* 8 + StartBit
) * USBHC_MEM_UNIT
;
225 Get the pci memory address according to the allocated host memory address.
227 @param Pool The memory pool of the host controller.
228 @param Mem The memory to free.
229 @param Size The size of the memory to free.
231 @return the pci memory address
234 UsbHcGetPciAddressForHostMem (
235 IN USBHC_MEM_POOL
*Pool
,
240 USBHC_MEM_BLOCK
*Head
;
241 USBHC_MEM_BLOCK
*Block
;
243 EFI_PHYSICAL_ADDRESS PhyAddr
;
247 AllocSize
= USBHC_MEM_ROUND (Size
);
249 for (Block
= Head
; Block
!= NULL
; Block
= Block
->Next
) {
251 // scan the memory block list for the memory block that
252 // completely contains the allocated memory.
254 if ((Block
->Buf
<= (UINT8
*) Mem
) && (((UINT8
*) Mem
+ AllocSize
) <= (Block
->Buf
+ Block
->BufLen
))) {
259 ASSERT ((Block
!= NULL
));
261 // calculate the pci memory address for host memory address.
263 Offset
= (UINT8
*)Mem
- Block
->BufHost
;
264 PhyAddr
= (EFI_PHYSICAL_ADDRESS
)(UINTN
) (Block
->Buf
+ Offset
);
270 Insert the memory block to the pool's list of the blocks.
272 @param Head The head of the memory pool's block list.
273 @param Block The memory block to insert.
277 UsbHcInsertMemBlockToPool (
278 IN USBHC_MEM_BLOCK
*Head
,
279 IN USBHC_MEM_BLOCK
*Block
282 ASSERT ((Head
!= NULL
) && (Block
!= NULL
));
283 Block
->Next
= Head
->Next
;
289 Is the memory block empty?
291 @param Block The memory block to check.
293 @retval TRUE The memory block is empty.
294 @retval FALSE The memory block isn't empty.
298 UsbHcIsMemBlockEmpty (
299 IN USBHC_MEM_BLOCK
*Block
304 for (Index
= 0; Index
< Block
->BitsLen
; Index
++) {
305 if (Block
->Bits
[Index
] != 0) {
315 Unlink the memory block from the pool's list.
317 @param Head The block list head of the memory's pool.
318 @param BlockToUnlink The memory block to unlink.
322 UsbHcUnlinkMemBlock (
323 IN USBHC_MEM_BLOCK
*Head
,
324 IN USBHC_MEM_BLOCK
*BlockToUnlink
327 USBHC_MEM_BLOCK
*Block
;
329 ASSERT ((Head
!= NULL
) && (BlockToUnlink
!= NULL
));
331 for (Block
= Head
; Block
!= NULL
; Block
= Block
->Next
) {
332 if (Block
->Next
== BlockToUnlink
) {
333 Block
->Next
= BlockToUnlink
->Next
;
334 BlockToUnlink
->Next
= NULL
;
342 Initialize the memory management pool for the host controller.
344 @param PciIo The PciIo that can be used to access the host controller.
345 @param Check4G Whether the host controller requires allocated memory
346 from one 4G address space.
347 @param Which4G The 4G memory area each memory allocated should be from.
349 @retval EFI_SUCCESS The memory pool is initialized.
350 @retval EFI_OUT_OF_RESOURCE Fail to init the memory pool.
355 IN EFI_PCI_IO_PROTOCOL
*PciIo
,
360 USBHC_MEM_POOL
*Pool
;
362 Pool
= AllocatePool (sizeof (USBHC_MEM_POOL
));
369 Pool
->Check4G
= Check4G
;
370 Pool
->Which4G
= Which4G
;
371 Pool
->Head
= UsbHcAllocMemBlock (Pool
, USBHC_MEM_DEFAULT_PAGES
);
373 if (Pool
->Head
== NULL
) {
374 gBS
->FreePool (Pool
);
383 Release the memory management pool.
385 @param Pool The USB memory pool to free.
387 @retval EFI_SUCCESS The memory pool is freed.
388 @retval EFI_DEVICE_ERROR Failed to free the memory pool.
393 IN USBHC_MEM_POOL
*Pool
396 USBHC_MEM_BLOCK
*Block
;
398 ASSERT (Pool
->Head
!= NULL
);
401 // Unlink all the memory blocks from the pool, then free them.
402 // UsbHcUnlinkMemBlock can't be used to unlink and free the
405 for (Block
= Pool
->Head
->Next
; Block
!= NULL
; Block
= Pool
->Head
->Next
) {
406 UsbHcUnlinkMemBlock (Pool
->Head
, Block
);
407 UsbHcFreeMemBlock (Pool
, Block
);
410 UsbHcFreeMemBlock (Pool
, Pool
->Head
);
411 gBS
->FreePool (Pool
);
417 Allocate some memory from the host controller's memory pool
418 which can be used to communicate with host controller.
420 @param Pool The host controller's memory pool.
421 @param Size Size of the memory to allocate.
423 @return The allocated memory or NULL.
428 IN USBHC_MEM_POOL
*Pool
,
432 USBHC_MEM_BLOCK
*Head
;
433 USBHC_MEM_BLOCK
*Block
;
434 USBHC_MEM_BLOCK
*NewBlock
;
440 AllocSize
= USBHC_MEM_ROUND (Size
);
442 ASSERT (Head
!= NULL
);
445 // First check whether current memory blocks can satisfy the allocation.
447 for (Block
= Head
; Block
!= NULL
; Block
= Block
->Next
) {
448 Mem
= UsbHcAllocMemFromBlock (Block
, AllocSize
/ USBHC_MEM_UNIT
);
461 // Create a new memory block if there is not enough memory
462 // in the pool. If the allocation size is larger than the
463 // default page number, just allocate a large enough memory
464 // block. Otherwise allocate default pages.
466 if (AllocSize
> EFI_PAGES_TO_SIZE (USBHC_MEM_DEFAULT_PAGES
)) {
467 Pages
= EFI_SIZE_TO_PAGES (AllocSize
) + 1;
469 Pages
= USBHC_MEM_DEFAULT_PAGES
;
472 NewBlock
= UsbHcAllocMemBlock (Pool
, Pages
);
474 if (NewBlock
== NULL
) {
475 DEBUG ((EFI_D_INFO
, "UsbHcAllocateMem: failed to allocate block\n"));
480 // Add the new memory block to the pool, then allocate memory from it
482 UsbHcInsertMemBlockToPool (Head
, NewBlock
);
483 Mem
= UsbHcAllocMemFromBlock (NewBlock
, AllocSize
/ USBHC_MEM_UNIT
);
494 Free the allocated memory back to the memory pool.
496 @param Pool The memory pool of the host controller.
497 @param Mem The memory to free.
498 @param Size The size of the memory to free.
503 IN USBHC_MEM_POOL
*Pool
,
508 USBHC_MEM_BLOCK
*Head
;
509 USBHC_MEM_BLOCK
*Block
;
517 AllocSize
= USBHC_MEM_ROUND (Size
);
518 ToFree
= (UINT8
*) Mem
;
520 for (Block
= Head
; Block
!= NULL
; Block
= Block
->Next
) {
522 // scan the memory block list for the memory block that
523 // completely contains the memory to free.
525 if ((Block
->Buf
<= ToFree
) && ((ToFree
+ AllocSize
) <= (Block
->Buf
+ Block
->BufLen
))) {
527 // compute the start byte and bit in the bit array
529 Byte
= ((ToFree
- Block
->Buf
) / USBHC_MEM_UNIT
) / 8;
530 Bit
= ((ToFree
- Block
->Buf
) / USBHC_MEM_UNIT
) % 8;
533 // reset associated bits in bit arry
535 for (Count
= 0; Count
< (AllocSize
/ USBHC_MEM_UNIT
); Count
++) {
536 ASSERT (USB_HC_BIT_IS_SET (Block
->Bits
[Byte
], Bit
));
538 Block
->Bits
[Byte
] = (UINT8
) (Block
->Bits
[Byte
] ^ USB_HC_BIT (Bit
));
539 NEXT_BIT (Byte
, Bit
);
547 // If Block == NULL, it means that the current memory isn't
548 // in the host controller's pool. This is critical because
549 // the caller has passed in a wrong memory point
551 ASSERT (Block
!= NULL
);
554 // Release the current memory block if it is empty and not the head
556 if ((Block
!= Head
) && UsbHcIsMemBlockEmpty (Block
)) {
557 UsbHcUnlinkMemBlock (Head
, Block
);
558 UsbHcFreeMemBlock (Pool
, Block
);