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