git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_A53_64-bit_UltraScale_MPSoC/RTOSDemo_A53_bsp/psu_cortexa53_0/libsrc/usbpsu_v1_1/src/xusbpsu.c

   1 /******************************************************************************
   2 *
   3 * Copyright (C) 2016 Xilinx, Inc.  All rights reserved.
   4 *
   5 * Permission is hereby granted, free of charge, to any person obtaining a copy
   6 * of this software and associated documentation files (the "Software"), to deal
   7 * in the Software without restriction, including without limitation the rights
   8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 * copies of the Software, and to permit persons to whom the Software is
  10 * furnished to do so, subject to the following conditions:
  11 *
  12 * The above copyright notice and this permission notice shall be included in
  13 * all copies or substantial portions of the Software.
  14 *
  15 * Use of the Software is limited solely to applications:
  16 * (a) running on a Xilinx device, or
  17 * (b) that interact with a Xilinx device through a bus or interconnect.
  18 *
  19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  22 * XILINX  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25 * SOFTWARE.
  26 *
  27 * Except as contained in this notice, the name of the Xilinx shall not be used
  28 * in advertising or otherwise to promote the sale, use or other dealings in
  29 * this Software without prior written authorization from Xilinx.
  30 *
  31 ******************************************************************************/
  32 /****************************************************************************/
  33 /**
  34 *
  35 * @file xusbpsu.c
  36 * @addtogroup usbpsu_v1_0
  37 * @{
  38 *
  39 * <pre>
  40 *
  41 * MODIFICATION HISTORY:
  42 *
  43 * Ver   Who    Date     Changes
  44 * ----- -----  -------- -----------------------------------------------------
  45 * 1.0   sg    06/16/16 First release
  46 * 1.1   sg    10/24/16 Added new function XUsbPsu_IsSuperSpeed
  47 *
  48 * </pre>
  49 *
  50 *****************************************************************************/
  51
  52 /***************************** Include Files ********************************/
  53
  54 #include "xusbpsu.h"
  55
  56 /************************** Constant Definitions *****************************/
  57
  58
  59 /**************************** Type Definitions *******************************/
  60
  61
  62 /***************** Macros (Inline Functions) Definitions *********************/
  63
  64
  65 /************************** Function Prototypes ******************************/
  66
  67
  68 /************************** Variable Definitions *****************************/
  69
  70 /*****************************************************************************/
  71 /**
  72 * Waits until a bit in a register is cleared or timeout occurs
  73 *
  74 * @param        InstancePtr is a pointer to the XUsbPsu instance to be worked on.
  75 * @param        Offset is register offset.
  76 * @param        BitMask is bit mask of required bit to be checked.
  77 * @param        Timeout is the time to wait specified in micro seconds.
  78 *
  79 * @return
  80 *                       - XST_SUCCESS when bit is cleared.
  81 *                       - XST_FAILURE when timed out.
  82 *
  83 ******************************************************************************/
  84 s32 XUsbPsu_Wait_Clear_Timeout(struct XUsbPsu *InstancePtr, u32 Offset,
  85                                                                 u32 BitMask, u32 Timeout)
  86 {
  87         u32 RegVal;
  88         u32 LocalTimeout = Timeout;
  89
  90         do {
  91                 RegVal = XUsbPsu_ReadReg(InstancePtr, Offset);
  92                 if ((RegVal & BitMask) == 0U) {
  93                         break;
  94                 }
  95                 LocalTimeout--;
  96                 if (LocalTimeout == 0U) {
  97                         return XST_FAILURE;
  98                 }
  99                 XUsbSleep(1U);
 100         } while (1);
 101
 102         return XST_SUCCESS;
 103 }
 104
 105 /*****************************************************************************/
 106 /**
 107 * Waits until a bit in a register is set or timeout occurs
 108 *
 109 * @param        InstancePtr is a pointer to the XUsbPsu instance to be worked on.
 110 * @param        Offset is register offset.
 111 * @param        BitMask is bit mask of required bit to be checked.
 112 * @param        Timeout is the time to wait specified in micro seconds.
 113 *
 114 * @return
 115 *                       - XST_SUCCESS when bit is set.
 116 *                       - XST_FAILURE when timed out.
 117 *
 118 ******************************************************************************/
 119 s32 XUsbPsu_Wait_Set_Timeout(struct XUsbPsu *InstancePtr, u32 Offset,
 120                                                                 u32 BitMask, u32 Timeout)
 121 {
 122         u32 RegVal;
 123         u32 LocalTimeout = Timeout;
 124
 125         do {
 126                 RegVal = XUsbPsu_ReadReg(InstancePtr, Offset);
 127                 if ((RegVal & BitMask) != 0U) {
 128                         break;
 129                 }
 130                 LocalTimeout--;
 131                 if (LocalTimeout == 0U) {
 132                         return XST_FAILURE;
 133                 }
 134                 XUsbSleep(1U);
 135         } while (1);
 136
 137         return XST_SUCCESS;
 138 }
 139
 140 /*****************************************************************************/
 141 /**
 142 * Sets mode of Core to USB Device/Host/OTG.
 143 *
 144 *
 145 * @param        InstancePtr is a pointer to the XUsbPsu instance to be worked on.
 146 * @param        Mode is mode to set
 147 *                       - XUSBPSU_GCTL_PRTCAP_OTG
 148 *                       - XUSBPSU_GCTL_PRTCAP_HOST
 149 *                       - XUSBPSU_GCTL_PRTCAP_DEVICE
 150 *
 151 * @return       None
 152 *
 153 ******************************************************************************/
 154 void XUsbPsu_SetMode(struct XUsbPsu *InstancePtr, u32 Mode)
 155 {
 156         u32 RegVal;
 157
 158         Xil_AssertVoid(InstancePtr != NULL);
 159         Xil_AssertVoid((Mode <= XUSBPSU_GCTL_PRTCAP_OTG) &&
 160                                         (Mode >= XUSBPSU_GCTL_PRTCAP_HOST));
 161
 162         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_GCTL);
 163         RegVal &= ~(XUSBPSU_GCTL_PRTCAPDIR(XUSBPSU_GCTL_PRTCAP_OTG));
 164         RegVal |= XUSBPSU_GCTL_PRTCAPDIR(Mode);
 165         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GCTL, RegVal);
 166 }
 167
 168 /*****************************************************************************/
 169 /**
 170 * Issues core PHY reset.
 171 *
 172 * @param        InstancePtr is a pointer to the XUsbPsu instance to be worked on.
 173 *
 174 * @return       None
 175 *
 176 ******************************************************************************/
 177 void XUsbPsu_PhyReset(struct XUsbPsu *InstancePtr)
 178 {
 179         u32             RegVal;
 180
 181         Xil_AssertVoid(InstancePtr != NULL);
 182
 183         /* Before Resetting PHY, put Core in Reset */
 184         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_GCTL);
 185         RegVal |= XUSBPSU_GCTL_CORESOFTRESET;
 186         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GCTL, RegVal);
 187
 188         /* Assert USB3 PHY reset */
 189         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_GUSB3PIPECTL(0));
 190         RegVal |= XUSBPSU_GUSB3PIPECTL_PHYSOFTRST;
 191         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GUSB3PIPECTL(0), RegVal);
 192
 193         /* Assert USB2 PHY reset */
 194         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_GUSB2PHYCFG(0));
 195         RegVal |= XUSBPSU_GUSB2PHYCFG_PHYSOFTRST;
 196         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GUSB2PHYCFG(0), RegVal);
 197
 198         XUsbSleep(XUSBPSU_PHY_TIMEOUT);
 199
 200         /* Clear USB3 PHY reset */
 201         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_GUSB3PIPECTL(0));
 202         RegVal &= ~XUSBPSU_GUSB3PIPECTL_PHYSOFTRST;
 203         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GUSB3PIPECTL(0), RegVal);
 204
 205         /* Clear USB2 PHY reset */
 206         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_GUSB2PHYCFG(0));
 207         RegVal &= ~XUSBPSU_GUSB2PHYCFG_PHYSOFTRST;
 208         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GUSB2PHYCFG(0), RegVal);
 209
 210         XUsbSleep(XUSBPSU_PHY_TIMEOUT);
 211
 212         /* Take Core out of reset state after PHYS are stable*/
 213         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_GCTL);
 214         RegVal &= ~XUSBPSU_GCTL_CORESOFTRESET;
 215         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GCTL, RegVal);
 216 }
 217
 218 /*****************************************************************************/
 219 /**
 220 * Sets up Event buffers so that events are written by Core.
 221 *
 222 * @param        InstancePtr is a pointer to the XUsbPsu instance to be worked on.
 223 *
 224 * @return       None
 225 *
 226 ******************************************************************************/
 227 void XUsbPsu_EventBuffersSetup(struct XUsbPsu *InstancePtr)
 228 {
 229     struct XUsbPsu_EvtBuffer *Evt;
 230
 231         Xil_AssertVoid(InstancePtr != NULL);
 232
 233         Evt = &InstancePtr->Evt;
 234         Evt->BuffAddr = (void *)InstancePtr->EventBuffer;
 235
 236         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GEVNTADRLO(0),
 237                                                 (UINTPTR)InstancePtr->EventBuffer);
 238         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GEVNTADRHI(0),
 239                                                 ((UINTPTR)(InstancePtr->EventBuffer) >> 16U) >> 16U);
 240         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GEVNTSIZ(0),
 241                                         XUSBPSU_GEVNTSIZ_SIZE(sizeof(InstancePtr->EventBuffer)));
 242         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GEVNTCOUNT(0), 0);
 243 }
 244
 245 /*****************************************************************************/
 246 /**
 247 * Resets Event buffer Registers to zero so that events are not written by Core.
 248 *
 249 * @param        InstancePtr is a pointer to the XUsbPsu instance to be worked on.
 250 *
 251 * @return       None
 252 *
 253 ******************************************************************************/
 254 void XUsbPsu_EventBuffersReset(struct XUsbPsu *InstancePtr)
 255 {
 256
 257         Xil_AssertVoid(InstancePtr != NULL);
 258
 259         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GEVNTADRLO(0U), 0U);
 260         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GEVNTADRHI(0U), 0U);
 261         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GEVNTSIZ(0U),
 262                         (u32)XUSBPSU_GEVNTSIZ_INTMASK | XUSBPSU_GEVNTSIZ_SIZE(0U));
 263         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GEVNTCOUNT(0U), 0U);
 264 }
 265
 266 /*****************************************************************************/
 267 /**
 268 * Reads data from Hardware Params Registers of Core.
 269 *
 270 * @param        InstancePtr is a pointer to the XUsbPsu instance to be worked on.
 271 * @param        RegIndex is Register number to read
 272 *                       - XUSBPSU_GHWPARAMS0
 273 *                       - XUSBPSU_GHWPARAMS1
 274 *                       - XUSBPSU_GHWPARAMS2
 275 *                       - XUSBPSU_GHWPARAMS3
 276 *                       - XUSBPSU_GHWPARAMS4
 277 *                       - XUSBPSU_GHWPARAMS5
 278 *                       - XUSBPSU_GHWPARAMS6
 279 *                       - XUSBPSU_GHWPARAMS7
 280 *
 281 * @return       One of the GHWPARAMS RegValister contents.
 282 *
 283 ******************************************************************************/
 284 u32 XUsbPsu_ReadHwParams(struct XUsbPsu *InstancePtr, u8 RegIndex)
 285 {
 286         u32 RegVal;
 287
 288         Xil_AssertNonvoid(InstancePtr != NULL);
 289         Xil_AssertNonvoid(RegIndex <= (u8)XUSBPSU_GHWPARAMS7);
 290
 291         RegVal = XUsbPsu_ReadReg(InstancePtr, ((u32)XUSBPSU_GHWPARAMS0_OFFSET +
 292                                                         ((u32)RegIndex * (u32)4)));
 293         return RegVal;
 294 }
 295
 296 /*****************************************************************************/
 297 /**
 298 * Initializes Core.
 299 *
 300 * @param  InstancePtr is a pointer to the XUsbPsu instance to be worked on.
 301 *
 302 * @return
 303 *               - XST_SUCCESS if initialization was successful
 304 *               - XST_FAILURE if initialization was not successful
 305 *
 306 ******************************************************************************/
 307 s32 XUsbPsu_CoreInit(struct XUsbPsu *InstancePtr)
 308 {
 309         u32             RegVal;
 310         u32             Hwparams1;
 311
 312         /* issue device SoftReset too */
 313         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCTL, XUSBPSU_DCTL_CSFTRST);
 314
 315         if (XUsbPsu_Wait_Clear_Timeout(InstancePtr, XUSBPSU_DCTL,
 316                         XUSBPSU_DCTL_CSFTRST, 500U) == XST_FAILURE) {
 317                 /* timed out return failure */
 318                 return XST_FAILURE;
 319         }
 320
 321         XUsbPsu_PhyReset(InstancePtr);
 322
 323         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_GCTL);
 324     RegVal &= ~XUSBPSU_GCTL_SCALEDOWN_MASK;
 325     RegVal &= ~XUSBPSU_GCTL_DISSCRAMBLE;
 326     RegVal |= XUSBPSU_GCTL_U2EXIT_LFPS;
 327
 328         Hwparams1 = XUsbPsu_ReadHwParams(InstancePtr, 1U);
 329
 330         switch (XUSBPSU_GHWPARAMS1_EN_PWROPT(Hwparams1)) {
 331                 case XUSBPSU_GHWPARAMS1_EN_PWROPT_CLK:
 332                         RegVal &= ~XUSBPSU_GCTL_DSBLCLKGTNG;
 333                         break;
 334
 335                 case XUSBPSU_GHWPARAMS1_EN_PWROPT_HIB:
 336                 /* enable hibernation here */
 337                         break;
 338
 339                 default:
 340                         /* Made for Misra-C Compliance. */
 341                         break;
 342         }
 343
 344         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_GCTL, RegVal);
 345
 346         return XST_SUCCESS;
 347 }
 348
 349 /*****************************************************************************/
 350 /**
 351 * Enables an interrupt in Event Enable RegValister.
 352 *
 353 * @param  InstancePtr is a pointer to the XUsbPsu instance to be worked on
 354 * @param  Mask is the OR of any Interrupt Enable Masks:
 355 *               - XUSBPSU_DEVTEN_VNDRDEVTSTRCVEDEN
 356 *               - XUSBPSU_DEVTEN_EVNTOVERFLOWEN
 357 *               - XUSBPSU_DEVTEN_CMDCMPLTEN
 358 *               - XUSBPSU_DEVTEN_ERRTICERREN
 359 *               - XUSBPSU_DEVTEN_SOFEN
 360 *               - XUSBPSU_DEVTEN_EOPFEN
 361 *               - XUSBPSU_DEVTEN_HIBERNATIONREQEVTEN
 362 *               - XUSBPSU_DEVTEN_WKUPEVTEN
 363 *               - XUSBPSU_DEVTEN_ULSTCNGEN
 364 *               - XUSBPSU_DEVTEN_CONNECTDONEEN
 365 *               - XUSBPSU_DEVTEN_USBRSTEN
 366 *               - XUSBPSU_DEVTEN_DISCONNEVTEN
 367 *
 368 * @return  None
 369 *
 370 ******************************************************************************/
 371 void XUsbPsu_EnableIntr(struct XUsbPsu *InstancePtr, u32 Mask)
 372 {
 373     u32 RegVal;
 374
 375         Xil_AssertVoid(InstancePtr != NULL);
 376
 377     RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DEVTEN);
 378     RegVal |= Mask;
 379
 380         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DEVTEN, RegVal);
 381 }
 382
 383 /*****************************************************************************/
 384 /**
 385 * Disables an interrupt in Event Enable RegValister.
 386 *
 387 * @param  InstancePtr is a pointer to the XUsbPsu instance to be worked on.
 388 * @param  Mask is the OR of Interrupt Enable Masks
 389 *               - XUSBPSU_DEVTEN_VNDRDEVTSTRCVEDEN
 390 *               - XUSBPSU_DEVTEN_EVNTOVERFLOWEN
 391 *               - XUSBPSU_DEVTEN_CMDCMPLTEN
 392 *               - XUSBPSU_DEVTEN_ERRTICERREN
 393 *               - XUSBPSU_DEVTEN_SOFEN
 394 *               - XUSBPSU_DEVTEN_EOPFEN
 395 *               - XUSBPSU_DEVTEN_HIBERNATIONREQEVTEN
 396 *               - XUSBPSU_DEVTEN_WKUPEVTEN
 397 *               - XUSBPSU_DEVTEN_ULSTCNGEN
 398 *               - XUSBPSU_DEVTEN_CONNECTDONEEN
 399 *               - XUSBPSU_DEVTEN_USBRSTEN
 400 *               - XUSBPSU_DEVTEN_DISCONNEVTEN
 401 *
 402 * @return  None
 403 *
 404 ******************************************************************************/
 405 void XUsbPsu_DisableIntr(struct XUsbPsu *InstancePtr, u32 Mask)
 406 {
 407         u32 RegVal;
 408
 409         Xil_AssertVoid(InstancePtr != NULL);
 410
 411         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DEVTEN);
 412         RegVal &= ~Mask;
 413         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DEVTEN, RegVal);
 414 }
 415
 416 /****************************************************************************/
 417 /**
 418 *
 419 * This function does the following:
 420 *       - initializes a specific XUsbPsu instance.
 421 *       - sets up Event Buffer for Core to write events.
 422 *       - Core Reset and PHY Reset.
 423 *       - Sets core in Device Mode.
 424 *       - Sets default speed as HIGH_SPEED.
 425 *       - Sets Device Address to 0.
 426 *       - Enables interrupts.
 427 *
 428 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 429 * @param        ConfigPtr points to the XUsbPsu device configuration structure.
 430 * @param        BaseAddress is the device base address in the virtual memory
 431 *                       address space. If the address translation is not used then the
 432 *                       physical address is passed.
 433 *                       Unexpected errors may occur if the address mapping is changed
 434 *                       after this function is invoked.
 435 *
 436 * @return       XST_SUCCESS else XST_FAILURE
 437 *
 438 * @note         None.
 439 *
 440 *****************************************************************************/
 441 s32 XUsbPsu_CfgInitialize(struct XUsbPsu *InstancePtr,
 442                         XUsbPsu_Config *ConfigPtr, u32 BaseAddress)
 443 {
 444         int Status;
 445         u32 RegVal;
 446
 447
 448         Xil_AssertNonvoid(InstancePtr != NULL);
 449         Xil_AssertNonvoid(ConfigPtr   != NULL);
 450         Xil_AssertNonvoid(BaseAddress != 0U)
 451
 452         InstancePtr->ConfigPtr = ConfigPtr;
 453
 454         Status = XUsbPsu_CoreInit(InstancePtr);
 455         if (Status != XST_SUCCESS) {
 456 #ifdef XUSBPSU_DEBUG
 457                 xil_printf("Core initialization failed\r\n");
 458 #endif
 459                 return XST_FAILURE;
 460         }
 461
 462         RegVal = XUsbPsu_ReadHwParams(InstancePtr, 3U);
 463         InstancePtr->NumInEps = (u8)XUSBPSU_NUM_IN_EPS(RegVal);
 464         InstancePtr->NumOutEps = (u8)(XUSBPSU_NUM_EPS(RegVal) -
 465                         InstancePtr->NumInEps);
 466
 467         /* Map USB and Physical Endpoints */
 468         XUsbPsu_InitializeEps(InstancePtr);
 469
 470         XUsbPsu_EventBuffersSetup(InstancePtr);
 471
 472         XUsbPsu_SetMode(InstancePtr, XUSBPSU_GCTL_PRTCAP_DEVICE);
 473
 474     /*
 475      * Setting to max speed to support SS and HS
 476      */
 477     XUsbPsu_SetSpeed(InstancePtr, XUSBPSU_DCFG_SUPERSPEED);
 478
 479         (void)XUsbPsu_SetDeviceAddress(InstancePtr, 0U);
 480
 481         return XST_SUCCESS;
 482 }
 483
 484 /****************************************************************************/
 485 /**
 486 *
 487 * Starts the controller so that Host can detect this device.
 488 *
 489 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 490 *
 491 * @return       XST_SUCCESS else XST_FAILURE
 492 *
 493 * @note         None.
 494 *
 495 *****************************************************************************/
 496 s32 XUsbPsu_Start(struct XUsbPsu *InstancePtr)
 497 {
 498         u32                     RegVal;
 499
 500         Xil_AssertNonvoid(InstancePtr != NULL);
 501
 502         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCTL);
 503
 504         RegVal |= XUSBPSU_DCTL_RUN_STOP;
 505
 506         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCTL, RegVal);
 507
 508         if (XUsbPsu_Wait_Clear_Timeout(InstancePtr, XUSBPSU_DSTS,
 509                         XUSBPSU_DSTS_DEVCTRLHLT, 500U) == XST_FAILURE) {
 510                 return XST_FAILURE;
 511         }
 512
 513         return XST_SUCCESS;
 514 }
 515
 516 /****************************************************************************/
 517 /**
 518 *
 519 * Stops the controller so that Device disconnects from Host.
 520 *
 521 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 522 *
 523 * @return       XST_SUCCESS else XST_FAILURE
 524 *
 525 * @note         None.
 526 *
 527 *****************************************************************************/
 528 s32 XUsbPsu_Stop(struct XUsbPsu *InstancePtr)
 529 {
 530         u32     RegVal;
 531
 532         Xil_AssertNonvoid(InstancePtr != NULL);
 533
 534         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCTL);
 535         RegVal &= ~XUSBPSU_DCTL_RUN_STOP;
 536
 537         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCTL, RegVal);
 538
 539         if (XUsbPsu_Wait_Set_Timeout(InstancePtr, XUSBPSU_DSTS,
 540                         XUSBPSU_DSTS_DEVCTRLHLT, 500U) == XST_FAILURE) {
 541                 return XST_FAILURE;
 542         }
 543
 544         return XST_SUCCESS;
 545 }
 546
 547 /****************************************************************************/
 548 /**
 549  * Enables USB2 Test Modes
 550  *
 551  * @param       InstancePtr is a pointer to the XUsbPsu instance.
 552  * @param       Mode is Test mode to set.
 553  *
 554  * @return      XST_SUCCESS else XST_FAILURE
 555  *
 556  * @note        None.
 557  *
 558  ****************************************************************************/
 559 s32 XUsbPsu_SetTestMode(struct XUsbPsu *InstancePtr, u32 Mode)
 560 {
 561         u32     RegVal;
 562         s32 Status = XST_SUCCESS;
 563
 564         Xil_AssertNonvoid(InstancePtr != NULL);
 565         Xil_AssertNonvoid((Mode >= XUSBPSU_TEST_J)
 566                         && (Mode <= XUSBPSU_TEST_FORCE_ENABLE));
 567
 568         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCTL);
 569         RegVal &= ~XUSBPSU_DCTL_TSTCTRL_MASK;
 570
 571         switch (Mode) {
 572                 case XUSBPSU_TEST_J:
 573                 case XUSBPSU_TEST_K:
 574                 case XUSBPSU_TEST_SE0_NAK:
 575                 case XUSBPSU_TEST_PACKET:
 576                 case XUSBPSU_TEST_FORCE_ENABLE:
 577                         RegVal |= (u32)Mode << 1;
 578                         break;
 579
 580                 default:
 581                         Status = (s32)XST_FAILURE;
 582                         break;
 583         }
 584
 585         if (Status != (s32)XST_FAILURE) {
 586                 XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCTL, RegVal);
 587                 Status = XST_SUCCESS;
 588         }
 589
 590         return Status;
 591 }
 592
 593 /****************************************************************************/
 594 /**
 595  * Gets current State of USB Link
 596  *
 597  * @param       InstancePtr is a pointer to the XUsbPsu instance.
 598  *
 599  * @return      Link State
 600  *
 601  * @note        None.
 602  *
 603  ****************************************************************************/
 604 XusbPsuLinkState XUsbPsu_GetLinkState(struct XUsbPsu *InstancePtr)
 605 {
 606         u32             RegVal;
 607
 608         Xil_AssertNonvoid(InstancePtr != NULL);
 609
 610         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DSTS);
 611
 612         return XUSBPSU_DSTS_USBLNKST(RegVal);
 613 }
 614
 615 /****************************************************************************/
 616 /**
 617  * Sets USB Link to a particular State
 618  *
 619  * @param       InstancePtr is a pointer to the XUsbPsu instance.
 620  * @param       State is State of Link to set.
 621  *
 622  * @return      XST_SUCCESS else XST_FAILURE
 623  *
 624  * @note        None.
 625  *
 626  ****************************************************************************/
 627 s32 XUsbPsu_SetLinkState(struct XUsbPsu *InstancePtr,
 628                 XusbPsuLinkStateChange State)
 629 {
 630         u32             RegVal;
 631
 632         Xil_AssertNonvoid(InstancePtr != NULL);
 633
 634          /* Wait until device controller is ready. */
 635         if (XUsbPsu_Wait_Clear_Timeout(InstancePtr, XUSBPSU_DSTS,
 636                         XUSBPSU_DSTS_DCNRD, 500U) == XST_FAILURE) {
 637                 return XST_FAILURE;
 638         }
 639
 640         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCTL);
 641         RegVal &= ~XUSBPSU_DCTL_ULSTCHNGREQ_MASK;
 642
 643         RegVal |= XUSBPSU_DCTL_ULSTCHNGREQ(State);
 644         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCTL, RegVal);
 645
 646         return XST_SUCCESS;
 647 }
 648
 649 /****************************************************************************/
 650 /**
 651 * Sets speed of the Core for connecting to Host
 652 *
 653 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 654 * @param        Speed is required speed
 655 *                               - XUSBPSU_DCFG_HIGHSPEED
 656 *                               - XUSBPSU_DCFG_FULLSPEED2
 657 *                               - XUSBPSU_DCFG_LOWSPEED
 658 *                               - XUSBPSU_DCFG_FULLSPEED1
 659 *
 660 * @return       None
 661 *
 662 * @note         None.
 663 *
 664 *****************************************************************************/
 665 void XUsbPsu_SetSpeed(struct XUsbPsu *InstancePtr, u32 Speed)
 666 {
 667         u32     RegVal;
 668
 669         Xil_AssertVoid(InstancePtr != NULL);
 670         Xil_AssertVoid(Speed <= (u32)XUSBPSU_DCFG_SUPERSPEED);
 671
 672         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCFG);
 673         RegVal &= ~(XUSBPSU_DCFG_SPEED_MASK);
 674         RegVal |= Speed;
 675         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCFG, RegVal);
 676 }
 677
 678 /****************************************************************************/
 679 /**
 680 * Sets Device Address of the Core
 681 *
 682 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 683 * @param        Addr is address to set.
 684 *
 685 * @return       XST_SUCCESS else XST_FAILURE
 686 *
 687 * @note None.
 688 *
 689 *****************************************************************************/
 690 s32 XUsbPsu_SetDeviceAddress(struct XUsbPsu *InstancePtr, u16 Addr)
 691 {
 692         u32 RegVal;
 693
 694         Xil_AssertNonvoid(InstancePtr != NULL);
 695         Xil_AssertNonvoid(Addr <= 127U);
 696
 697         if (InstancePtr->State == XUSBPSU_STATE_CONFIGURED) {
 698                 return XST_FAILURE;
 699         }
 700
 701         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCFG);
 702         RegVal &= ~(XUSBPSU_DCFG_DEVADDR_MASK);
 703         RegVal |= XUSBPSU_DCFG_DEVADDR(Addr);
 704         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCFG, RegVal);
 705
 706         if (Addr) {
 707                 InstancePtr->State = XUSBPSU_STATE_ADDRESS;
 708         }
 709         else {
 710                 InstancePtr->State = XUSBPSU_STATE_DEFAULT;
 711         }
 712
 713         return XST_SUCCESS;
 714 }
 715
 716 /****************************************************************************/
 717 /**
 718 * Sets speed of the Core for connecting to Host
 719 *
 720 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 721 *
 722 * @return       XST_SUCCESS else XST_FAILURE
 723 *
 724 * @note         None.
 725 *
 726 *****************************************************************************/
 727 s32 XUsbPsu_IsSuperSpeed(struct XUsbPsu *InstancePtr)
 728 {
 729         if (InstancePtr->Speed != XUSBPSU_SPEED_SUPER) {
 730                 return XST_FAILURE;
 731         }
 732
 733         return XST_SUCCESS;
 734 }
 735
 736 /****************************************************************************/
 737 /**
 738 * Set U1 sleep timeout
 739 *
 740 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 741 * @param        Sleep is time in microseconds
 742 *
 743 * @return       XST_SUCCESS else XST_FAILURE
 744 *
 745 * @note None.
 746 *
 747 *****************************************************************************/
 748 s32 XUsbPsu_SetU1SleepTimeout(struct XUsbPsu *InstancePtr, u8 Sleep)
 749 {
 750         u32 RegVal;
 751
 752         Xil_AssertNonvoid(InstancePtr != NULL);
 753
 754         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_PORTMSC_30);
 755         RegVal &= ~XUSBPSU_PORTMSC_30_U1_TIMEOUT_MASK;
 756         RegVal |= (Sleep << XUSBPSU_PORTMSC_30_U1_TIMEOUT_SHIFT);
 757         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_PORTMSC_30, RegVal);
 758
 759         return XST_SUCCESS;
 760 }
 761
 762 /****************************************************************************/
 763 /**
 764 * Set U2 sleep timeout
 765 *
 766 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 767 * @param        Sleep is time in microseconds
 768 *
 769 * @return       XST_SUCCESS else XST_FAILURE
 770 *
 771 * @note None.
 772 *
 773 *****************************************************************************/
 774 s32 XUsbPsu_SetU2SleepTimeout(struct XUsbPsu *InstancePtr, u8 Sleep)
 775 {
 776         u32 RegVal;
 777
 778         Xil_AssertNonvoid(InstancePtr != NULL);
 779
 780         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_PORTMSC_30);
 781         RegVal &= ~XUSBPSU_PORTMSC_30_U2_TIMEOUT_MASK;
 782         RegVal |= (Sleep << XUSBPSU_PORTMSC_30_U2_TIMEOUT_SHIFT);
 783         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_PORTMSC_30, RegVal);
 784
 785         return XST_SUCCESS;
 786 }
 787 /****************************************************************************/
 788 /**
 789 * Enable Accept U1 and U2 sleep enable
 790 *
 791 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 792 *
 793 * @return       XST_SUCCESS else XST_FAILURE
 794 *
 795 * @note None.
 796 *
 797 *****************************************************************************/
 798 s32 XUsbPsu_AcceptU1U2Sleep(struct XUsbPsu *InstancePtr)
 799 {
 800         u32 RegVal;
 801
 802         Xil_AssertNonvoid(InstancePtr != NULL);
 803
 804         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCTL);
 805         RegVal |= XUSBPSU_DCTL_ACCEPTU2ENA | XUSBPSU_DCTL_ACCEPTU1ENA;
 806         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCTL, RegVal);
 807
 808         return XST_SUCCESS;
 809 }
 810
 811 /****************************************************************************/
 812 /**
 813 * Enable U1 enable sleep
 814 *
 815 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 816 *
 817 * @return       XST_SUCCESS else XST_FAILURE
 818 *
 819 * @note None.
 820 *
 821 *****************************************************************************/
 822 s32 XUsbPsu_U1SleepEnable(struct XUsbPsu *InstancePtr)
 823 {
 824         u32 RegVal;
 825
 826         Xil_AssertNonvoid(InstancePtr != NULL);
 827
 828         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCTL);
 829         RegVal |= XUSBPSU_DCTL_INITU1ENA;
 830         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCTL, RegVal);
 831
 832         return XST_SUCCESS;
 833 }
 834
 835 /****************************************************************************/
 836 /**
 837 * Enable U2 enable sleep
 838 *
 839 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 840 *
 841 * @return       XST_SUCCESS else XST_FAILURE
 842 *
 843 * @note None.
 844 *
 845 *****************************************************************************/
 846 s32 XUsbPsu_U2SleepEnable(struct XUsbPsu *InstancePtr)
 847 {
 848         u32 RegVal;
 849
 850         Xil_AssertNonvoid(InstancePtr != NULL);
 851
 852         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCTL);
 853         RegVal |= XUSBPSU_DCTL_INITU2ENA;
 854         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCTL, RegVal);
 855
 856         return XST_SUCCESS;
 857 }
 858
 859 /****************************************************************************/
 860 /**
 861 * Enable U1 disable sleep
 862 *
 863 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 864 *
 865 * @return       XST_SUCCESS else XST_FAILURE
 866 *
 867 * @note None.
 868 *
 869 *****************************************************************************/
 870 s32 XUsbPsu_U1SleepDisable(struct XUsbPsu *InstancePtr)
 871 {
 872         u32 RegVal;
 873
 874         Xil_AssertNonvoid(InstancePtr != NULL);
 875
 876         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCTL);
 877         RegVal &= ~XUSBPSU_DCTL_INITU1ENA;
 878         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCTL, RegVal);
 879
 880         return XST_SUCCESS;
 881 }
 882
 883 /****************************************************************************/
 884 /**
 885 * Enable U2 disable sleep
 886 *
 887 * @param        InstancePtr is a pointer to the XUsbPsu instance.
 888 *
 889 * @return       XST_SUCCESS else XST_FAILURE
 890 *
 891 * @note None.
 892 *
 893 *****************************************************************************/
 894 s32 XUsbPsu_U2SleepDisable(struct XUsbPsu *InstancePtr)
 895 {
 896         u32 RegVal;
 897
 898         Xil_AssertNonvoid(InstancePtr != NULL);
 899
 900         RegVal = XUsbPsu_ReadReg(InstancePtr, XUSBPSU_DCTL);
 901         RegVal &= ~XUSBPSU_DCTL_INITU2ENA;
 902         XUsbPsu_WriteReg(InstancePtr, XUSBPSU_DCTL, RegVal);
 903
 904         return XST_SUCCESS;
 905 }
 906 /** @} */