QuarkSocPkg/QuarkSouthCluster/Usb/Ohci/Dxe/OhciUrb.c

   1 /** @file
   2 This file contains URB request, each request is warpped in a
   3 URB (Usb Request Block).
   4
   5 Copyright (c) 2013-2015 Intel Corporation.
   6
   7 This program and the accompanying materials
   8 are licensed and made available under the terms and conditions of the BSD License
   9 which accompanies this distribution.  The full text of the license may be found at
  10 http://opensource.org/licenses/bsd-license.php
  11
  12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17
  18
  19 #include "Ohci.h"
  20
  21
  22 /**
  23
  24   Create a TD
  25
  26   @Param  Ohc                   UHC private data
  27
  28   @retval                       TD structure pointer
  29
  30 **/
  31 TD_DESCRIPTOR *
  32 OhciCreateTD (
  33   IN USB_OHCI_HC_DEV      *Ohc
  34   )
  35 {
  36   TD_DESCRIPTOR           *Td;
  37
  38   Td = UsbHcAllocateMem(Ohc->MemPool, sizeof(TD_DESCRIPTOR));
  39   if (Td == NULL) {
  40     DEBUG ((EFI_D_INFO, "STV allocate TD fail !\r\n"));
  41     return NULL;
  42   }
  43   Td->CurrBufferPointer = 0;
  44   Td->NextTD = 0;
  45   Td->BufferEndPointer = 0;
  46   Td->NextTDPointer = 0;
  47
  48   return Td;
  49 }
  50
  51
  52 /**
  53
  54   Free a TD
  55
  56   @Param  Ohc                   UHC private data
  57   @Param  Td                    Pointer to a TD to free
  58
  59   @retval  EFI_SUCCESS          TD freed
  60
  61 **/
  62 EFI_STATUS
  63 OhciFreeTD (
  64   IN USB_OHCI_HC_DEV      *Ohc,
  65   IN TD_DESCRIPTOR        *Td
  66   )
  67 {
  68   if (Td == NULL) {
  69     return EFI_SUCCESS;
  70   }
  71   UsbHcFreeMem(Ohc->MemPool, Td, sizeof(TD_DESCRIPTOR));
  72
  73   return EFI_SUCCESS;
  74 }
  75
  76
  77 /**
  78
  79   Create a ED
  80
  81   @Param   Ohc                  Device private data
  82
  83   @retval  ED                   descriptor pointer
  84
  85 **/
  86 ED_DESCRIPTOR *
  87 OhciCreateED (
  88   USB_OHCI_HC_DEV          *Ohc
  89   )
  90 {
  91   ED_DESCRIPTOR   *Ed;
  92   Ed = UsbHcAllocateMem(Ohc->MemPool, sizeof (ED_DESCRIPTOR));
  93   if (Ed == NULL) {
  94     DEBUG ((EFI_D_INFO, "STV allocate ED fail !\r\n"));
  95     return NULL;
  96   }
  97   Ed->Word0.Skip = 1;
  98   Ed->TdTailPointer = 0;
  99   Ed->Word2.TdHeadPointer = 0;
 100   Ed->NextED = 0;
 101
 102   return Ed;
 103 }
 104
 105 /**
 106
 107   Free a ED
 108
 109   @Param  Ohc                   UHC private data
 110   @Param  Ed                    Pointer to a ED to free
 111
 112   @retval  EFI_SUCCESS          ED freed
 113
 114 **/
 115
 116 EFI_STATUS
 117 OhciFreeED (
 118   IN USB_OHCI_HC_DEV      *Ohc,
 119   IN ED_DESCRIPTOR        *Ed
 120   )
 121 {
 122   if (Ed == NULL) {
 123     return EFI_SUCCESS;
 124   }
 125   UsbHcFreeMem(Ohc->MemPool, Ed, sizeof(ED_DESCRIPTOR));
 126
 127   return EFI_SUCCESS;
 128 }
 129
 130 /**
 131
 132   Free  ED
 133
 134   @Param  Ohc                    Device private data
 135   @Param  Ed                     Pointer to a ED to free
 136
 137   @retval  EFI_SUCCESS           ED freed
 138
 139 **/
 140 EFI_STATUS
 141 OhciFreeAllTDFromED (
 142   IN USB_OHCI_HC_DEV      *Ohc,
 143   IN ED_DESCRIPTOR        *Ed
 144   )
 145 {
 146   TD_DESCRIPTOR           *HeadTd;
 147   TD_DESCRIPTOR           *TailTd;
 148   TD_DESCRIPTOR           *Td;
 149   TD_DESCRIPTOR           *TempTd;
 150
 151   if (Ed == NULL) {
 152     return EFI_SUCCESS;
 153   }
 154
 155   HeadTd = TD_PTR (Ed->Word2.TdHeadPointer);
 156   TailTd = (TD_DESCRIPTOR *)(UINTN)(Ed->TdTailPointer);
 157
 158   Td = HeadTd;
 159   while (Td != TailTd) {
 160     TempTd = Td;
 161     Td = (TD_DESCRIPTOR *)(UINTN)(Td->NextTDPointer);
 162     OhciFreeTD (Ohc, TempTd);
 163   }
 164
 165   return EFI_SUCCESS;
 166 }
 167
 168 /**
 169
 170   Find a working ED match the requirement
 171
 172   @Param  EdHead                Head of the ED list
 173   @Param  DeviceAddress         Device address to search
 174   @Param  EndPointNum           End point num to search
 175   @Param  EdDir                 ED Direction to search
 176
 177   @retval   ED descriptor searched
 178
 179 **/
 180
 181 ED_DESCRIPTOR *
 182 OhciFindWorkingEd (
 183   IN ED_DESCRIPTOR       *EdHead,
 184   IN UINT8               DeviceAddress,
 185   IN UINT8               EndPointNum,
 186   IN UINT8               EdDir
 187   )
 188 {
 189   ED_DESCRIPTOR           *Ed;
 190
 191   for (Ed = EdHead; Ed != NULL; Ed = (ED_DESCRIPTOR *)(UINTN)(Ed->NextED)) {
 192     if (Ed->Word2.Halted == 0 && Ed->Word0.Skip == 0 &&
 193         Ed->Word0.FunctionAddress == DeviceAddress && Ed->Word0.EndPointNum == EndPointNum &&
 194         Ed->Word0.Direction == EdDir) {
 195       break;
 196     }
 197   }
 198
 199   return Ed;
 200 }
 201
 202
 203 /**
 204
 205   Initialize interrupt list.
 206
 207   @Param Ohc                    Device private data
 208
 209   @retval  EFI_SUCCESS          Initialization done
 210
 211 **/
 212 EFI_STATUS
 213 OhciInitializeInterruptList (
 214   USB_OHCI_HC_DEV          *Ohc
 215   )
 216 {
 217   static UINT32     Leaf[32] = {0, 16, 8, 24, 4, 20, 12, 28, 2, 18, 10, 26, 6, 22, 14, 30, 1, 17,
 218                                 9, 25, 5, 21, 13, 29, 3, 19, 11, 27, 7, 23, 15, 31};
 219   UINT32            *HccaInterruptTable;
 220   UINTN             Index;
 221   UINTN             Level;
 222   UINTN             Count;
 223   ED_DESCRIPTOR     *NewEd;
 224
 225   HccaInterruptTable = Ohc->HccaMemoryBlock->HccaInterruptTable;
 226
 227   for (Index = 0; Index < 32; Index++) {
 228     NewEd = OhciCreateED (Ohc);
 229     if (NewEd == NULL) {
 230       return EFI_OUT_OF_RESOURCES;
 231     }
 232     HccaInterruptTable[Index] = (UINT32)(UINTN)NewEd;
 233   }
 234
 235   for (Index = 0; Index < 32; Index++) {
 236     Ohc->IntervalList[0][Index] = (ED_DESCRIPTOR *)(UINTN)HccaInterruptTable[Leaf[Index]];
 237   }
 238
 239   Count = 32;
 240   for (Level = 1; Level <= 5; Level++) {
 241     Count = Count >> 1;
 242
 243     for (Index = 0; Index < Count; Index++) {
 244       Ohc->IntervalList[Level][Index] = OhciCreateED (Ohc);
 245       if (HccaInterruptTable[Index] == 0) {
 246         return EFI_OUT_OF_RESOURCES;
 247       }
 248       Ohc->IntervalList[Level - 1][Index * 2    ]->NextED = (UINT32)(UINTN)Ohc->IntervalList[Level][Index];
 249       Ohc->IntervalList[Level - 1][Index * 2 + 1]->NextED = (UINT32)(UINTN)Ohc->IntervalList[Level][Index];
 250     }
 251   }
 252
 253   return EFI_SUCCESS;
 254 }
 255
 256 /**
 257
 258   Attach an ED
 259
 260   @Param  Ed                    Ed to be attached
 261   @Param  NewEd                 Ed to attach
 262
 263   @retval EFI_SUCCESS           NewEd attached to Ed
 264   @retval EFI_INVALID_PARAMETER Ed is NULL
 265
 266 **/
 267 EFI_STATUS
 268 OhciAttachED (
 269   IN ED_DESCRIPTOR        *Ed,
 270   IN ED_DESCRIPTOR        *NewEd
 271   )
 272 {
 273   ED_DESCRIPTOR           *Temp;
 274
 275   if (Ed == NULL) {
 276     return EFI_INVALID_PARAMETER;
 277   }
 278
 279   if (Ed->NextED == 0){
 280     Ed->NextED = (UINT32)(UINTN)NewEd;
 281   } else {
 282     Temp = (ED_DESCRIPTOR *)(UINTN)(Ed->NextED);
 283     Ed->NextED = (UINT32)(UINTN)NewEd;
 284     NewEd->NextED = (UINT32)(UINTN)Temp;
 285   }
 286
 287   return EFI_SUCCESS;
 288 }
 289
 290
 291 /**
 292
 293   Count ED number on a ED chain
 294
 295   @Param  Ed                    Head of the ED chain
 296
 297   @retval                       ED number on the chain
 298
 299 **/
 300
 301 UINTN
 302 CountEdNum (
 303   IN ED_DESCRIPTOR      *Ed
 304   )
 305 {
 306   UINTN     Count;
 307
 308   Count = 0;
 309
 310   while (Ed) {
 311     Ed = (ED_DESCRIPTOR *)(UINTN)(Ed->NextED);
 312     Count++;
 313   }
 314
 315   return Count;
 316 }
 317
 318 /**
 319
 320   Find the minimal burn ED list on a specific depth level
 321
 322   @Param  Ohc                   Device private data
 323   @Param  Depth                 Depth level
 324
 325   @retval                       ED list found
 326
 327 **/
 328
 329 ED_DESCRIPTOR *
 330 OhciFindMinInterruptEDList (
 331   IN USB_OHCI_HC_DEV      *Ohc,
 332   IN UINT32               Depth
 333   )
 334 {
 335   UINTN                   EdNum;
 336   UINTN                   MinEdNum;
 337   ED_DESCRIPTOR           *TempEd;
 338   ED_DESCRIPTOR           *HeadEd;
 339   UINTN                   Index;
 340
 341   if (Depth > 5) {
 342     return NULL;
 343   }
 344
 345   MinEdNum = 0xFFFFFFFF;
 346   TempEd = NULL;
 347   for (Index = 0; Index < (UINTN)(32 >> Depth); Index++) {
 348     HeadEd = Ohc->IntervalList[Depth][Index];
 349     EdNum = CountEdNum (HeadEd);
 350     if (EdNum < MinEdNum) {
 351       MinEdNum = EdNum;
 352       TempEd = HeadEd;
 353     }
 354   }
 355
 356   ASSERT (TempEd != NULL);
 357
 358   return TempEd;
 359 }
 360
 361
 362 /**
 363
 364   Attach an ED to an ED list
 365
 366   @Param  OHC                   UHC private data
 367   @Param  ListType              Type of the ED list
 368   @Param  Ed                    ED to attach
 369   @Param  EdList                ED list to be attached
 370
 371   @retval  EFI_SUCCESS          ED attached to ED list
 372
 373 **/
 374 ED_DESCRIPTOR *
 375 OhciAttachEDToList (
 376   IN USB_OHCI_HC_DEV       *Ohc,
 377   IN DESCRIPTOR_LIST_TYPE  ListType,
 378   IN ED_DESCRIPTOR         *Ed,
 379   IN ED_DESCRIPTOR         *EdList
 380   )
 381 {
 382   ED_DESCRIPTOR            *HeadEd;
 383
 384   HeadEd = NULL;
 385   switch(ListType) {
 386     case CONTROL_LIST:
 387       HeadEd = (ED_DESCRIPTOR *) OhciGetMemoryPointer (Ohc, HC_CONTROL_HEAD);
 388       if (HeadEd == NULL) {
 389         OhciSetMemoryPointer (Ohc, HC_CONTROL_HEAD, Ed);
 390         HeadEd = Ed;
 391       } else {
 392         OhciAttachED (HeadEd, Ed);
 393       }
 394     break;
 395
 396     case BULK_LIST:
 397       HeadEd = (ED_DESCRIPTOR *) OhciGetMemoryPointer (Ohc, HC_BULK_HEAD);
 398       if (HeadEd == NULL) {
 399         OhciSetMemoryPointer (Ohc, HC_BULK_HEAD, Ed);
 400         HeadEd = Ed;
 401       } else {
 402         OhciAttachED (HeadEd, Ed);
 403       }
 404     break;
 405
 406     case INTERRUPT_LIST:
 407       OhciAttachED (EdList, Ed);
 408       break;
 409
 410     default:
 411       ASSERT (FALSE);
 412   }
 413
 414   return HeadEd;
 415 }
 416
 417 /**
 418
 419   Remove interrupt EDs that match requirement
 420
 421   @Param  Ohc                   UHC private data
 422   @Param  IntEd                 The address of Interrupt endpoint
 423
 424   @retval  EFI_SUCCESS          EDs match requirement removed
 425
 426 **/
 427
 428 EFI_STATUS
 429 OhciFreeInterruptEdByEd (
 430   IN USB_OHCI_HC_DEV      *Ohc,
 431   IN ED_DESCRIPTOR        *IntEd
 432   )
 433 {
 434   ED_DESCRIPTOR           *Ed;
 435   ED_DESCRIPTOR           *TempEd;
 436   UINTN                   Index;
 437
 438   if (IntEd == NULL)
 439     return EFI_SUCCESS;
 440
 441   for (Index = 0; Index < 32; Index++) {
 442     Ed = (ED_DESCRIPTOR *)(UINTN)Ohc->HccaMemoryBlock->HccaInterruptTable[Index];
 443     if (Ed == NULL) {
 444       continue;
 445     }
 446     while (Ed->NextED != 0) {
 447       if (Ed->NextED == (UINT32)(UINTN)IntEd ) {
 448         TempEd = (ED_DESCRIPTOR *)(UINTN)(Ed->NextED);
 449         Ed->NextED = TempEd->NextED;
 450         OhciFreeED (Ohc, TempEd);
 451       } else {
 452         Ed = (ED_DESCRIPTOR *)(UINTN)(Ed->NextED);
 453       }
 454     }
 455   }
 456   return EFI_SUCCESS;
 457 }
 458
 459 /**
 460
 461   Remove interrupt EDs that match requirement
 462
 463   @Param  Ohc                   UHC private data
 464   @Param  FunctionAddress       Requirement on function address
 465   @Param  EndPointNum           Requirement on end point number
 466
 467   @retval  EFI_SUCCESS          EDs match requirement removed
 468
 469 **/
 470 EFI_STATUS
 471 OhciFreeInterruptEdByAddr (
 472   IN USB_OHCI_HC_DEV      *Ohc,
 473   IN UINT8                FunctionAddress,
 474   IN UINT8                EndPointNum
 475   )
 476 {
 477   ED_DESCRIPTOR           *Ed;
 478   ED_DESCRIPTOR           *TempEd;
 479   UINTN                   Index;
 480
 481   for (Index = 0; Index < 32; Index++) {
 482     Ed = (ED_DESCRIPTOR *)(UINTN)Ohc->HccaMemoryBlock->HccaInterruptTable[Index];
 483     if (Ed == NULL) {
 484       continue;
 485     }
 486
 487     while (Ed->NextED != 0) {
 488       TempEd = (ED_DESCRIPTOR *)(UINTN)(Ed->NextED);
 489       if (TempEd->Word0.FunctionAddress == FunctionAddress &&
 490           TempEd->Word0.EndPointNum     == EndPointNum        ) {
 491         Ed->NextED = TempEd->NextED;
 492         OhciFreeED (Ohc, TempEd);
 493       } else {
 494         Ed = (ED_DESCRIPTOR *)(UINTN)(Ed->NextED);
 495       }
 496     }
 497   }
 498
 499   return EFI_SUCCESS;
 500 }
 501
 502
 503 /**
 504
 505   Link Td2 to the end of Td1
 506
 507   @Param Td1                    TD to be linked
 508   @Param Td2                    TD to link
 509
 510   @retval EFI_SUCCESS           TD successfully linked
 511   @retval EFI_INVALID_PARAMETER Td1 is NULL
 512
 513 **/
 514 EFI_STATUS
 515 OhciLinkTD (
 516   IN TD_DESCRIPTOR        *Td1,
 517   IN TD_DESCRIPTOR        *Td2
 518   )
 519 {
 520   TD_DESCRIPTOR           *TempTd;
 521
 522   if (Td1 == NULL) {
 523     return EFI_INVALID_PARAMETER;
 524   }
 525
 526   if (Td1 == Td2) {
 527     return EFI_SUCCESS;
 528   }
 529
 530   TempTd = Td1;
 531   while (TempTd->NextTD != 0) {
 532     TempTd = (TD_DESCRIPTOR *)(UINTN)(TempTd->NextTD);
 533   }
 534
 535   TempTd->NextTD = (UINT32)(UINTN)Td2;
 536   TempTd->NextTDPointer = (UINT32)(UINTN)Td2;
 537
 538   return EFI_SUCCESS;
 539 }
 540
 541
 542 /**
 543
 544   Attach TD list to ED
 545
 546   @Param  Ed                    ED which TD list attach on
 547   @Param  HeadTd                Head of the TD list to attach
 548
 549   @retval  EFI_SUCCESS          TD list attached on the ED
 550
 551 **/
 552 EFI_STATUS
 553 OhciAttachTDListToED (
 554   IN ED_DESCRIPTOR        *Ed,
 555   IN TD_DESCRIPTOR        *HeadTd
 556   )
 557 {
 558   TD_DESCRIPTOR           *TempTd;
 559
 560   TempTd = TD_PTR (Ed->Word2.TdHeadPointer);
 561
 562   if (TempTd != NULL) {
 563     while (TempTd->NextTD != 0) {
 564       TempTd = (TD_DESCRIPTOR *)(UINTN)(TempTd->NextTD);
 565     }
 566     TempTd->NextTD = (UINT32)(UINTN)HeadTd;
 567     TempTd->NextTDPointer = (UINT32)(UINTN)HeadTd;
 568   } else {
 569     Ed->Word2.TdHeadPointer = RIGHT_SHIFT_4 ((UINT32)(UINTN)HeadTd);
 570   }
 571
 572   return EFI_SUCCESS;
 573 }
 574
 575
 576 /**
 577
 578   Set value to ED specific field
 579
 580   @Param  Ed                    ED to be set
 581   @Param  Field                 Field to be set
 582   @Param  Value                 Value to set
 583
 584   @retval  EFI_SUCCESS          Value set
 585
 586 **/
 587 EFI_STATUS
 588 OhciSetEDField (
 589   IN ED_DESCRIPTOR        *Ed,
 590   IN UINT32               Field,
 591   IN UINT32               Value
 592   )
 593 {
 594   if (Field & ED_FUNC_ADD) {
 595     Ed->Word0.FunctionAddress = Value;
 596   }
 597   if (Field & ED_ENDPT_NUM) {
 598     Ed->Word0.EndPointNum = Value;
 599   }
 600   if (Field & ED_DIR) {
 601     Ed->Word0.Direction = Value;
 602   }
 603   if (Field & ED_SPEED) {
 604     Ed->Word0.Speed = Value;
 605   }
 606   if (Field & ED_SKIP) {
 607     Ed->Word0.Skip = Value;
 608   }
 609   if (Field & ED_FORMAT) {
 610     Ed->Word0.Format = Value;
 611   }
 612   if (Field & ED_MAX_PACKET) {
 613     Ed->Word0.MaxPacketSize = Value;
 614   }
 615   if (Field & ED_PDATA) {
 616     Ed->Word0.FreeSpace = Value;
 617   }
 618   if (Field & ED_ZERO) {
 619     Ed->Word2.Zero = Value;
 620   }
 621   if (Field & ED_TDTAIL_PTR) {
 622     Ed->TdTailPointer = Value;
 623   }
 624
 625   if (Field & ED_HALTED) {
 626     Ed->Word2.Halted = Value;
 627   }
 628   if (Field & ED_DTTOGGLE) {
 629     Ed->Word2.ToggleCarry = Value;
 630   }
 631   if (Field & ED_TDHEAD_PTR) {
 632     Ed->Word2.TdHeadPointer = RIGHT_SHIFT_4 (Value);
 633   }
 634
 635   if (Field & ED_NEXT_EDPTR) {
 636     Ed->NextED = Value;
 637   }
 638
 639   return EFI_SUCCESS;
 640 }
 641
 642 /**
 643
 644   Get value from an ED's specific field
 645
 646   @Param  Ed                    ED pointer
 647   @Param  Field                 Field to get value from
 648
 649   @retval                       Value of the field
 650
 651 **/
 652 UINT32
 653 OhciGetEDField (
 654   IN ED_DESCRIPTOR        *Ed,
 655   IN UINT32               Field
 656   )
 657 {
 658   switch (Field) {
 659     case ED_FUNC_ADD:
 660       return Ed->Word0.FunctionAddress;
 661       break;
 662     case ED_ENDPT_NUM:
 663       return Ed->Word0.EndPointNum;
 664       break;
 665     case ED_DIR:
 666       return Ed->Word0.Direction;
 667       break;
 668     case ED_SPEED:
 669       return Ed->Word0.Speed;
 670       break;
 671     case ED_SKIP:
 672       return Ed->Word0.Skip;
 673       break;
 674     case ED_FORMAT:
 675       return Ed->Word0.Format;
 676       break;
 677     case ED_MAX_PACKET:
 678       return Ed->Word0.MaxPacketSize;
 679       break;
 680
 681     case ED_TDTAIL_PTR:
 682       return Ed->TdTailPointer;
 683       break;
 684
 685     case ED_HALTED:
 686       return Ed->Word2.Halted;
 687       break;
 688
 689     case ED_DTTOGGLE:
 690       return Ed->Word2.ToggleCarry;
 691       break;
 692
 693     case ED_TDHEAD_PTR:
 694       return Ed->Word2.TdHeadPointer << 4;
 695       break;
 696
 697     case ED_NEXT_EDPTR:
 698       return Ed->NextED;
 699       break;
 700
 701     default:
 702       ASSERT (FALSE);
 703   }
 704
 705   return 0;
 706 }
 707
 708
 709 /**
 710
 711   Set value to TD specific field
 712
 713   @Param  Td                    TD to be set
 714   @Param  Field                 Field to be set
 715   @Param  Value                 Value to set
 716
 717   @retval  EFI_SUCCESS          Value set
 718
 719 **/
 720 EFI_STATUS
 721 OhciSetTDField (
 722   IN TD_DESCRIPTOR        *Td,
 723   IN UINT32               Field,
 724   IN UINT32               Value
 725   )
 726 {
 727   if (Field & TD_PDATA) {
 728     Td->Word0.Reserved = Value;
 729   }
 730   if (Field & TD_BUFFER_ROUND) {
 731     Td->Word0.BufferRounding = Value;
 732   }
 733   if (Field & TD_DIR_PID) {
 734     Td->Word0.DirPID = Value;
 735   }
 736   if (Field & TD_DELAY_INT) {
 737     Td->Word0.DelayInterrupt = Value;
 738   }
 739   if (Field & TD_DT_TOGGLE) {
 740     Td->Word0.DataToggle = Value | 0x2;
 741   }
 742   if (Field & TD_ERROR_CNT) {
 743     Td->Word0.ErrorCount = Value;
 744   }
 745   if (Field & TD_COND_CODE) {
 746     Td->Word0.ConditionCode = Value;
 747   }
 748
 749   if (Field & TD_CURR_BUFFER_PTR) {
 750     Td->CurrBufferPointer = Value;
 751   }
 752
 753
 754   if (Field & TD_NEXT_PTR) {
 755     Td->NextTD = Value;
 756   }
 757
 758   if (Field & TD_BUFFER_END_PTR) {
 759     Td->BufferEndPointer = Value;
 760   }
 761
 762   return EFI_SUCCESS;
 763 }
 764
 765
 766 /**
 767
 768   Get value from ED specific field
 769
 770   @Param  Td                    TD pointer
 771   @Param  Field                 Field to get value from
 772
 773   @retval                       Value of the field
 774
 775 **/
 776
 777 UINT32
 778 OhciGetTDField (
 779   IN TD_DESCRIPTOR      *Td,
 780   IN UINT32             Field
 781   )
 782 {
 783   switch (Field){
 784     case TD_BUFFER_ROUND:
 785       return Td->Word0.BufferRounding;
 786       break;
 787     case TD_DIR_PID:
 788       return Td->Word0.DirPID;
 789       break;
 790     case TD_DELAY_INT:
 791       return Td->Word0.DelayInterrupt;
 792       break;
 793     case TD_DT_TOGGLE:
 794       return Td->Word0.DataToggle;
 795       break;
 796     case TD_ERROR_CNT:
 797       return Td->Word0.ErrorCount;
 798       break;
 799     case TD_COND_CODE:
 800       return Td->Word0.ConditionCode;
 801       break;
 802     case TD_CURR_BUFFER_PTR:
 803       return Td->CurrBufferPointer;
 804       break;
 805
 806     case TD_NEXT_PTR:
 807       return Td->NextTD;
 808       break;
 809
 810     case TD_BUFFER_END_PTR:
 811       return Td->BufferEndPointer;
 812       break;
 813
 814     default:
 815       ASSERT (FALSE);
 816   }
 817
 818   return 0;
 819 }
 820
 821 /**
 822
 823   Free the Ed,Td,buffer that were created during transferring
 824
 825   @Param  Ohc                   Device private data
 826 **/
 827
 828 VOID
 829 OhciFreeDynamicIntMemory(
 830   IN USB_OHCI_HC_DEV      *Ohc
 831   )
 832 {
 833   INTERRUPT_CONTEXT_ENTRY *Entry;
 834   if (Ohc != NULL) {
 835     while (Ohc->InterruptContextList != NULL) {
 836       Entry = Ohc->InterruptContextList;
 837       Ohc->InterruptContextList = Ohc->InterruptContextList->NextEntry;
 838       OhciFreeInterruptEdByEd (Ohc, Entry->Ed);
 839       OhciFreeInterruptContextEntry (Ohc, Entry);
 840     }
 841   }
 842 }
 843 /**
 844
 845   Free the Ed that were initilized during driver was starting,
 846   those memory were used as interrupt ED head
 847
 848   @Param  Ohc                   Device private data
 849
 850
 851 **/
 852 VOID
 853 OhciFreeFixedIntMemory (
 854   IN USB_OHCI_HC_DEV      *Ohc
 855   )
 856 {
 857   static UINT32           Leaf[] = {32,16,8,4,2,1};
 858   UINTN                   Index;
 859   UINTN                   Level;
 860
 861   for (Level = 0; Level < 6; Level++) {
 862     for (Index = 0; Index < Leaf[Level]; Index++) {
 863       if (Ohc->IntervalList[Level][Index] != NULL) {
 864         UsbHcFreeMem(Ohc->MemPool, Ohc->IntervalList[Level][Index], sizeof(ED_DESCRIPTOR));
 865       }
 866     }
 867   }
 868 }
 869 /**
 870
 871   Release all OHCI used memory when OHCI going to quit
 872
 873   @Param  Ohc                   Device private data
 874
 875   @retval EFI_SUCCESS          Memory released
 876
 877 **/
 878
 879 EFI_STATUS
 880 OhciFreeIntTransferMemory (
 881   IN USB_OHCI_HC_DEV           *Ohc
 882   )
 883 {
 884   //
 885   // Free the Ed,Td,buffer that were created during transferring
 886   //
 887   OhciFreeDynamicIntMemory (Ohc);
 888   //
 889   // Free the Ed that were initilized during driver was starting
 890   //
 891   OhciFreeFixedIntMemory (Ohc);
 892   return EFI_SUCCESS;
 893 }
 894
 895