EdkModulePkg/Bus/Pci/Ehci/Dxe/EhciMem.c

   1 /*++
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14     EhciMem.c
  15
  16 Abstract:
  17
  18
  19 Revision History
  20 --*/
  21
  22 #include "Ehci.h"
  23
  24
  25 EFI_STATUS
  26 CreateMemoryBlock (
  27   IN  USB2_HC_DEV               *HcDev,
  28   OUT MEMORY_MANAGE_HEADER      **MemoryHeader,
  29   IN  UINTN                     MemoryBlockSizeInPages
  30   )
  31 /*++
  32
  33 Routine Description:
  34
  35   Use PciIo->AllocateBuffer to allocate common buffer for the memory block,
  36   and use PciIo->Map to map the common buffer for Bus Master Read/Write.
  37
  38 Arguments:
  39
  40   HcDev                  - USB2_HC_DEV
  41   MemoryHeader           - MEMORY_MANAGE_HEADER to output
  42   MemoryBlockSizeInPages - MemoryBlockSizeInPages
  43
  44 Returns:
  45
  46   EFI_SUCCESS           Success
  47   EFI_OUT_OF_RESOURCES  Fail for no resources
  48   EFI_UNSUPPORTED       Unsupported currently
  49
  50 --*/
  51 {
  52   EFI_STATUS            Status;
  53   VOID                  *CommonBuffer;
  54   EFI_PHYSICAL_ADDRESS  MappedAddress;
  55   UINTN                 MemoryBlockSizeInBytes;
  56   VOID                  *Mapping;
  57
  58   //
  59   // Allocate memory for MemoryHeader
  60   //
  61   *MemoryHeader = AllocateZeroPool (sizeof (MEMORY_MANAGE_HEADER));
  62   if (*MemoryHeader == NULL) {
  63     return EFI_OUT_OF_RESOURCES;
  64   }
  65
  66   (*MemoryHeader)->Next = NULL;
  67
  68   //
  69   // set Memory block size
  70   //
  71   (*MemoryHeader)->MemoryBlockSizeInBytes = EFI_PAGES_TO_SIZE (MemoryBlockSizeInPages);
  72
  73   //
  74   // each bit in Bit Array will manage 32 bytes memory in memory block
  75   //
  76   (*MemoryHeader)->BitArraySizeInBytes = ((*MemoryHeader)->MemoryBlockSizeInBytes / 32) / 8;
  77
  78   //
  79   // Allocate memory for BitArray
  80   //
  81   (*MemoryHeader)->BitArrayPtr = AllocateZeroPool ((*MemoryHeader)->BitArraySizeInBytes);
  82   if ((*MemoryHeader)->BitArrayPtr == NULL) {
  83     gBS->FreePool (*MemoryHeader);
  84     return EFI_OUT_OF_RESOURCES;
  85   }
  86
  87   //
  88   // Memory Block uses MemoryBlockSizeInPages pages,
  89   // and it is allocated as common buffer use.
  90   //
  91   Status = HcDev->PciIo->AllocateBuffer (
  92                            HcDev->PciIo,
  93                            AllocateAnyPages,
  94                            EfiBootServicesData,
  95                            MemoryBlockSizeInPages,
  96                            &CommonBuffer,
  97                            0
  98                            );
  99   if (EFI_ERROR (Status)) {
 100     gBS->FreePool ((*MemoryHeader)->BitArrayPtr);
 101     gBS->FreePool (*MemoryHeader);
 102     return EFI_OUT_OF_RESOURCES;
 103   }
 104
 105   MemoryBlockSizeInBytes = EFI_PAGES_TO_SIZE (MemoryBlockSizeInPages);
 106   Status = HcDev->PciIo->Map (
 107                            HcDev->PciIo,
 108                            EfiPciIoOperationBusMasterCommonBuffer,
 109                            CommonBuffer,
 110                            &MemoryBlockSizeInBytes,
 111                            &MappedAddress,
 112                            &Mapping
 113                            );
 114   //
 115   // If returned Mapped size is less than the size
 116   // we request,do not support.
 117   //
 118   if (EFI_ERROR (Status) || (MemoryBlockSizeInBytes != EFI_PAGES_TO_SIZE (MemoryBlockSizeInPages))) {
 119     HcDev->PciIo->FreeBuffer (HcDev->PciIo, MemoryBlockSizeInPages, CommonBuffer);
 120     gBS->FreePool ((*MemoryHeader)->BitArrayPtr);
 121     gBS->FreePool (*MemoryHeader);
 122     return EFI_UNSUPPORTED;
 123   }
 124
 125   //
 126   // Data structure involved by host controller
 127   // should be restricted into the same 4G
 128   //
 129   if (HcDev->Is64BitCapable != 0) {
 130         if (HcDev->High32BitAddr != GET_32B_TO_63B (MappedAddress)) {
 131           HcDev->PciIo->Unmap (HcDev->PciIo, Mapping);
 132       HcDev->PciIo->FreeBuffer (HcDev->PciIo, MemoryBlockSizeInPages, CommonBuffer);
 133       gBS->FreePool ((*MemoryHeader)->BitArrayPtr);
 134       gBS->FreePool (*MemoryHeader);
 135       return EFI_UNSUPPORTED;
 136         }
 137   }
 138
 139   //
 140   // Set Memory block initial address
 141   //
 142   (*MemoryHeader)->MemoryBlockPtr = (UINT8 *) ((UINTN) MappedAddress);
 143   (*MemoryHeader)->Mapping        = Mapping;
 144
 145   ZeroMem (
 146     (*MemoryHeader)->MemoryBlockPtr,
 147     EFI_PAGES_TO_SIZE (MemoryBlockSizeInPages)
 148     );
 149
 150   return EFI_SUCCESS;
 151 }
 152
 153 EFI_STATUS
 154 FreeMemoryHeader (
 155   IN USB2_HC_DEV               *HcDev,
 156   IN MEMORY_MANAGE_HEADER      *MemoryHeader
 157   )
 158 /*++
 159
 160 Routine Description:
 161
 162   Free Memory Header
 163
 164 Arguments:
 165
 166   HcDev         - USB2_HC_DEV
 167   MemoryHeader  - MemoryHeader to be freed
 168
 169 Returns:
 170
 171   EFI_SUCCESS            Success
 172   EFI_INVALID_PARAMETER  Parameter is error
 173
 174 --*/
 175 {
 176   if ((MemoryHeader == NULL) || (HcDev == NULL)) {
 177     return EFI_INVALID_PARAMETER;
 178   }
 179   //
 180   // unmap the common buffer used by the memory block
 181   //
 182   HcDev->PciIo->Unmap (HcDev->PciIo, MemoryHeader->Mapping);
 183
 184   //
 185   // free common buffer
 186   //
 187   HcDev->PciIo->FreeBuffer (
 188                   HcDev->PciIo,
 189                   EFI_SIZE_TO_PAGES (MemoryHeader->MemoryBlockSizeInBytes),
 190                   MemoryHeader->MemoryBlockPtr
 191                   );
 192   //
 193   // free bit array
 194   //
 195   gBS->FreePool (MemoryHeader->BitArrayPtr);
 196   //
 197   // free memory header
 198   //
 199   gBS->FreePool (MemoryHeader);
 200
 201   return EFI_SUCCESS;
 202 }
 203
 204 EFI_STATUS
 205 EhciAllocatePool (
 206   IN  USB2_HC_DEV     *HcDev,
 207   OUT UINT8           **Pool,
 208   IN  UINTN           AllocSize
 209   )
 210 /*++
 211
 212 Routine Description:
 213
 214   Ehci Allocate Pool
 215
 216 Arguments:
 217
 218   HcDev     - USB2_HC_DEV
 219   Pool      - Place to store pointer to the memory buffer
 220   AllocSize - Alloc Size
 221
 222 Returns:
 223
 224   EFI_SUCCESS        Success
 225   EFI_DEVICE_ERROR   Fail
 226
 227 --*/
 228 {
 229   MEMORY_MANAGE_HEADER  *MemoryHeader;
 230   MEMORY_MANAGE_HEADER  *TempHeaderPtr;
 231   MEMORY_MANAGE_HEADER  *NewMemoryHeader;
 232   UINTN                 RealAllocSize;
 233   UINTN                 MemoryBlockSizeInPages;
 234   EFI_STATUS            Status;
 235   EFI_TPL               OldTpl;
 236
 237   *Pool         = NULL;
 238
 239   MemoryHeader  = HcDev->MemoryHeader;
 240   ASSERT (MemoryHeader != NULL);
 241
 242   OldTpl = gBS->RaiseTPL (EFI_TPL_NOTIFY + 1);
 243
 244   //
 245   // allocate unit is 32 bytes (align on 32 byte)
 246   //
 247   if (AllocSize & 0x1F) {
 248     RealAllocSize = (AllocSize / 32 + 1) * 32;
 249   } else {
 250     RealAllocSize = AllocSize;
 251   }
 252
 253   //
 254   // There may be linked MemoryHeaders.
 255   // To allocate a free pool in Memory blocks,
 256   // must search in the MemoryHeader link list
 257   // until enough free pool is found.
 258   //
 259   Status = EFI_NOT_FOUND;
 260   for (TempHeaderPtr = MemoryHeader; TempHeaderPtr != NULL; TempHeaderPtr = TempHeaderPtr->Next) {
 261
 262     Status = AllocMemInMemoryBlock (
 263               TempHeaderPtr,
 264               (VOID **) Pool,
 265               RealAllocSize / 32
 266               );
 267     if (!EFI_ERROR (Status)) {
 268       ZeroMem (*Pool, AllocSize);
 269       gBS->RestoreTPL (OldTpl);
 270       return EFI_SUCCESS;
 271     }
 272   }
 273
 274   gBS->RestoreTPL (OldTpl);
 275
 276   //
 277   // There is no enough memory,
 278   // Create a new Memory Block
 279   //
 280
 281   //
 282   // if pool size is larger than NORMAL_MEMORY_BLOCK_UNIT_IN_PAGES,
 283   // just allocate a large enough memory block.
 284   //
 285   if (RealAllocSize > EFI_PAGES_TO_SIZE (NORMAL_MEMORY_BLOCK_UNIT_IN_PAGES)) {
 286     MemoryBlockSizeInPages = EFI_SIZE_TO_PAGES (RealAllocSize) + 1;
 287   } else {
 288     MemoryBlockSizeInPages = NORMAL_MEMORY_BLOCK_UNIT_IN_PAGES;
 289   }
 290
 291   Status = CreateMemoryBlock (HcDev, &NewMemoryHeader, MemoryBlockSizeInPages);
 292   if (EFI_ERROR (Status)) {
 293     return Status;
 294   }
 295
 296   OldTpl = gBS->RaiseTPL (EFI_TPL_NOTIFY + 1);
 297
 298   //
 299   // Link the new Memory Block to the Memory Header list
 300   //
 301   InsertMemoryHeaderToList (MemoryHeader, NewMemoryHeader);
 302
 303   Status = AllocMemInMemoryBlock (
 304              NewMemoryHeader,
 305              (VOID **) Pool,
 306              RealAllocSize / 32
 307              );
 308   if (!EFI_ERROR (Status)) {
 309     ZeroMem (*Pool, AllocSize);
 310   }
 311
 312   gBS->RestoreTPL (OldTpl);
 313   return Status;
 314 }
 315
 316 VOID
 317 EhciFreePool (
 318   IN USB2_HC_DEV     *HcDev,
 319   IN UINT8           *Pool,
 320   IN UINTN           AllocSize
 321   )
 322 /*++
 323
 324 Routine Description:
 325
 326   Uhci Free Pool
 327
 328 Arguments:
 329
 330   HcDev     - USB_HC_DEV
 331   Pool      - Pool to free
 332   AllocSize - Pool size
 333
 334 Returns:
 335
 336   VOID
 337
 338 --*/
 339 {
 340   MEMORY_MANAGE_HEADER  *MemoryHeader;
 341   MEMORY_MANAGE_HEADER  *TempHeaderPtr;
 342   UINTN                 StartBytePos;
 343   UINTN                 Index;
 344   UINT8                 StartBitPos;
 345   UINT8                 Index2;
 346   UINTN                 Count;
 347   UINTN                 RealAllocSize;
 348   EFI_TPL               OldTpl;
 349
 350   OldTpl        = gBS->RaiseTPL (EFI_TPL_NOTIFY + 1);
 351
 352   MemoryHeader  = HcDev->MemoryHeader;
 353
 354   //
 355   // allocate unit is 32 byte (align on 32 byte)
 356   //
 357   if (AllocSize & 0x1F) {
 358     RealAllocSize = (AllocSize / 32 + 1) * 32;
 359   } else {
 360     RealAllocSize = AllocSize;
 361   }
 362
 363   //
 364   // scan the memory header linked list for
 365   // the asigned memory to free.
 366   //
 367   for (TempHeaderPtr = MemoryHeader; TempHeaderPtr != NULL; TempHeaderPtr = TempHeaderPtr->Next) {
 368
 369     if ((Pool >= TempHeaderPtr->MemoryBlockPtr) &&
 370         ((Pool + RealAllocSize) <= (TempHeaderPtr->MemoryBlockPtr + TempHeaderPtr->MemoryBlockSizeInBytes))
 371         ) {
 372       //
 373       // Pool is in the Memory Block area,
 374       // find the start byte and bit in the bit array
 375       //
 376       StartBytePos  = ((Pool - TempHeaderPtr->MemoryBlockPtr) / 32) / 8;
 377       StartBitPos   = (UINT8) (((Pool - TempHeaderPtr->MemoryBlockPtr) / 32) & 0x7);
 378
 379       //
 380       // reset associated bits in bit arry
 381       //
 382       for (Index = StartBytePos, Index2 = StartBitPos, Count = 0; Count < (RealAllocSize / 32); Count++) {
 383         TempHeaderPtr->BitArrayPtr[Index] ^= (UINT8) (bit (Index2));
 384         Index2++;
 385         if (Index2 == 8) {
 386           Index += 1;
 387           Index2 = 0;
 388         }
 389       }
 390       //
 391       // break the loop
 392       //
 393       break;
 394     }
 395   }
 396
 397   //
 398   // Release emptied memory blocks (only if the memory block is not
 399   // the first one in the memory header list
 400   //
 401   for (TempHeaderPtr = MemoryHeader->Next; TempHeaderPtr != NULL;) {
 402
 403     ASSERT (MemoryHeader->Next != NULL);
 404
 405     if (IsMemoryBlockEmptied (TempHeaderPtr)) {
 406
 407       DelinkMemoryBlock (MemoryHeader, TempHeaderPtr);
 408       //
 409       // when the TempHeaderPtr is freed in FreeMemoryHeader(),
 410       // the TempHeaderPtr is pointing to nonsense content.
 411       //
 412       gBS->RestoreTPL (OldTpl);
 413       FreeMemoryHeader (HcDev, TempHeaderPtr);
 414       OldTpl = gBS->RaiseTPL (EFI_TPL_NOTIFY + 1);
 415       //
 416       // reset the TempHeaderPtr, continue search for
 417       // another empty memory block.
 418       //
 419       TempHeaderPtr = MemoryHeader->Next;
 420       continue;
 421     }
 422
 423     TempHeaderPtr = TempHeaderPtr->Next;
 424   }
 425
 426   gBS->RestoreTPL (OldTpl);
 427 }
 428
 429 VOID
 430 InsertMemoryHeaderToList (
 431   IN MEMORY_MANAGE_HEADER     *MemoryHeader,
 432   IN MEMORY_MANAGE_HEADER     *NewMemoryHeader
 433   )
 434 /*++
 435
 436 Routine Description:
 437
 438   Insert Memory Header To List
 439
 440 Arguments:
 441
 442   MemoryHeader    - MEMORY_MANAGE_HEADER
 443   NewMemoryHeader - MEMORY_MANAGE_HEADER
 444
 445 Returns:
 446
 447   VOID
 448
 449 --*/
 450 {
 451   MEMORY_MANAGE_HEADER  *TempHeaderPtr;
 452
 453   for (TempHeaderPtr = MemoryHeader; TempHeaderPtr != NULL; TempHeaderPtr = TempHeaderPtr->Next) {
 454     if (TempHeaderPtr->Next == NULL) {
 455       TempHeaderPtr->Next = NewMemoryHeader;
 456       break;
 457     }
 458   }
 459 }
 460
 461 EFI_STATUS
 462 AllocMemInMemoryBlock (
 463   IN  MEMORY_MANAGE_HEADER     *MemoryHeader,
 464   OUT VOID                     **Pool,
 465   IN  UINTN                    NumberOfMemoryUnit
 466   )
 467 /*++
 468
 469 Routine Description:
 470
 471   Alloc Memory In MemoryBlock
 472
 473 Arguments:
 474
 475   MemoryHeader        - MEMORY_MANAGE_HEADER
 476   Pool                - Place to store pointer to memory
 477   NumberOfMemoryUnit  - Number Of Memory Unit
 478
 479 Returns:
 480
 481   EFI_SUCCESS    Success
 482   EFI_NOT_FOUND  Can't find the free memory
 483
 484 --*/
 485 {
 486   UINTN TempBytePos;
 487   UINTN FoundBytePos;
 488   UINT8 Index;
 489   UINT8 FoundBitPos;
 490   UINT8 ByteValue;
 491   UINT8 BitValue;
 492   UINTN NumberOfZeros;
 493   UINTN Count;
 494
 495   FoundBytePos  = 0;
 496   FoundBitPos   = 0;
 497   ByteValue     = MemoryHeader->BitArrayPtr[0];
 498   NumberOfZeros = 0;
 499   Index         = 0;
 500
 501   for (TempBytePos = 0; TempBytePos < MemoryHeader->BitArraySizeInBytes;) {
 502
 503     //
 504     // Pop out BitValue from a byte in TempBytePos.
 505     //
 506     BitValue = (UINT8) (ByteValue & 0x1);
 507
 508     //
 509     // right shift the byte
 510     //
 511     ByteValue /= 2;
 512
 513     if (BitValue == 0) {
 514       //
 515       // Found a free bit, the NumberOfZeros only record the number
 516       // of those consecutive zeros
 517       //
 518       NumberOfZeros++;
 519       //
 520       // Found enough consecutive free space, break the loop
 521       //
 522       if (NumberOfZeros >= NumberOfMemoryUnit) {
 523         break;
 524       }
 525     } else {
 526       //
 527       // Encountering a '1', meant the bit is ocupied.
 528       //
 529       if (NumberOfZeros >= NumberOfMemoryUnit) {
 530         //
 531         // Found enough consecutive free space,break the loop
 532         //
 533         break;
 534       } else {
 535         //
 536         // the NumberOfZeros only record the number of those consecutive zeros,
 537         // so reset the NumberOfZeros to 0 when encountering '1' before finding
 538         // enough consecutive '0's
 539         //
 540         NumberOfZeros = 0;
 541         //
 542         // reset the (FoundBytePos,FoundBitPos) to the position of '1'
 543         //
 544         FoundBytePos  = TempBytePos;
 545         FoundBitPos   = Index;
 546       }
 547     }
 548
 549     //
 550     // step forward a bit
 551     //
 552     Index++;
 553     if (Index == 8) {
 554       //
 555       // step forward a byte, getting the byte value,
 556       // and reset the bit pos.
 557       //
 558       TempBytePos += 1;
 559       ByteValue = MemoryHeader->BitArrayPtr[TempBytePos];
 560       Index     = 0;
 561     }
 562   }
 563
 564   if (NumberOfZeros < NumberOfMemoryUnit) {
 565     return EFI_NOT_FOUND;
 566   }
 567
 568   //
 569   // Found enough free space.
 570   //
 571
 572   //
 573   // The values recorded in (FoundBytePos,FoundBitPos) have two conditions:
 574   //  1)(FoundBytePos,FoundBitPos) record the position
 575   //    of the last '1' before the consecutive '0's, it must
 576   //    be adjusted to the start position of the consecutive '0's.
 577   //  2)the start address of the consecutive '0's is just the start of
 578   //    the bitarray. so no need to adjust the values of
 579   //    (FoundBytePos,FoundBitPos).
 580   //
 581   if ((MemoryHeader->BitArrayPtr[FoundBytePos] & bit (FoundBitPos)) != 0) {
 582     FoundBitPos += 1;
 583   }
 584
 585   //
 586   // Have the (FoundBytePos,FoundBitPos) make sense.
 587   //
 588   if (FoundBitPos > 7) {
 589     FoundBytePos += 1;
 590     FoundBitPos -= 8;
 591   }
 592
 593   //
 594   // Set the memory as allocated
 595   //
 596   for (TempBytePos = FoundBytePos, Index = FoundBitPos, Count = 0; Count < NumberOfMemoryUnit; Count++) {
 597
 598     MemoryHeader->BitArrayPtr[TempBytePos] |= bit (Index);
 599     Index++;
 600     if (Index == 8) {
 601       TempBytePos += 1;
 602       Index = 0;
 603     }
 604   }
 605
 606   *Pool = MemoryHeader->MemoryBlockPtr + (FoundBytePos * 8 + FoundBitPos) * 32;
 607
 608   return EFI_SUCCESS;
 609 }
 610
 611 BOOLEAN
 612 IsMemoryBlockEmptied (
 613   IN MEMORY_MANAGE_HEADER     *MemoryHeaderPtr
 614   )
 615 /*++
 616
 617 Routine Description:
 618
 619   Is Memory Block Emptied
 620
 621 Arguments:
 622
 623   MemoryHeaderPtr - MEMORY_MANAGE_HEADER
 624
 625 Returns:
 626
 627   TRUE    Empty
 628   FALSE   Not Empty
 629
 630 --*/
 631 {
 632   UINTN Index;
 633
 634   for (Index = 0; Index < MemoryHeaderPtr->BitArraySizeInBytes; Index++) {
 635     if (MemoryHeaderPtr->BitArrayPtr[Index] != 0) {
 636       return FALSE;
 637     }
 638   }
 639
 640   return TRUE;
 641 }
 642
 643 VOID
 644 DelinkMemoryBlock (
 645   IN MEMORY_MANAGE_HEADER     *FirstMemoryHeader,
 646   IN MEMORY_MANAGE_HEADER     *NeedFreeMemoryHeader
 647   )
 648 /*++
 649
 650 Routine Description:
 651
 652   Delink Memory Block
 653
 654 Arguments:
 655
 656   FirstMemoryHeader     - MEMORY_MANAGE_HEADER
 657   NeedFreeMemoryHeader  - MEMORY_MANAGE_HEADER
 658
 659 Returns:
 660
 661   VOID
 662
 663 --*/
 664 {
 665   MEMORY_MANAGE_HEADER  *TempHeaderPtr;
 666
 667   if ((FirstMemoryHeader == NULL) || (NeedFreeMemoryHeader == NULL)) {
 668     return ;
 669   }
 670
 671   for (TempHeaderPtr = FirstMemoryHeader; TempHeaderPtr != NULL; TempHeaderPtr = TempHeaderPtr->Next) {
 672
 673     if (TempHeaderPtr->Next == NeedFreeMemoryHeader) {
 674       //
 675       // Link the before and after
 676       //
 677       TempHeaderPtr->Next = NeedFreeMemoryHeader->Next;
 678       break;
 679     }
 680   }
 681 }
 682
 683 EFI_STATUS
 684 InitialMemoryManagement (
 685   IN USB2_HC_DEV     *HcDev
 686   )
 687 /*++
 688
 689 Routine Description:
 690
 691   Initialize Memory Management
 692
 693 Arguments:
 694
 695   HcDev  - USB2_HC_DEV
 696
 697 Returns:
 698
 699   EFI_SUCCESS        Success
 700   EFI_DEVICE_ERROR   Fail
 701
 702 --*/
 703 {
 704   EFI_STATUS            Status;
 705   MEMORY_MANAGE_HEADER  *MemoryHeader;
 706   UINTN                 MemPages;
 707
 708   MemPages  = NORMAL_MEMORY_BLOCK_UNIT_IN_PAGES;
 709   Status    = CreateMemoryBlock (HcDev, &MemoryHeader, MemPages);
 710   if (EFI_ERROR (Status)) {
 711     Status = EFI_OUT_OF_RESOURCES;
 712     goto exit;
 713   }
 714
 715   HcDev->MemoryHeader = MemoryHeader;
 716
 717 exit:
 718   return Status;
 719 }
 720
 721 EFI_STATUS
 722 DeinitialMemoryManagement (
 723   IN USB2_HC_DEV     *HcDev
 724   )
 725 /*++
 726
 727 Routine Description:
 728
 729   Deinitialize Memory Management
 730
 731 Arguments:
 732
 733   HcDev   - USB2_HC_DEV
 734
 735 Returns:
 736
 737   EFI_SUCCESS        Success
 738   EFI_DEVICE_ERROR   Fail
 739
 740 --*/
 741 {
 742   MEMORY_MANAGE_HEADER  *TempHeaderPtr;
 743
 744   for (TempHeaderPtr = HcDev->MemoryHeader->Next; TempHeaderPtr != NULL;) {
 745
 746     DelinkMemoryBlock (HcDev->MemoryHeader, TempHeaderPtr);
 747     //
 748     // when the TempHeaderPtr is freed in FreeMemoryHeader(),
 749     // the TempHeaderPtr is pointing to nonsense content.
 750     //
 751     FreeMemoryHeader (HcDev, TempHeaderPtr);
 752     //
 753     // reset the TempHeaderPtr,continue free another memory block.
 754     //
 755     TempHeaderPtr = HcDev->MemoryHeader->Next;
 756   }
 757
 758   FreeMemoryHeader (HcDev, HcDev->MemoryHeader);
 759
 760   return EFI_SUCCESS;
 761 }