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

   1 /** @file
   2 The OHCI register operation routines.
   3
   4 Copyright (c) 2013-2015 Intel Corporation.
   5
   6 SPDX-License-Identifier: BSD-2-Clause-Patent
   7
   8 **/
   9
  10
  11 #include "Ohci.h"
  12
  13 /**
  14
  15   Get OHCI operational reg value
  16
  17   @param  PciIo                 PciIo protocol instance
  18   @param  Offset                Offset of the operational reg
  19
  20   @retval                       Value of the register
  21
  22 **/
  23 UINT32
  24 OhciGetOperationalReg (
  25   IN EFI_PCI_IO_PROTOCOL  *PciIo,
  26   IN UINT32               Offset
  27   )
  28 {
  29   UINT32                  Value;
  30
  31   PciIo->Mem.Read(PciIo, EfiPciIoWidthUint32, OHC_BAR_INDEX, Offset, 1, &Value);
  32
  33   return Value;
  34 }
  35 /**
  36
  37   Set OHCI operational reg value
  38
  39   @param  PciIo                  PCI Bus Io protocol instance
  40   @param  Offset                 Offset of the operational reg
  41   @param  Value                  Value to set
  42
  43   @retval EFI_SUCCESS            Value set to the reg
  44
  45 **/
  46
  47
  48 EFI_STATUS
  49 OhciSetOperationalReg (
  50   IN EFI_PCI_IO_PROTOCOL  *PciIo,
  51   IN UINT32               Offset,
  52   IN VOID                 *Value
  53   )
  54 {
  55   EFI_STATUS Status;
  56
  57   Status = PciIo->Mem.Write(PciIo, EfiPciIoWidthUint32, OHC_BAR_INDEX, Offset, 1, Value);
  58
  59   return Status;
  60 }
  61 /**
  62
  63   Get HcRevision reg value
  64
  65   @param  PciIo                 PCI Bus Io protocol instance
  66
  67   @retval                       Value of the register
  68
  69 **/
  70
  71
  72 UINT32
  73 OhciGetHcRevision (
  74   IN EFI_PCI_IO_PROTOCOL  *PciIo
  75   )
  76 {
  77   return OhciGetOperationalReg (PciIo, HC_REVISION);
  78 }
  79 /**
  80
  81   Set HcReset reg value
  82
  83   @param  Ohc                   UHC private data
  84   @param  Field                 Field to set
  85   @param  Value                 Value to set
  86
  87   @retval EFI_SUCCESS           Value set
  88
  89 **/
  90
  91 EFI_STATUS
  92 OhciSetHcReset (
  93   IN USB_OHCI_HC_DEV            *Ohc,
  94   IN UINT32                     Field,
  95   IN UINT32                     Value
  96   )
  97 {
  98   HcRESET                       Reset;
  99
 100   *(UINT32 *) &Reset = OhciGetOperationalReg (Ohc->PciIo, USBHOST_OFFSET_UHCHR);
 101
 102   if (Field & RESET_SYSTEM_BUS) {
 103     Reset.FSBIR = Value;
 104   }
 105
 106   if (Field & RESET_HOST_CONTROLLER) {
 107     Reset.FHR = Value;
 108   }
 109
 110   if (Field & RESET_CLOCK_GENERATION) {
 111     Reset.CGR = Value;
 112   }
 113
 114   if (Field & RESET_SSE_GLOBAL) {
 115     Reset.SSE = Value;
 116   }
 117
 118   if (Field & RESET_PSPL) {
 119     Reset.PSPL = Value;
 120   }
 121
 122   if (Field & RESET_PCPL) {
 123     Reset.PCPL = Value;
 124   }
 125
 126   if (Field & RESET_SSEP1) {
 127     Reset.SSEP1 = Value;
 128   }
 129
 130   if (Field & RESET_SSEP2) {
 131     Reset.SSEP2 = Value;
 132   }
 133
 134   if (Field & RESET_SSEP3) {
 135     Reset.SSEP3 = Value;
 136   }
 137
 138   OhciSetOperationalReg (Ohc->PciIo, USBHOST_OFFSET_UHCHR, &Reset);
 139
 140   return EFI_SUCCESS;
 141 }
 142
 143 /**
 144
 145   Get specific field of HcReset reg value
 146
 147   @param  Ohc                   UHC private data
 148   @param  Field                 Field to get
 149
 150   @retval                       Value of the field
 151
 152 **/
 153
 154 UINT32
 155 OhciGetHcReset (
 156   IN USB_OHCI_HC_DEV      *Ohc,
 157   IN UINT32               Field
 158   )
 159 {
 160   HcRESET                 Reset;
 161   UINT32                  Value;
 162
 163
 164   *(UINT32 *) &Reset = OhciGetOperationalReg (Ohc->PciIo, USBHOST_OFFSET_UHCHR);
 165   Value = 0;
 166
 167   switch (Field) {
 168   case RESET_SYSTEM_BUS:
 169     Value = Reset.FSBIR;
 170     break;
 171
 172   case RESET_HOST_CONTROLLER:
 173     Value = Reset.FHR;
 174     break;
 175
 176   case RESET_CLOCK_GENERATION:
 177     Value = Reset.CGR;
 178     break;
 179
 180   case RESET_SSE_GLOBAL:
 181     Value = Reset.SSE;
 182     break;
 183
 184   case RESET_PSPL:
 185     Value = Reset.PSPL;
 186     break;
 187
 188   case RESET_PCPL:
 189     Value = Reset.PCPL;
 190     break;
 191
 192   case RESET_SSEP1:
 193     Value = Reset.SSEP1;
 194     break;
 195
 196   case RESET_SSEP2:
 197     Value = Reset.SSEP2;
 198     break;
 199
 200   case RESET_SSEP3:
 201     Value = Reset.SSEP3;
 202     break;
 203
 204   default:
 205     ASSERT (FALSE);
 206   }
 207
 208
 209   return Value;
 210 }
 211
 212 /**
 213
 214   Set HcControl reg value
 215
 216   @param  Ohc                   UHC private data
 217   @param  Field                 Field to set
 218   @param  Value                 Value to set
 219
 220   @retval  EFI_SUCCESS          Value set
 221
 222 **/
 223
 224 EFI_STATUS
 225 OhciSetHcControl (
 226   IN USB_OHCI_HC_DEV      *Ohc,
 227   IN UINTN                Field,
 228   IN UINT32               Value
 229   )
 230 {
 231   EFI_STATUS              Status;
 232   HcCONTROL               Control;
 233
 234
 235
 236   *(UINT32 *) &Control = OhciGetOperationalReg (Ohc->PciIo, HC_CONTROL);
 237
 238   if (Field & CONTROL_BULK_RATIO) {
 239     Control.ControlBulkRatio = Value;
 240   }
 241
 242   if (Field & HC_FUNCTIONAL_STATE) {
 243     Control.FunctionalState = Value;
 244   }
 245
 246   if (Field & PERIODIC_ENABLE) {
 247     Control.PeriodicEnable = Value;
 248   }
 249
 250   if (Field & CONTROL_ENABLE) {
 251     Control.ControlEnable = Value;
 252   }
 253
 254   if (Field & ISOCHRONOUS_ENABLE) {
 255     Control.IsochronousEnable = Value;
 256   }
 257
 258   if (Field & BULK_ENABLE) {
 259     Control.BulkEnable = Value;
 260   }
 261
 262   if (Field & INTERRUPT_ROUTING) {
 263     Control.InterruptRouting = Value;
 264   }
 265
 266   Status = OhciSetOperationalReg (Ohc->PciIo, HC_CONTROL, &Control);
 267
 268   return Status;
 269 }
 270
 271
 272 /**
 273
 274   Get specific field of HcControl reg value
 275
 276   @param  Ohc                   UHC private data
 277   @param  Field                 Field to get
 278
 279   @retval                       Value of the field
 280
 281 **/
 282
 283
 284 UINT32
 285 OhciGetHcControl (
 286   IN USB_OHCI_HC_DEV   *Ohc,
 287   IN UINTN             Field
 288   )
 289 {
 290   HcCONTROL     Control;
 291
 292   *(UINT32 *) &Control = OhciGetOperationalReg (Ohc->PciIo, HC_CONTROL);
 293
 294   switch (Field) {
 295   case CONTROL_BULK_RATIO:
 296     return Control.ControlBulkRatio;
 297     break;
 298   case PERIODIC_ENABLE:
 299     return Control.PeriodicEnable;
 300     break;
 301   case CONTROL_ENABLE:
 302     return Control.ControlEnable;
 303     break;
 304   case BULK_ENABLE:
 305     return Control.BulkEnable;
 306     break;
 307   case ISOCHRONOUS_ENABLE:
 308     return Control.IsochronousEnable;
 309     break;
 310   case HC_FUNCTIONAL_STATE:
 311     return Control.FunctionalState;
 312     break;
 313   case INTERRUPT_ROUTING:
 314     return Control.InterruptRouting;
 315     break;
 316   default:
 317     ASSERT (FALSE);
 318   }
 319
 320   return 0;
 321 }
 322
 323 /**
 324
 325   Set HcCommand reg value
 326
 327   @param  Ohc                   UHC private data
 328   @param  Field                 Field to set
 329   @param  Value                 Value to set
 330
 331   @retval EFI_SUCCESS           Value set
 332
 333 **/
 334
 335 EFI_STATUS
 336 OhciSetHcCommandStatus (
 337   IN USB_OHCI_HC_DEV      *Ohc,
 338   IN UINTN                Field,
 339   IN UINT32               Value
 340   )
 341 {
 342   EFI_STATUS              Status;
 343   HcCOMMAND_STATUS        CommandStatus;
 344
 345   ZeroMem (&CommandStatus, sizeof (HcCOMMAND_STATUS));
 346
 347   if(Field & HC_RESET){
 348     CommandStatus.HcReset = Value;
 349   }
 350
 351   if(Field & CONTROL_LIST_FILLED){
 352     CommandStatus.ControlListFilled = Value;
 353   }
 354
 355   if(Field & BULK_LIST_FILLED){
 356     CommandStatus.BulkListFilled = Value;
 357   }
 358
 359   if(Field & CHANGE_OWNER_REQUEST){
 360     CommandStatus.ChangeOwnerRequest = Value;
 361   }
 362
 363   if(Field & SCHEDULE_OVERRUN_COUNT){
 364     CommandStatus.ScheduleOverrunCount = Value;
 365   }
 366
 367   Status = OhciSetOperationalReg (Ohc->PciIo, HC_COMMAND_STATUS, &CommandStatus);
 368
 369   return Status;
 370 }
 371
 372 /**
 373
 374   Get specific field of HcCommand reg value
 375
 376   @param  Ohc                   UHC private data
 377   @param  Field                 Field to get
 378
 379   @retval                       Value of the field
 380
 381 **/
 382
 383 UINT32
 384 OhciGetHcCommandStatus (
 385   IN USB_OHCI_HC_DEV      *Ohc,
 386   IN UINTN                Field
 387   )
 388 {
 389   HcCOMMAND_STATUS        CommandStatus;
 390
 391   *(UINT32 *) &CommandStatus = OhciGetOperationalReg (Ohc->PciIo, HC_COMMAND_STATUS);
 392
 393   switch (Field){
 394   case HC_RESET:
 395     return CommandStatus.HcReset;
 396     break;
 397   case CONTROL_LIST_FILLED:
 398     return CommandStatus.ControlListFilled;
 399     break;
 400   case BULK_LIST_FILLED:
 401     return CommandStatus.BulkListFilled;
 402     break;
 403   case CHANGE_OWNER_REQUEST:
 404     return CommandStatus.ChangeOwnerRequest;
 405     break;
 406   case SCHEDULE_OVERRUN_COUNT:
 407     return CommandStatus.ScheduleOverrunCount;
 408     break;
 409   default:
 410     ASSERT (FALSE);
 411   }
 412
 413   return 0;
 414 }
 415
 416 /**
 417
 418   Clear specific fields of Interrupt Status
 419
 420   @param  Ohc                   UHC private data
 421   @param  Field                 Field to clear
 422
 423   @retval EFI_SUCCESS           Fields cleared
 424
 425 **/
 426
 427 EFI_STATUS
 428 OhciClearInterruptStatus (
 429   IN USB_OHCI_HC_DEV      *Ohc,
 430   IN UINTN                Field
 431   )
 432 {
 433   EFI_STATUS              Status;
 434   HcINTERRUPT_STATUS      InterruptStatus;
 435
 436   ZeroMem (&InterruptStatus, sizeof (HcINTERRUPT_STATUS));
 437
 438   if(Field & SCHEDULE_OVERRUN){
 439     InterruptStatus.SchedulingOverrun = 1;
 440   }
 441
 442   if(Field & WRITEBACK_DONE_HEAD){
 443     InterruptStatus.WriteBackDone = 1;
 444   }
 445   if(Field & START_OF_FRAME){
 446     InterruptStatus.Sof = 1;
 447   }
 448
 449   if(Field & RESUME_DETECT){
 450     InterruptStatus.ResumeDetected = 1;
 451   }
 452
 453   if(Field & UNRECOVERABLE_ERROR){
 454     InterruptStatus.UnrecoverableError = 1;
 455   }
 456
 457   if(Field & FRAME_NUMBER_OVERFLOW){
 458     InterruptStatus.FrameNumOverflow = 1;
 459   }
 460
 461   if(Field & ROOTHUB_STATUS_CHANGE){
 462     InterruptStatus.RHStatusChange = 1;
 463   }
 464
 465   if(Field & OWNERSHIP_CHANGE){
 466     InterruptStatus.OwnerChange = 1;
 467   }
 468
 469   Status = OhciSetOperationalReg (Ohc->PciIo, HC_INTERRUPT_STATUS, &InterruptStatus);
 470
 471   return Status;
 472 }
 473
 474 /**
 475
 476   Get fields of HcInterrupt reg value
 477
 478   @param  Ohc                   UHC private data
 479   @param  Field                 Field to get
 480
 481   @retval                       Value of the field
 482
 483 **/
 484
 485 UINT32
 486 OhciGetHcInterruptStatus (
 487   IN USB_OHCI_HC_DEV      *Ohc,
 488   IN UINTN                Field
 489   )
 490 {
 491   HcINTERRUPT_STATUS      InterruptStatus;
 492
 493   *(UINT32 *) &InterruptStatus = OhciGetOperationalReg (Ohc->PciIo, HC_INTERRUPT_STATUS);
 494
 495   switch (Field){
 496   case SCHEDULE_OVERRUN:
 497     return InterruptStatus.SchedulingOverrun;
 498     break;
 499
 500   case  WRITEBACK_DONE_HEAD:
 501     return InterruptStatus.WriteBackDone;
 502     break;
 503
 504   case START_OF_FRAME:
 505     return InterruptStatus.Sof;
 506     break;
 507
 508   case RESUME_DETECT:
 509     return InterruptStatus.ResumeDetected;
 510     break;
 511
 512   case UNRECOVERABLE_ERROR:
 513     return InterruptStatus.UnrecoverableError;
 514     break;
 515
 516   case FRAME_NUMBER_OVERFLOW:
 517     return InterruptStatus.FrameNumOverflow;
 518     break;
 519
 520   case ROOTHUB_STATUS_CHANGE:
 521     return InterruptStatus.RHStatusChange;
 522     break;
 523
 524   case OWNERSHIP_CHANGE:
 525     return InterruptStatus.OwnerChange;
 526     break;
 527
 528   default:
 529     ASSERT (FALSE);
 530   }
 531
 532   return 0;
 533 }
 534
 535 /**
 536
 537   Set Interrupt Control reg value
 538
 539   @param  Ohc                   UHC private data
 540   @param  StatEnable            Enable or Disable
 541   @param  Field                 Field to set
 542   @param  Value                 Value to set
 543
 544   @retval EFI_SUCCESS           Value set
 545
 546 **/
 547
 548 EFI_STATUS
 549 OhciSetInterruptControl (
 550   IN USB_OHCI_HC_DEV      *Ohc,
 551   IN BOOLEAN              StatEnable,
 552   IN UINTN                Field,
 553   IN UINT32               Value
 554   )
 555 {
 556   EFI_STATUS              Status;
 557   HcINTERRUPT_CONTROL     InterruptState;
 558
 559
 560   ZeroMem (&InterruptState, sizeof (HcINTERRUPT_CONTROL));
 561
 562   if(Field & SCHEDULE_OVERRUN) {
 563     InterruptState.SchedulingOverrunInt = Value;
 564   }
 565
 566   if(Field & WRITEBACK_DONE_HEAD) {
 567     InterruptState.WriteBackDoneInt = Value;
 568   }
 569   if(Field & START_OF_FRAME) {
 570     InterruptState.SofInt = Value;
 571   }
 572
 573   if(Field & RESUME_DETECT) {
 574     InterruptState.ResumeDetectedInt = Value;
 575   }
 576
 577   if(Field & UNRECOVERABLE_ERROR) {
 578     InterruptState.UnrecoverableErrorInt = Value;
 579   }
 580
 581   if(Field & FRAME_NUMBER_OVERFLOW) {
 582     InterruptState.FrameNumOverflowInt = Value;
 583   }
 584
 585   if(Field & ROOTHUB_STATUS_CHANGE) {
 586     InterruptState.RHStatusChangeInt = Value;
 587   }
 588
 589   if(Field & OWNERSHIP_CHANGE) {
 590     InterruptState.OwnerChangedInt = Value;
 591   }
 592
 593   if(Field & MASTER_INTERRUPT) {
 594     InterruptState.MasterInterruptEnable = Value;
 595   }
 596
 597   if (StatEnable) {
 598     Status = OhciSetOperationalReg (Ohc->PciIo, HC_INTERRUPT_ENABLE, &InterruptState);
 599   } else {
 600     Status = OhciSetOperationalReg (Ohc->PciIo, HC_INTERRUPT_DISABLE, &InterruptState);
 601   }
 602
 603   return Status;
 604 }
 605
 606 /**
 607
 608   Get field of HcInterruptControl reg value
 609
 610   @param  Ohc                   UHC private data
 611   @param  Field                 Field to get
 612
 613   @retval                       Value of the field
 614
 615 **/
 616
 617 UINT32
 618 OhciGetHcInterruptControl (
 619   IN USB_OHCI_HC_DEV      *Ohc,
 620   IN UINTN                Field
 621   )
 622 {
 623   HcINTERRUPT_CONTROL     InterruptState;
 624
 625   *(UINT32 *) &InterruptState = OhciGetOperationalReg (Ohc->PciIo, HC_INTERRUPT_ENABLE);
 626
 627   switch (Field){
 628     case SCHEDULE_OVERRUN:
 629       return InterruptState.SchedulingOverrunInt;
 630       break;
 631
 632     case WRITEBACK_DONE_HEAD:
 633       return InterruptState.WriteBackDoneInt;
 634       break;
 635
 636     case START_OF_FRAME:
 637       return InterruptState.SofInt;
 638       break;
 639
 640     case RESUME_DETECT:
 641       return InterruptState.ResumeDetectedInt;
 642       break;
 643
 644     case UNRECOVERABLE_ERROR:
 645       return InterruptState.UnrecoverableErrorInt;
 646       break;
 647
 648     case FRAME_NUMBER_OVERFLOW:
 649       return InterruptState.FrameNumOverflowInt;
 650       break;
 651
 652     case ROOTHUB_STATUS_CHANGE:
 653       return InterruptState.RHStatusChangeInt;
 654       break;
 655
 656     case OWNERSHIP_CHANGE:
 657       return InterruptState.OwnerChangedInt;
 658       break;
 659
 660     case MASTER_INTERRUPT:
 661       return InterruptState.MasterInterruptEnable;
 662       break;
 663
 664     default:
 665       ASSERT (FALSE);
 666   }
 667
 668   return 0;
 669 }
 670
 671 /**
 672
 673   Set memory pointer of specific type
 674
 675   @param  Ohc                   UHC private data
 676   @param  PointerType           Type of the pointer to set
 677   @param  Value                 Value to set
 678
 679   @retval EFI_SUCCESS           Memory pointer set
 680
 681 **/
 682
 683 EFI_STATUS
 684 OhciSetMemoryPointer(
 685   IN USB_OHCI_HC_DEV      *Ohc,
 686   IN UINT32               PointerType,
 687   IN VOID                 *Value
 688   )
 689 {
 690   EFI_STATUS              Status;
 691   UINT32                  Verify;
 692
 693   Status = OhciSetOperationalReg (Ohc->PciIo, PointerType, &Value);
 694
 695   if (EFI_ERROR (Status)) {
 696     return Status;
 697   }
 698
 699   Verify = OhciGetOperationalReg (Ohc->PciIo, PointerType);
 700
 701   while (Verify != (UINT32)(UINTN) Value) {
 702     gBS->Stall(1000);
 703     Verify = OhciGetOperationalReg (Ohc->PciIo, PointerType);
 704   };
 705
 706
 707   return Status;
 708 }
 709
 710 /**
 711
 712   Get memory pointer of specific type
 713
 714   @param  Ohc                   UHC private data
 715   @param  PointerType           Type of pointer
 716
 717   @retval                       Memory pointer of the specific type
 718
 719 **/
 720
 721 VOID *
 722 OhciGetMemoryPointer (
 723   IN USB_OHCI_HC_DEV      *Ohc,
 724   IN UINT32               PointerType
 725   )
 726 {
 727
 728   return (VOID *)(UINTN) OhciGetOperationalReg (Ohc->PciIo, PointerType);
 729 }
 730
 731
 732 /**
 733
 734   Set Frame Interval value
 735
 736   @param  Ohc                   UHC private data
 737   @param  Field                 Field to set
 738   @param  Value                 Value to set
 739
 740   @retval  EFI_SUCCESS          Value set
 741
 742 **/
 743
 744 EFI_STATUS
 745 OhciSetFrameInterval (
 746   IN USB_OHCI_HC_DEV      *Ohc,
 747   IN UINTN                Field,
 748   IN UINT32               Value
 749   )
 750 {
 751   EFI_STATUS              Status;
 752   HcFRM_INTERVAL          FrameInterval;
 753
 754
 755   *(UINT32 *) &FrameInterval = OhciGetOperationalReg(Ohc->PciIo, HC_FRM_INTERVAL);
 756
 757   if (Field & FRAME_INTERVAL) {
 758     FrameInterval.FrmIntervalToggle = !FrameInterval.FrmIntervalToggle;
 759     FrameInterval.FrameInterval = Value;
 760   }
 761
 762   if (Field & FS_LARGEST_DATA_PACKET) {
 763     FrameInterval.FSMaxDataPacket = Value;
 764   }
 765
 766   if (Field & FRMINT_TOGGLE) {
 767     FrameInterval.FrmIntervalToggle = Value;
 768   }
 769
 770   Status = OhciSetOperationalReg (
 771              Ohc->PciIo,
 772              HC_FRM_INTERVAL,
 773              &FrameInterval
 774              );
 775
 776   return Status;
 777 }
 778
 779
 780 /**
 781
 782   Get field of frame interval reg value
 783
 784   @param  Ohc                   UHC private data
 785   @param  Field                 Field to get
 786
 787   @retval                       Value of the field
 788
 789 **/
 790
 791 UINT32
 792 OhciGetFrameInterval (
 793   IN USB_OHCI_HC_DEV      *Ohc,
 794   IN UINTN                Field
 795   )
 796 {
 797   HcFRM_INTERVAL          FrameInterval;
 798
 799   *(UINT32 *) &FrameInterval = OhciGetOperationalReg (Ohc->PciIo, HC_FRM_INTERVAL);
 800
 801   switch (Field){
 802     case FRAME_INTERVAL:
 803       return FrameInterval.FrameInterval;
 804       break;
 805
 806     case FS_LARGEST_DATA_PACKET:
 807       return FrameInterval.FSMaxDataPacket;
 808       break;
 809
 810     case FRMINT_TOGGLE:
 811       return FrameInterval.FrmIntervalToggle;
 812       break;
 813
 814     default:
 815       ASSERT (FALSE);
 816   }
 817
 818   return 0;
 819 }
 820
 821 /**
 822
 823   Set Frame Remaining reg value
 824
 825   @param  Ohc                   UHC private data
 826   @param  Value                 Value to set
 827
 828   @retval  EFI_SUCCESS          Value set
 829
 830 **/
 831
 832 EFI_STATUS
 833 OhciSetFrameRemaining (
 834   IN USB_OHCI_HC_DEV      *Ohc,
 835   IN UINT32               Value
 836   )
 837 {
 838   EFI_STATUS              Status;
 839   HcFRAME_REMAINING       FrameRemaining;
 840
 841
 842   *(UINT32 *) &FrameRemaining = OhciGetOperationalReg (Ohc->PciIo, HC_FRM_REMAINING);
 843
 844   FrameRemaining.FrameRemaining = Value;
 845   FrameRemaining.FrameRemainingToggle = !FrameRemaining.FrameRemainingToggle;
 846
 847   Status = OhciSetOperationalReg (Ohc->PciIo, HC_FRM_REMAINING, &FrameRemaining);
 848
 849   return Status;
 850 }
 851 /**
 852
 853   Get value of frame remaining reg
 854
 855   @param  Ohc                   UHC private data
 856   @param  Field                 Field to get
 857
 858   @retval                       Value of frame remaining reg
 859
 860 **/
 861 UINT32
 862 OhciGetFrameRemaining (
 863   IN USB_OHCI_HC_DEV      *Ohc,
 864   IN UINTN                Field
 865   )
 866
 867 {
 868   HcFRAME_REMAINING       FrameRemaining;
 869
 870
 871   *(UINT32 *) &FrameRemaining = OhciGetOperationalReg (Ohc->PciIo, HC_FRM_REMAINING);
 872
 873   switch (Field){
 874     case FRAME_REMAINING:
 875       return FrameRemaining.FrameRemaining;
 876       break;
 877
 878     case FRAME_REMAIN_TOGGLE:
 879       return FrameRemaining.FrameRemainingToggle;
 880       break;
 881
 882     default:
 883       ASSERT (FALSE);
 884   }
 885
 886   return 0;
 887 }
 888
 889 /**
 890
 891   Set frame number reg value
 892
 893   @param  Ohc                   UHC private data
 894   @param  Value                 Value to set
 895
 896   @retval  EFI_SUCCESS          Value set
 897
 898 **/
 899
 900 EFI_STATUS
 901 OhciSetFrameNumber(
 902   IN USB_OHCI_HC_DEV      *Ohc,
 903   IN UINT32               Value
 904   )
 905 {
 906   EFI_STATUS              Status;
 907
 908   Status = OhciSetOperationalReg (Ohc->PciIo, HC_FRM_NUMBER, &Value);
 909
 910   return Status;
 911 }
 912
 913 /**
 914
 915   Get frame number reg value
 916
 917   @param  Ohc                   UHC private data
 918
 919   @retval                       Value of frame number reg
 920
 921 **/
 922
 923 UINT32
 924 OhciGetFrameNumber (
 925   IN USB_OHCI_HC_DEV      *Ohc
 926   )
 927 {
 928   return OhciGetOperationalReg(Ohc->PciIo, HC_FRM_NUMBER);
 929 }
 930
 931 /**
 932
 933   Set period start reg value
 934
 935   @param  Ohc                   UHC private data
 936   @param  Value                 Value to set
 937
 938   @retval EFI_SUCCESS           Value set
 939
 940 **/
 941
 942 EFI_STATUS
 943 OhciSetPeriodicStart (
 944   IN USB_OHCI_HC_DEV      *Ohc,
 945   IN UINT32               Value
 946   )
 947 {
 948   EFI_STATUS              Status;
 949
 950
 951   Status = OhciSetOperationalReg (Ohc->PciIo, HC_PERIODIC_START, &Value);
 952
 953   return Status;
 954 }
 955
 956
 957 /**
 958
 959   Get periodic start reg value
 960
 961   @param  Ohc                   UHC private data
 962
 963   @param                        Value of periodic start reg
 964
 965 **/
 966
 967 UINT32
 968 OhciGetPeriodicStart (
 969   IN USB_OHCI_HC_DEV      *Ohc
 970   )
 971 {
 972   return OhciGetOperationalReg(Ohc->PciIo, HC_PERIODIC_START);
 973 }
 974
 975
 976 /**
 977
 978   Set Ls Threshold reg value
 979
 980   @param  Ohc                   UHC private data
 981   @param  Value                 Value to set
 982
 983   @retval  EFI_SUCCESS          Value set
 984
 985 **/
 986
 987 EFI_STATUS
 988 OhciSetLsThreshold (
 989   IN USB_OHCI_HC_DEV      *Ohc,
 990   IN UINT32               Value
 991   )
 992 {
 993   EFI_STATUS              Status;
 994
 995
 996   Status = OhciSetOperationalReg (Ohc->PciIo, HC_LS_THREASHOLD, &Value);
 997
 998   return Status;
 999 }
1000
1001
1002 /**
1003
1004   Get Ls Threshold reg value
1005
1006   @param  Ohc                   UHC private data
1007
1008   @retval                       Value of Ls Threshold reg
1009
1010 **/
1011
1012 UINT32
1013 OhciGetLsThreshold (
1014   IN USB_OHCI_HC_DEV      *Ohc
1015   )
1016 {
1017   return OhciGetOperationalReg(Ohc->PciIo, HC_LS_THREASHOLD);
1018 }
1019
1020 /**
1021
1022   Set Root Hub Descriptor reg value
1023
1024   @param  Ohc                   UHC private data
1025   @param  Field                 Field to set
1026   @param  Value                 Value to set
1027
1028   @retval  EFI_SUCCESS          Value set
1029
1030 **/
1031 EFI_STATUS
1032 OhciSetRootHubDescriptor (
1033   IN USB_OHCI_HC_DEV      *Ohc,
1034   IN UINTN                Field,
1035   IN UINT32               Value
1036   )
1037 {
1038   EFI_STATUS              Status;
1039   HcRH_DESC_A             DescriptorA;
1040   HcRH_DESC_B             DescriptorB;
1041
1042
1043   if (Field & (RH_DEV_REMOVABLE | RH_PORT_PWR_CTRL_MASK)) {
1044     *(UINT32 *) &DescriptorB = OhciGetOperationalReg (Ohc->PciIo, HC_RH_DESC_B);
1045
1046     if(Field & RH_DEV_REMOVABLE) {
1047       DescriptorB.DeviceRemovable = Value;
1048     }
1049     if(Field & RH_PORT_PWR_CTRL_MASK) {
1050       DescriptorB.PortPowerControlMask = Value;
1051     }
1052
1053     Status = OhciSetOperationalReg (Ohc->PciIo, HC_RH_DESC_B, &DescriptorB);
1054
1055     return Status;
1056   }
1057
1058   *(UINT32 *)&DescriptorA = OhciGetOperationalReg (Ohc->PciIo, HC_RH_DESC_A);
1059
1060   if(Field & RH_NUM_DS_PORTS) {
1061     DescriptorA.NumDownStrmPorts = Value;
1062   }
1063   if(Field & RH_NO_PSWITCH) {
1064     DescriptorA.NoPowerSwitch = Value;
1065   }
1066   if(Field & RH_PSWITCH_MODE) {
1067     DescriptorA.PowerSwitchMode = Value;
1068   }
1069   if(Field & RH_DEVICE_TYPE) {
1070     DescriptorA.DeviceType = Value;
1071   }
1072   if(Field & RH_OC_PROT_MODE) {
1073     DescriptorA.OverCurrentProtMode = Value;
1074   }
1075   if(Field & RH_NOC_PROT) {
1076     DescriptorA.NoOverCurrentProtMode = Value;
1077   }
1078   if(Field & RH_NO_POTPGT) {
1079     DescriptorA.PowerOnToPowerGoodTime = Value;
1080   }
1081
1082   Status = OhciSetOperationalReg (Ohc->PciIo, HC_RH_DESC_A, &DescriptorA);
1083
1084   return Status;
1085 }
1086
1087
1088 /**
1089
1090   Get Root Hub Descriptor reg value
1091
1092   @param  Ohc                   UHC private data
1093   @param  Field                 Field to get
1094
1095   @retval                       Value of the field
1096
1097 **/
1098
1099 UINT32
1100 OhciGetRootHubDescriptor (
1101   IN USB_OHCI_HC_DEV     *Ohc,
1102   IN UINTN               Field
1103   )
1104 {
1105   HcRH_DESC_A             DescriptorA;
1106   HcRH_DESC_B             DescriptorB;
1107
1108
1109   *(UINT32 *) &DescriptorA = OhciGetOperationalReg (Ohc->PciIo, HC_RH_DESC_A);
1110   *(UINT32 *) &DescriptorB = OhciGetOperationalReg (Ohc->PciIo, HC_RH_DESC_B);
1111
1112   switch (Field){
1113     case RH_DEV_REMOVABLE:
1114       return DescriptorB.DeviceRemovable;
1115       break;
1116
1117     case RH_PORT_PWR_CTRL_MASK:
1118       return DescriptorB.PortPowerControlMask;
1119       break;
1120
1121     case RH_NUM_DS_PORTS:
1122       return DescriptorA.NumDownStrmPorts;
1123       break;
1124
1125     case RH_NO_PSWITCH:
1126       return DescriptorA.NoPowerSwitch;
1127       break;
1128
1129     case RH_PSWITCH_MODE:
1130       return DescriptorA.PowerSwitchMode;
1131       break;
1132
1133     case RH_DEVICE_TYPE:
1134       return DescriptorA.DeviceType;
1135       break;
1136
1137     case RH_OC_PROT_MODE:
1138       return DescriptorA.OverCurrentProtMode;
1139       break;
1140
1141     case RH_NOC_PROT:
1142       return DescriptorA.NoOverCurrentProtMode;
1143       break;
1144
1145     case RH_NO_POTPGT:
1146       return DescriptorA.PowerOnToPowerGoodTime;
1147       break;
1148
1149     default:
1150       ASSERT (FALSE);
1151   }
1152
1153   return 0;
1154 }
1155
1156
1157 /**
1158
1159   Set Root Hub Status reg value
1160
1161   @param  Ohc                   UHC private data
1162   @param  Field                 Field to set
1163
1164   @retval  EFI_SUCCESS          Value set
1165
1166 **/
1167
1168 EFI_STATUS
1169 OhciSetRootHubStatus (
1170   IN USB_OHCI_HC_DEV      *Ohc,
1171   IN UINTN                Field
1172   )
1173 {
1174   EFI_STATUS              Status;
1175   HcRH_STATUS             RootHubStatus;
1176
1177
1178   ZeroMem (&RootHubStatus, sizeof(HcRH_STATUS));
1179
1180   if(Field & RH_LOCAL_PSTAT){
1181     RootHubStatus.LocalPowerStat = 1;
1182   }
1183   if(Field & RH_OC_ID){
1184     RootHubStatus.OverCurrentIndicator = 1;
1185   }
1186   if(Field & RH_REMOTE_WK_ENABLE){
1187     RootHubStatus.DevRemoteWakeupEnable = 1;
1188   }
1189   if(Field & RH_LOCAL_PSTAT_CHANGE){
1190     RootHubStatus.LocalPowerStatChange = 1;
1191   }
1192   if(Field & RH_OC_ID_CHANGE){
1193     RootHubStatus.OverCurrentIndicatorChange = 1;
1194   }
1195   if(Field & RH_CLR_RMT_WK_ENABLE){
1196     RootHubStatus.ClearRemoteWakeupEnable = 1;
1197   }
1198
1199   Status = OhciSetOperationalReg (Ohc->PciIo, HC_RH_STATUS, &RootHubStatus);
1200
1201   return Status;
1202 }
1203
1204
1205 /**
1206
1207   Get Root Hub Status reg value
1208
1209   @param  Ohc                   UHC private data
1210   @param  Field                 Field to get
1211
1212   @retval                       Value of the field
1213
1214 **/
1215
1216 UINT32
1217 OhciGetRootHubStatus (
1218   IN USB_OHCI_HC_DEV      *Ohc,
1219   IN UINTN                Field
1220   )
1221 {
1222   HcRH_STATUS             RootHubStatus;
1223
1224
1225   *(UINT32 *) &RootHubStatus = OhciGetOperationalReg (Ohc->PciIo, HC_RH_STATUS);
1226
1227   switch (Field) {
1228     case RH_LOCAL_PSTAT:
1229       return RootHubStatus.LocalPowerStat;
1230       break;
1231     case RH_OC_ID:
1232       return RootHubStatus.OverCurrentIndicator;
1233       break;
1234     case RH_REMOTE_WK_ENABLE:
1235       return RootHubStatus.DevRemoteWakeupEnable;
1236       break;
1237     case RH_LOCAL_PSTAT_CHANGE:
1238       return RootHubStatus.LocalPowerStatChange;
1239       break;
1240     case RH_OC_ID_CHANGE:
1241       return RootHubStatus.OverCurrentIndicatorChange;
1242       break;
1243     case RH_CLR_RMT_WK_ENABLE:
1244       return RootHubStatus.ClearRemoteWakeupEnable;
1245       break;
1246     default:
1247       ASSERT (FALSE);
1248   }
1249
1250   return 0;
1251 }
1252
1253
1254 /**
1255
1256   Set Root Hub Port Status reg value
1257
1258   @param  Ohc                   UHC private data
1259   @param  Index                 Index of the port
1260   @param  Field                 Field to set
1261
1262   @retval  EFI_SUCCESS          Value set
1263
1264 **/
1265
1266 EFI_STATUS
1267 OhciSetRootHubPortStatus (
1268   IN USB_OHCI_HC_DEV      *Ohc,
1269   IN UINT32               Index,
1270   IN UINTN                Field
1271   )
1272 {
1273   EFI_STATUS              Status;
1274   HcRHPORT_STATUS         PortStatus;
1275
1276
1277   ZeroMem (&PortStatus, sizeof(HcRHPORT_STATUS));
1278
1279   if (Field & RH_CLEAR_PORT_ENABLE) {
1280     PortStatus.CurrentConnectStat = 1;
1281   }
1282   if (Field & RH_SET_PORT_ENABLE) {
1283     PortStatus.EnableStat = 1;
1284   }
1285   if (Field & RH_SET_PORT_SUSPEND) {
1286     PortStatus.SuspendStat = 1;
1287   }
1288   if (Field & RH_CLEAR_SUSPEND_STATUS) {
1289     PortStatus.OCIndicator = 1;
1290   }
1291   if (Field & RH_SET_PORT_RESET) {
1292     PortStatus.ResetStat = 1;
1293   }
1294   if (Field & RH_SET_PORT_POWER) {
1295     PortStatus.PowerStat = 1;
1296   }
1297   if (Field & RH_CLEAR_PORT_POWER) {
1298     PortStatus.LsDeviceAttached = 1;
1299   }
1300   if (Field & RH_CONNECT_STATUS_CHANGE) {
1301     PortStatus.ConnectStatChange = 1;
1302   }
1303   if (Field & RH_PORT_ENABLE_STAT_CHANGE) {
1304     PortStatus.EnableStatChange = 1;
1305   }
1306   if (Field & RH_PORT_SUSPEND_STAT_CHANGE) {
1307     PortStatus.SuspendStatChange = 1;
1308   }
1309   if (Field & RH_OC_INDICATOR_CHANGE) {
1310     PortStatus.OCIndicatorChange = 1;
1311   }
1312   if (Field & RH_PORT_RESET_STAT_CHANGE ) {
1313     PortStatus.ResetStatChange = 1;
1314   }
1315
1316   Status = OhciSetOperationalReg (Ohc->PciIo, HC_RH_PORT_STATUS + (Index * 4), &PortStatus);
1317
1318   return Status;
1319 }
1320
1321
1322 /**
1323
1324   Get Root Hub Port Status reg value
1325
1326   @param  Ohc                   UHC private data
1327   @param  Index                 Index of the port
1328   @param  Field                 Field to get
1329
1330   @retval                       Value of the field and index
1331
1332 **/
1333
1334 UINT32
1335 OhciReadRootHubPortStatus (
1336   IN USB_OHCI_HC_DEV      *Ohc,
1337   IN UINT32               Index,
1338   IN UINTN                Field
1339   )
1340 {
1341   HcRHPORT_STATUS         PortStatus;
1342
1343   *(UINT32 *) &PortStatus = OhciGetOperationalReg (
1344                               Ohc->PciIo,
1345                               HC_RH_PORT_STATUS + (Index * 4)
1346                               );
1347
1348   switch (Field){
1349   case RH_CURR_CONNECT_STAT:
1350     return PortStatus.CurrentConnectStat;
1351     break;
1352   case RH_PORT_ENABLE_STAT:
1353     return PortStatus.EnableStat;
1354     break;
1355   case RH_PORT_SUSPEND_STAT:
1356     return PortStatus.SuspendStat;
1357     break;
1358   case RH_PORT_OC_INDICATOR:
1359     return PortStatus.OCIndicator;
1360     break;
1361   case RH_PORT_RESET_STAT:
1362     return PortStatus.ResetStat;
1363     break;
1364   case RH_PORT_POWER_STAT:
1365     return PortStatus.PowerStat;
1366     break;
1367   case RH_LSDEVICE_ATTACHED:
1368     return PortStatus.LsDeviceAttached;
1369     break;
1370   case RH_CONNECT_STATUS_CHANGE:
1371     return PortStatus.ConnectStatChange;
1372     break;
1373   case RH_PORT_ENABLE_STAT_CHANGE:
1374     return PortStatus.EnableStatChange;
1375     break;
1376   case RH_PORT_SUSPEND_STAT_CHANGE:
1377     return PortStatus.SuspendStatChange;
1378     break;
1379   case RH_OC_INDICATOR_CHANGE:
1380     return PortStatus.OCIndicatorChange;
1381     break;
1382   case RH_PORT_RESET_STAT_CHANGE:
1383     return PortStatus.ResetStatChange;
1384     break;
1385   default:
1386     ASSERT (FALSE);
1387   }
1388
1389   return 0;
1390 }