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