drivers/usb/dwc_otg_310/dwc_otg_cil.h

   1 /* ==========================================================================
   2  * $File: //dwh/usb_iip/dev/software/otg/linux/drivers/dwc_otg_cil.h $
   3  * $Revision: #127 $
   4  * $Date: 2012/12/21 $
   5  * $Change: 2131568 $
   6  *
   7  * Synopsys HS OTG Linux Software Driver and documentation (hereinafter,
   8  * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless
   9  * otherwise expressly agreed to in writing between Synopsys and you.
  10  *
  11  * The Software IS NOT an item of Licensed Software or Licensed Product under
  12  * any End User Software License Agreement or Agreement for Licensed Product
  13  * with Synopsys or any supplement thereto. You are permitted to use and
  14  * redistribute this Software in source and binary forms, with or without
  15  * modification, provided that redistributions of source code must retain this
  16  * notice. You may not view, use, disclose, copy or distribute this file or
  17  * any information contained herein except pursuant to this license grant from
  18  * Synopsys. If you do not agree with this notice, including the disclaimer
  19  * below, then you are not authorized to use the Software.
  20  *
  21  * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS
  22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS BE LIABLE FOR ANY DIRECT,
  25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  28  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  31  * DAMAGE.
  32  * ========================================================================== */
  33
  34 #if !defined(__DWC_CIL_H__)
  35 #define __DWC_CIL_H__
  36
  37 #include "common_port/dwc_list.h"
  38 #include "dwc_otg_dbg.h"
  39 #include "dwc_otg_regs.h"
  40
  41 #include "dwc_otg_core_if.h"
  42 #include "dwc_otg_adp.h"
  43
  44 /**
  45  * @file
  46  * This file contains the interface to the Core Interface Layer.
  47  */
  48
  49 #ifdef DWC_UTE_CFI
  50
  51 #define MAX_DMA_DESCS_PER_EP    256
  52
  53 /**
  54  * Enumeration for the data buffer mode
  55  */
  56 typedef enum _data_buffer_mode {
  57         BM_STANDARD = 0,        /* data buffer is in normal mode */
  58         BM_SG = 1,              /* data buffer uses the scatter/gather mode */
  59         BM_CONCAT = 2,          /* data buffer uses the concatenation mode */
  60         BM_CIRCULAR = 3,        /* data buffer uses the circular DMA mode */
  61         BM_ALIGN = 4            /* data buffer is in buffer alignment mode */
  62 } data_buffer_mode_e;
  63 #endif /* DWC_UTE_CFI */
  64
  65 /** Macros defined for DWC OTG HW Release version */
  66
  67 #define OTG_CORE_REV_2_60a      0x4F54260A
  68 #define OTG_CORE_REV_2_71a      0x4F54271A
  69 #define OTG_CORE_REV_2_72a      0x4F54272A
  70 #define OTG_CORE_REV_2_80a      0x4F54280A
  71 #define OTG_CORE_REV_2_81a      0x4F54281A
  72 #define OTG_CORE_REV_2_90a      0x4F54290A
  73 #define OTG_CORE_REV_2_91a      0x4F54291A
  74 #define OTG_CORE_REV_2_92a      0x4F54292A
  75 #define OTG_CORE_REV_2_93a      0x4F54293A
  76 #define OTG_CORE_REV_2_94a      0x4F54294A
  77 #define OTG_CORE_REV_3_00a      0x4F54300A
  78 #define OTG_CORE_REV_3_10a      0x4F54310A
  79
  80 /**
  81  * Information for each ISOC packet.
  82  */
  83 typedef struct iso_pkt_info {
  84         uint32_t offset;
  85         uint32_t length;
  86         int32_t status;
  87 } iso_pkt_info_t;
  88
  89 /**
  90  * The <code>dwc_ep</code> structure represents the state of a single
  91  * endpoint when acting in device mode. It contains the data items
  92  * needed for an endpoint to be activated and transfer packets.
  93  */
  94 typedef struct dwc_ep {
  95         /** EP number used for register address lookup */
  96         uint8_t num;
  97         /** EP direction 0 = OUT */
  98         unsigned is_in:1;
  99         /** EP active. */
 100         unsigned active:1;
 101
 102         /**
 103          * Periodic Tx FIFO # for IN EPs For INTR EP set to 0 to use non-periodic
 104          * Tx FIFO. If dedicated Tx FIFOs are enabled Tx FIFO # FOR IN EPs*/
 105         unsigned tx_fifo_num:4;
 106         /** EP type: 0 - Control, 1 - ISOC,      2 - BULK,      3 - INTR */
 107         unsigned type:2;
 108 #define DWC_OTG_EP_TYPE_CONTROL    0
 109 #define DWC_OTG_EP_TYPE_ISOC       1
 110 #define DWC_OTG_EP_TYPE_BULK       2
 111 #define DWC_OTG_EP_TYPE_INTR       3
 112
 113         /** DATA start PID for INTR and BULK EP */
 114         unsigned data_pid_start:1;
 115         /** Frame (even/odd) for ISOC EP */
 116         unsigned even_odd_frame:1;
 117         /** Max Packet bytes */
 118         unsigned maxpacket:11;
 119
 120         /** Max Transfer size */
 121         uint32_t maxxfer;
 122
 123         /** @name Transfer state */
 124         /** @{ */
 125
 126         /**
 127          * Pointer to the beginning of the transfer buffer -- do not modify
 128          * during transfer.
 129          */
 130
 131         dwc_dma_t dma_addr;
 132
 133         dwc_dma_t dma_desc_addr;
 134         dwc_otg_dev_dma_desc_t *desc_addr;
 135
 136         uint8_t *start_xfer_buff;
 137         /** pointer to the transfer buffer */
 138         uint8_t *xfer_buff;
 139         /** Number of bytes to transfer */
 140         unsigned xfer_len:19;
 141         /** Number of bytes transferred. */
 142         unsigned xfer_count:19;
 143         /** Sent ZLP */
 144         unsigned sent_zlp:1;
 145         /** Total len for control transfer */
 146         unsigned total_len:19;
 147
 148         /** stall clear flag */
 149         unsigned stall_clear_flag:1;
 150
 151         /** SETUP pkt cnt rollover flag for EP0 out*/
 152         unsigned stp_rollover;
 153
 154 #ifdef DWC_UTE_CFI
 155         /* The buffer mode */
 156         data_buffer_mode_e buff_mode;
 157
 158         /* The chain of DMA descriptors.
 159          * MAX_DMA_DESCS_PER_EP will be allocated for each active EP.
 160          */
 161         dwc_otg_dma_desc_t *descs;
 162
 163         /* The DMA address of the descriptors chain start */
 164         dma_addr_t descs_dma_addr;
 165         /** This variable stores the length of the last enqueued request */
 166         uint32_t cfi_req_len;
 167 #endif/* DWC_UTE_CFI */
 168
 169 /** Max DMA Descriptor count for any EP */
 170 #define MAX_DMA_DESC_CNT 256
 171         /** Allocated DMA Desc count */
 172         uint32_t desc_cnt;
 173
 174         /** bInterval */
 175         uint32_t bInterval;
 176         /** Next frame num to setup next ISOC transfer */
 177         uint32_t frame_num;
 178         /** Indicates SOF number overrun in DSTS */
 179         uint8_t frm_overrun;
 180
 181 #ifdef DWC_UTE_PER_IO
 182         /** Next frame num for which will be setup DMA Desc */
 183         uint32_t xiso_frame_num;
 184         /** bInterval */
 185         uint32_t xiso_bInterval;
 186         /** Count of currently active transfers - shall be either 0 or 1 */
 187         int xiso_active_xfers;
 188         int xiso_queued_xfers;
 189 #endif
 190 #ifdef DWC_EN_ISOC
 191         /**
 192          * Variables specific for ISOC EPs
 193          *
 194          */
 195         /** DMA addresses of ISOC buffers */
 196         dwc_dma_t dma_addr0;
 197         dwc_dma_t dma_addr1;
 198
 199         dwc_dma_t iso_dma_desc_addr;
 200         dwc_otg_dev_dma_desc_t *iso_desc_addr;
 201
 202         /** pointer to the transfer buffers */
 203         uint8_t *xfer_buff0;
 204         uint8_t *xfer_buff1;
 205
 206         /** number of ISOC Buffer is processing */
 207         uint32_t proc_buf_num;
 208         /** Interval of ISOC Buffer processing */
 209         uint32_t buf_proc_intrvl;
 210         /** Data size for regular frame */
 211         uint32_t data_per_frame;
 212
 213         /* todo - pattern data support is to be implemented in the future */
 214         /** Data size for pattern frame */
 215         uint32_t data_pattern_frame;
 216         /** Frame number of pattern data */
 217         uint32_t sync_frame;
 218
 219         /** bInterval */
 220         uint32_t bInterval;
 221         /** ISO Packet number per frame */
 222         uint32_t pkt_per_frm;
 223         /** Next frame num for which will be setup DMA Desc */
 224         uint32_t next_frame;
 225         /** Number of packets per buffer processing */
 226         uint32_t pkt_cnt;
 227         /** Info for all isoc packets */
 228         iso_pkt_info_t *pkt_info;
 229         /** current pkt number */
 230         uint32_t cur_pkt;
 231         /** current pkt number */
 232         uint8_t *cur_pkt_addr;
 233         /** current pkt number */
 234         uint32_t cur_pkt_dma_addr;
 235 #endif                          /* DWC_EN_ISOC */
 236
 237 /** @} */
 238 } dwc_ep_t;
 239
 240 /*
 241  * Reasons for halting a host channel.
 242  */
 243 typedef enum dwc_otg_halt_status {
 244         DWC_OTG_HC_XFER_NO_HALT_STATUS,
 245         DWC_OTG_HC_XFER_COMPLETE,
 246         DWC_OTG_HC_XFER_URB_COMPLETE,
 247         DWC_OTG_HC_XFER_ACK,
 248         DWC_OTG_HC_XFER_NAK,
 249         DWC_OTG_HC_XFER_NYET,
 250         DWC_OTG_HC_XFER_STALL,
 251         DWC_OTG_HC_XFER_XACT_ERR,
 252         DWC_OTG_HC_XFER_FRAME_OVERRUN,
 253         DWC_OTG_HC_XFER_BABBLE_ERR,
 254         DWC_OTG_HC_XFER_DATA_TOGGLE_ERR,
 255         DWC_OTG_HC_XFER_AHB_ERR,
 256         DWC_OTG_HC_XFER_PERIODIC_INCOMPLETE,
 257         DWC_OTG_HC_XFER_URB_DEQUEUE
 258 } dwc_otg_halt_status_e;
 259
 260 /**
 261  * Host channel descriptor. This structure represents the state of a single
 262  * host channel when acting in host mode. It contains the data items needed to
 263  * transfer packets to an endpoint via a host channel.
 264  */
 265 typedef struct dwc_hc {
 266         /** Host channel number used for register address lookup */
 267         uint8_t hc_num;
 268
 269         /** Device to access */
 270         unsigned dev_addr:7;
 271
 272         /** EP to access */
 273         unsigned ep_num:4;
 274
 275         /** EP direction. 0: OUT, 1: IN */
 276         unsigned ep_is_in:1;
 277
 278         /**
 279          * EP speed.
 280          * One of the following values:
 281          *      - DWC_OTG_EP_SPEED_LOW
 282          *      - DWC_OTG_EP_SPEED_FULL
 283          *      - DWC_OTG_EP_SPEED_HIGH
 284          */
 285         unsigned speed:2;
 286 #define DWC_OTG_EP_SPEED_LOW    0
 287 #define DWC_OTG_EP_SPEED_FULL   1
 288 #define DWC_OTG_EP_SPEED_HIGH   2
 289
 290         /**
 291          * Endpoint type.
 292          * One of the following values:
 293          *      - DWC_OTG_EP_TYPE_CONTROL: 0
 294          *      - DWC_OTG_EP_TYPE_ISOC: 1
 295          *      - DWC_OTG_EP_TYPE_BULK: 2
 296          *      - DWC_OTG_EP_TYPE_INTR: 3
 297          */
 298         unsigned ep_type:2;
 299
 300         /** Max packet size in bytes */
 301         unsigned max_packet:11;
 302
 303         /**
 304          * PID for initial transaction.
 305          * 0: DATA0,<br>
 306          * 1: DATA2,<br>
 307          * 2: DATA1,<br>
 308          * 3: MDATA (non-Control EP),
 309          *        SETUP (Control EP)
 310          */
 311         unsigned data_pid_start:2;
 312 #define DWC_OTG_HC_PID_DATA0 0
 313 #define DWC_OTG_HC_PID_DATA2 1
 314 #define DWC_OTG_HC_PID_DATA1 2
 315 #define DWC_OTG_HC_PID_MDATA 3
 316 #define DWC_OTG_HC_PID_SETUP 3
 317
 318         /** Number of periodic transactions per (micro)frame */
 319         unsigned multi_count:2;
 320
 321         /** @name Transfer State */
 322         /** @{ */
 323
 324         /** Pointer to the current transfer buffer position. */
 325         uint8_t *xfer_buff;
 326         /**
 327          * In Buffer DMA mode this buffer will be used
 328          * if xfer_buff is not DWORD aligned.
 329          */
 330         dwc_dma_t align_buff;
 331         /** Total number of bytes to transfer. */
 332         uint32_t xfer_len;
 333         /** Number of bytes transferred so far. */
 334         uint32_t xfer_count;
 335         /** Packet count at start of transfer.*/
 336         uint16_t start_pkt_count;
 337
 338         /**
 339          * Flag to indicate whether the transfer has been started. Set to 1 if
 340          * it has been started, 0 otherwise.
 341          */
 342         uint8_t xfer_started;
 343
 344         /**
 345          * Set to 1 to indicate that a PING request should be issued on this
 346          * channel. If 0, process normally.
 347          */
 348         uint8_t do_ping;
 349
 350         /**
 351          * Set to 1 to indicate that the error count for this transaction is
 352          * non-zero. Set to 0 if the error count is 0.
 353          */
 354         uint8_t error_state;
 355
 356         /**
 357          * Set to 1 to indicate that this channel should be halted the next
 358          * time a request is queued for the channel. This is necessary in
 359          * slave mode if no request queue space is available when an attempt
 360          * is made to halt the channel.
 361          */
 362         uint8_t halt_on_queue;
 363
 364         /**
 365          * Set to 1 if the host channel has been halted, but the core is not
 366          * finished flushing queued requests. Otherwise 0.
 367          */
 368         uint8_t halt_pending;
 369
 370         /**
 371          * Reason for halting the host channel.
 372          */
 373         dwc_otg_halt_status_e halt_status;
 374
 375         /*
 376          * Split settings for the host channel
 377          */
 378         uint8_t do_split;                  /**< Enable split for the channel */
 379         uint8_t complete_split;    /**< Enable complete split */
 380         uint8_t csplit_nak;
 381         uint8_t hub_addr;                  /**< Address of high speed hub */
 382
 383         uint8_t port_addr;                 /**< Port of the low/full speed device */
 384         /** Split transaction position
 385          * One of the following values:
 386          *        - DWC_HCSPLIT_XACTPOS_MID
 387          *        - DWC_HCSPLIT_XACTPOS_BEGIN
 388          *        - DWC_HCSPLIT_XACTPOS_END
 389          *        - DWC_HCSPLIT_XACTPOS_ALL */
 390         uint8_t xact_pos;
 391
 392         /** Set when the host channel does a short read. */
 393         uint8_t short_read;
 394
 395         /**
 396          * Number of requests issued for this channel since it was assigned to
 397          * the current transfer (not counting PINGs).
 398          */
 399         uint8_t requests;
 400
 401         /**
 402          * Queue Head for the transfer being processed by this channel.
 403          */
 404         struct dwc_otg_qh *qh;
 405
 406         /** @} */
 407
 408         /** Entry in list of host channels. */
 409          DWC_CIRCLEQ_ENTRY(dwc_hc) hc_list_entry;
 410
 411         /** @name Descriptor DMA support */
 412         /** @{ */
 413
 414         /** Number of Transfer Descriptors */
 415         uint16_t ntd;
 416
 417         /** Descriptor List DMA address */
 418         dwc_dma_t desc_list_addr;
 419
 420         /** Scheduling micro-frame bitmap. */
 421         uint8_t schinfo;
 422
 423         /** @} */
 424 } dwc_hc_t;
 425
 426 /**
 427  * The following parameters may be specified when starting the module. These
 428  * parameters define how the DWC_otg controller should be configured.
 429  */
 430 typedef struct dwc_otg_core_params {
 431         int32_t opt;
 432
 433         /**
 434          * Specifies the OTG capabilities. The driver will automatically
 435          * detect the value for this parameter if none is specified.
 436          * 0 - HNP and SRP capable (default)
 437          * 1 - SRP Only capable
 438          * 2 - No HNP/SRP capable
 439          */
 440         int32_t otg_cap;
 441
 442         /**
 443          * Specifies whether to use slave or DMA mode for accessing the data
 444          * FIFOs. The driver will automatically detect the value for this
 445          * parameter if none is specified.
 446          * 0 - Slave
 447          * 1 - DMA (default, if available)
 448          */
 449         int32_t dma_enable;
 450
 451         /**
 452          * When DMA mode is enabled specifies whether to use address DMA or DMA
 453          * Descriptor mode for accessing the data FIFOs in device mode. The driver
 454          * will automatically detect the value for this if none is specified.
 455          * 0 - address DMA
 456          * 1 - DMA Descriptor(default, if available)
 457          */
 458         int32_t dma_desc_enable;
 459         /** The DMA Burst size (applicable only for External DMA
 460          * Mode). 1, 4, 8 16, 32, 64, 128, 256 (default 32)
 461          */
 462         int32_t dma_burst_size; /* Translate this to GAHBCFG values */
 463
 464         /**
 465          * Specifies the maximum speed of operation in host and device mode.
 466          * The actual speed depends on the speed of the attached device and
 467          * the value of phy_type. The actual speed depends on the speed of the
 468          * attached device.
 469          * 0 - High Speed (default)
 470          * 1 - Full Speed
 471          */
 472         int32_t speed;
 473         /** Specifies whether low power mode is supported when attached
 474          *      to a Full Speed or Low Speed device in host mode.
 475          * 0 - Don't support low power mode (default)
 476          * 1 - Support low power mode
 477          */
 478         int32_t host_support_fs_ls_low_power;
 479
 480         /** Specifies the PHY clock rate in low power mode when connected to a
 481          * Low Speed device in host mode. This parameter is applicable only if
 482          * HOST_SUPPORT_FS_LS_LOW_POWER is enabled. If PHY_TYPE is set to FS
 483          * then defaults to 6 MHZ otherwise 48 MHZ.
 484          *
 485          * 0 - 48 MHz
 486          * 1 - 6 MHz
 487          */
 488         int32_t host_ls_low_power_phy_clk;
 489
 490         /**
 491          * 0 - Use cC FIFO size parameters
 492          * 1 - Allow dynamic FIFO sizing (default)
 493          */
 494         int32_t enable_dynamic_fifo;
 495
 496         /** Total number of 4-byte words in the data FIFO memory. This
 497          * memory includes the Rx FIFO, non-periodic Tx FIFO, and periodic
 498          * Tx FIFOs.
 499          * 32 to 32768 (default 8192)
 500          * Note: The total FIFO memory depth in the FPGA configuration is 8192.
 501          */
 502         int32_t data_fifo_size;
 503
 504         /** Number of 4-byte words in the Rx FIFO in device mode when dynamic
 505          * FIFO sizing is enabled.
 506          * 16 to 32768 (default 1064)
 507          */
 508         int32_t dev_rx_fifo_size;
 509
 510         /** Number of 4-byte words in the non-periodic Tx FIFO in device mode
 511          * when dynamic FIFO sizing is enabled.
 512          * 16 to 32768 (default 1024)
 513          */
 514         int32_t dev_nperio_tx_fifo_size;
 515
 516         /** Number of 4-byte words in each of the periodic Tx FIFOs in device
 517          * mode when dynamic FIFO sizing is enabled.
 518          * 4 to 768 (default 256)
 519          */
 520         uint32_t dev_perio_tx_fifo_size[MAX_PERIO_FIFOS];
 521
 522         /** Number of 4-byte words in the Rx FIFO in host mode when dynamic
 523          * FIFO sizing is enabled.
 524          * 16 to 32768 (default 1024)
 525          */
 526         int32_t host_rx_fifo_size;
 527
 528         /** Number of 4-byte words in the non-periodic Tx FIFO in host mode
 529          * when Dynamic FIFO sizing is enabled in the core.
 530          * 16 to 32768 (default 1024)
 531          */
 532         int32_t host_nperio_tx_fifo_size;
 533
 534         /** Number of 4-byte words in the host periodic Tx FIFO when dynamic
 535          * FIFO sizing is enabled.
 536          * 16 to 32768 (default 1024)
 537          */
 538         int32_t host_perio_tx_fifo_size;
 539
 540         /** The maximum transfer size supported in bytes.
 541          * 2047 to 65,535  (default 65,535)
 542          */
 543         int32_t max_transfer_size;
 544
 545         /** The maximum number of packets in a transfer.
 546          * 15 to 511  (default 511)
 547          */
 548         int32_t max_packet_count;
 549
 550         /** The number of host channel registers to use.
 551          * 1 to 16 (default 12)
 552          * Note: The FPGA configuration supports a maximum of 12 host channels.
 553          */
 554         int32_t host_channels;
 555
 556         /** The number of endpoints in addition to EP0 available for device
 557          * mode operations.
 558          * 1 to 15 (default 6 IN and OUT)
 559          * Note: The FPGA configuration supports a maximum of 6 IN and OUT
 560          * endpoints in addition to EP0.
 561          */
 562         int32_t dev_endpoints;
 563
 564                 /**
 565                  * Specifies the type of PHY interface to use. By default, the driver
 566                  * will automatically detect the phy_type.
 567                  *
 568                  * 0 - Full Speed PHY
 569                  * 1 - UTMI+ (default)
 570                  * 2 - ULPI
 571                  */
 572         int32_t phy_type;
 573
 574         /**
 575          * Specifies the UTMI+ Data Width. This parameter is
 576          * applicable for a PHY_TYPE of UTMI+ or ULPI. (For a ULPI
 577          * PHY_TYPE, this parameter indicates the data width between
 578          * the MAC and the ULPI Wrapper.) Also, this parameter is
 579          * applicable only if the OTG_HSPHY_WIDTH cC parameter was set
 580          * to "8 and 16 bits", meaning that the core has been
 581          * configured to work at either data path width.
 582          *
 583          * 8 or 16 bits (default 16)
 584          */
 585         int32_t phy_utmi_width;
 586
 587         /**
 588          * Specifies whether the ULPI operates at double or single
 589          * data rate. This parameter is only applicable if PHY_TYPE is
 590          * ULPI.
 591          *
 592          * 0 - single data rate ULPI interface with 8 bit wide data
 593          * bus (default)
 594          * 1 - double data rate ULPI interface with 4 bit wide data
 595          * bus
 596          */
 597         int32_t phy_ulpi_ddr;
 598
 599         /**
 600          * Specifies whether to use the internal or external supply to
 601          * drive the vbus with a ULPI phy.
 602          */
 603         int32_t phy_ulpi_ext_vbus;
 604
 605         /**
 606          * Specifies whether to use the I2Cinterface for full speed PHY. This
 607          * parameter is only applicable if PHY_TYPE is FS.
 608          * 0 - No (default)
 609          * 1 - Yes
 610          */
 611         int32_t i2c_enable;
 612
 613         int32_t ulpi_fs_ls;
 614
 615         int32_t ts_dline;
 616
 617         /**
 618          * Specifies whether dedicated transmit FIFOs are
 619          * enabled for non periodic IN endpoints in device mode
 620          * 0 - No
 621          * 1 - Yes
 622          */
 623         int32_t en_multiple_tx_fifo;
 624
 625         /** Number of 4-byte words in each of the Tx FIFOs in device
 626          * mode when dynamic FIFO sizing is enabled.
 627          * 4 to 768 (default 256)
 628          */
 629         uint32_t dev_tx_fifo_size[MAX_TX_FIFOS];
 630
 631         /** Thresholding enable flag-
 632          * bit 0 - enable non-ISO Tx thresholding
 633          * bit 1 - enable ISO Tx thresholding
 634          * bit 2 - enable Rx thresholding
 635          */
 636         uint32_t thr_ctl;
 637
 638         /** Thresholding length for Tx
 639          *      FIFOs in 32 bit DWORDs
 640          */
 641         uint32_t tx_thr_length;
 642
 643         /** Thresholding length for Rx
 644          *      FIFOs in 32 bit DWORDs
 645          */
 646         uint32_t rx_thr_length;
 647
 648         /**
 649          * Specifies whether LPM (Link Power Management) support is enabled
 650          */
 651         int32_t lpm_enable;
 652
 653         /**
 654         * Specifies whether LPM Errata (Link Power Management) support is enabled
 655         */
 656         int32_t besl_enable;
 657
 658         /**
 659         * Specifies the baseline besl value
 660         */
 661         int32_t baseline_besl;
 662
 663         /**
 664         * Specifies the deep besl value
 665         */
 666         int32_t deep_besl;
 667         /** Per Transfer Interrupt
 668          *      mode enable flag
 669          * 1 - Enabled
 670          * 0 - Disabled
 671          */
 672         int32_t pti_enable;
 673
 674         /** Multi Processor Interrupt
 675          *      mode enable flag
 676          * 1 - Enabled
 677          * 0 - Disabled
 678          */
 679         int32_t mpi_enable;
 680
 681         /** IS_USB Capability
 682          * 1 - Enabled
 683          * 0 - Disabled
 684          */
 685         int32_t ic_usb_cap;
 686
 687         /** AHB Threshold Ratio
 688          * 2'b00 AHB Threshold =        MAC Threshold
 689          * 2'b01 AHB Threshold = 1/2    MAC Threshold
 690          * 2'b10 AHB Threshold = 1/4    MAC Threshold
 691          * 2'b11 AHB Threshold = 1/8    MAC Threshold
 692          */
 693         int32_t ahb_thr_ratio;
 694
 695         /** ADP Support
 696          * 1 - Enabled
 697          * 0 - Disabled
 698          */
 699         int32_t adp_supp_enable;
 700
 701         /** HFIR Reload Control
 702          * 0 - The HFIR cannot be reloaded dynamically.
 703          * 1 - Allow dynamic reloading of the HFIR register during runtime.
 704          */
 705         int32_t reload_ctl;
 706
 707         /** DCFG: Enable device Out NAK
 708          * 0 - The core does not set NAK after Bulk Out transfer complete.
 709          * 1 - The core sets NAK after Bulk OUT transfer complete.
 710          */
 711         int32_t dev_out_nak;
 712
 713         /** DCFG: Enable Continue on BNA
 714          * After receiving BNA interrupt the core disables the endpoint,when the
 715          * endpoint is re-enabled by the application the core starts processing
 716          * 0 - from the DOEPDMA descriptor
 717          * 1 - from the descriptor which received the BNA.
 718          */
 719         int32_t cont_on_bna;
 720
 721         /** GAHBCFG: AHB Single Support
 722          * This bit when programmed supports SINGLE transfers for remainder
 723          * data in a transfer for DMA mode of operation.
 724          * 0 - in this case the remainder data will be sent using INCR burst size.
 725          * 1 - in this case the remainder data will be sent using SINGLE burst size.
 726          */
 727         int32_t ahb_single;
 728
 729         /** Core Power down mode
 730          * 0 - No Power Down is enabled
 731          * 1 - Reserved
 732          * 2 - Complete Power Down (Hibernation)
 733          */
 734         int32_t power_down;
 735
 736         /** OTG revision supported
 737          * 0 - OTG 1.3 revision
 738          * 1 - OTG 2.0 revision
 739          */
 740         int32_t otg_ver;
 741
 742 } dwc_otg_core_params_t;
 743
 744 #ifdef DEBUG
 745 struct dwc_otg_core_if;
 746 typedef struct hc_xfer_info {
 747         struct dwc_otg_core_if *core_if;
 748         dwc_hc_t *hc;
 749 } hc_xfer_info_t;
 750 #endif
 751
 752 typedef struct ep_xfer_info {
 753         struct dwc_otg_core_if *core_if;
 754         dwc_ep_t *ep;
 755         uint8_t state;
 756 } ep_xfer_info_t;
 757 /*
 758  * Device States
 759  */
 760 typedef enum dwc_otg_lx_state {
 761         /** On state */
 762         DWC_OTG_L0,
 763         /** LPM sleep state*/
 764         DWC_OTG_L1,
 765         /** USB suspend state*/
 766         DWC_OTG_L2,
 767         /** Off state*/
 768         DWC_OTG_L3
 769 } dwc_otg_lx_state_e;
 770
 771 struct dwc_otg_global_regs_backup {
 772         uint32_t gotgctl_local;
 773         uint32_t gintmsk_local;
 774         uint32_t gahbcfg_local;
 775         uint32_t gusbcfg_local;
 776         uint32_t grxfsiz_local;
 777         uint32_t gnptxfsiz_local;
 778 #ifdef CONFIG_USB_DWC_OTG_LPM
 779         uint32_t glpmcfg_local;
 780 #endif
 781         uint32_t gi2cctl_local;
 782         uint32_t hptxfsiz_local;
 783         uint32_t pcgcctl_local;
 784         uint32_t gdfifocfg_local;
 785         uint32_t dtxfsiz_local[MAX_EPS_CHANNELS];
 786         uint32_t gpwrdn_local;
 787         uint32_t xhib_pcgcctl;
 788         uint32_t xhib_gpwrdn;
 789 };
 790
 791 struct dwc_otg_host_regs_backup {
 792         uint32_t hcfg_local;
 793         uint32_t haintmsk_local;
 794         uint32_t hcintmsk_local[MAX_EPS_CHANNELS];
 795         uint32_t hprt0_local;
 796         uint32_t hfir_local;
 797 };
 798
 799 struct dwc_otg_dev_regs_backup {
 800         uint32_t dcfg;
 801         uint32_t dctl;
 802         uint32_t daintmsk;
 803         uint32_t diepmsk;
 804         uint32_t doepmsk;
 805         uint32_t diepctl[MAX_EPS_CHANNELS];
 806         uint32_t dieptsiz[MAX_EPS_CHANNELS];
 807         uint32_t diepdma[MAX_EPS_CHANNELS];
 808 };
 809 /**
 810  * The <code>dwc_otg_core_if</code> structure contains information needed to manage
 811  * the DWC_otg controller acting in either host or device mode. It
 812  * represents the programming view of the controller as a whole.
 813  */
 814 struct dwc_otg_core_if {
 815         /** Parameters that define how the core should be configured.*/
 816         dwc_otg_core_params_t *core_params;
 817
 818         /** Core Global registers starting at offset 000h. */
 819         dwc_otg_core_global_regs_t *core_global_regs;
 820
 821         /** Device-specific information */
 822         dwc_otg_dev_if_t *dev_if;
 823         /** Host-specific information */
 824         dwc_otg_host_if_t *host_if;
 825
 826         /** Value from SNPSID register */
 827         uint32_t snpsid;
 828
 829         /** The DWC otg device pointer. */
 830         struct dwc_otg_device *otg_dev;
 831
 832         /*
 833          * Set to 1 if the core PHY interface bits in USBCFG have been
 834          * initialized.
 835          */
 836         uint8_t phy_init_done;
 837
 838         /*
 839          * SRP Success flag, set by srp success interrupt in FS I2C mode
 840          */
 841         uint8_t srp_success;
 842         uint8_t srp_timer_started;
 843         /** Timer for SRP. If it expires before SRP is successful
 844          * clear the SRP. */
 845         dwc_timer_t *srp_timer;
 846
 847         uint8_t usb_mode;
 848 #define USB_MODE_NORMAL (0)
 849 #define USB_MODE_FORCE_HOST (1)
 850 #define USB_MODE_FORCE_DEVICE (2)
 851
 852         /* Indicate USB get VBUS 5V from PMIC(e.g. rk81x) */
 853         bool pmic_vbus;
 854
 855 #ifdef DWC_DEV_SRPCAP
 856         /* This timer is needed to power on the hibernated host core if SRP is not
 857          * initiated on connected SRP capable device for limited period of time
 858          */
 859         uint8_t pwron_timer_started;
 860         dwc_timer_t *pwron_timer;
 861 #endif
 862         /* Common configuration information */
 863         /** Power and Clock Gating Control Register */
 864         volatile uint32_t *pcgcctl;
 865 #define DWC_OTG_PCGCCTL_OFFSET 0xE00
 866
 867         /** Push/pop addresses for endpoints or host channels.*/
 868         uint32_t *data_fifo[MAX_EPS_CHANNELS];
 869 #define DWC_OTG_DATA_FIFO_OFFSET 0x1000
 870 #define DWC_OTG_DATA_FIFO_SIZE 0x1000
 871
 872         /** Total RAM for FIFOs (Bytes) */
 873         uint16_t total_fifo_size;
 874         /** Size of Rx FIFO (Bytes) */
 875         uint16_t rx_fifo_size;
 876         /** Size of Non-periodic Tx FIFO (Bytes) */
 877         uint16_t nperio_tx_fifo_size;
 878
 879         /** 1 if DMA is enabled, 0 otherwise. */
 880         uint8_t dma_enable;
 881
 882         /** 1 if DMA descriptor is enabled, 0 otherwise. */
 883         uint8_t dma_desc_enable;
 884
 885         /** 1 if PTI Enhancement mode is enabled, 0 otherwise. */
 886         uint8_t pti_enh_enable;
 887
 888         /** 1 if MPI Enhancement mode is enabled, 0 otherwise. */
 889         uint8_t multiproc_int_enable;
 890
 891         /** 1 if dedicated Tx FIFOs are enabled, 0 otherwise. */
 892         uint8_t en_multiple_tx_fifo;
 893
 894         /** Set to 1 if multiple packets of a high-bandwidth transfer is in
 895          * process of being queued */
 896         uint8_t queuing_high_bandwidth;
 897
 898         /** Hardware Configuration -- stored here for convenience.*/
 899         hwcfg1_data_t hwcfg1;
 900         hwcfg2_data_t hwcfg2;
 901         hwcfg3_data_t hwcfg3;
 902         hwcfg4_data_t hwcfg4;
 903         fifosize_data_t hptxfsiz;
 904
 905         /** Host and Device Configuration -- stored here for convenience.*/
 906         hcfg_data_t hcfg;
 907         dcfg_data_t dcfg;
 908
 909         /** The operational State, during transations
 910          * (a_host>>a_peripherial and b_device=>b_host) this may not
 911          * match the core but allows the software to determine
 912          * transitions.
 913          */
 914         uint8_t op_state;
 915
 916         /** Test mode for PET testing */
 917         uint8_t test_mode;
 918
 919         /**
 920          * Set to 1 if the HCD needs to be restarted on a session request
 921          * interrupt. This is required if no connector ID status change has
 922          * occurred since the HCD was last disconnected.
 923          */
 924         uint8_t restart_hcd_on_session_req;
 925
 926         /** HCD callbacks */
 927         /** A-Device is a_host */
 928 #define A_HOST          (1)
 929         /** A-Device is a_suspend */
 930 #define A_SUSPEND       (2)
 931         /** A-Device is a_peripherial */
 932 #define A_PERIPHERAL    (3)
 933         /** B-Device is operating as a Peripheral. */
 934 #define B_PERIPHERAL    (4)
 935         /** B-Device is operating as a Host. */
 936 #define B_HOST          (5)
 937
 938         /** HCD callbacks */
 939         struct dwc_otg_cil_callbacks *hcd_cb;
 940         void *hcd_cb_p;
 941         /** PCD callbacks */
 942         struct dwc_otg_cil_callbacks *pcd_cb;
 943
 944         /** Device mode Periodic Tx FIFO Mask */
 945         uint32_t p_tx_msk;
 946         /** Device mode Periodic Tx FIFO Mask */
 947         uint32_t tx_msk;
 948
 949         /** Workqueue object used for handling several interrupts */
 950         dwc_workq_t *wq_otg;
 951
 952         /** Tasklet used for handling "Wakeup Detected" Interrupt*/
 953         dwc_tasklet_t *wkp_tasklet;
 954         /** This arrays used for debug purposes for DEV OUT NAK enhancement */
 955         uint32_t start_doeptsiz_val[MAX_EPS_CHANNELS];
 956         ep_xfer_info_t ep_xfer_info[MAX_EPS_CHANNELS];
 957         dwc_timer_t *ep_xfer_timer[MAX_EPS_CHANNELS];
 958 #ifdef DEBUG
 959         uint32_t start_hcchar_val[MAX_EPS_CHANNELS];
 960
 961         hc_xfer_info_t hc_xfer_info[MAX_EPS_CHANNELS];
 962         dwc_timer_t *hc_xfer_timer[MAX_EPS_CHANNELS];
 963
 964         uint32_t hfnum_7_samples;
 965         uint64_t hfnum_7_frrem_accum;
 966         uint32_t hfnum_0_samples;
 967         uint64_t hfnum_0_frrem_accum;
 968         uint32_t hfnum_other_samples;
 969         uint64_t hfnum_other_frrem_accum;
 970 #endif
 971
 972 #ifdef DWC_UTE_CFI
 973         uint16_t pwron_rxfsiz;
 974         uint16_t pwron_gnptxfsiz;
 975         uint16_t pwron_txfsiz[15];
 976
 977         uint16_t init_rxfsiz;
 978         uint16_t init_gnptxfsiz;
 979         uint16_t init_txfsiz[15];
 980 #endif
 981
 982         /** Lx state of device */
 983         dwc_otg_lx_state_e lx_state;
 984
 985         /** Saved Core Global registers */
 986         struct dwc_otg_global_regs_backup *gr_backup;
 987         /** Saved Host registers */
 988         struct dwc_otg_host_regs_backup *hr_backup;
 989         /** Saved Device registers */
 990         struct dwc_otg_dev_regs_backup *dr_backup;
 991
 992         /** Power Down Enable */
 993         uint32_t power_down;
 994
 995         /** ADP support Enable */
 996         uint32_t adp_enable;
 997
 998         /** ADP structure object */
 999         dwc_otg_adp_t adp;
1000
1001         /** hibernation/suspend flag */
1002         int hibernation_suspend;
1003
1004         /** Device mode extended hibernation flag */
1005         int xhib;
1006
1007         /** OTG revision supported */
1008         uint32_t otg_ver;
1009
1010         /** OTG status flag used for HNP polling */
1011         uint8_t otg_sts;
1012
1013         /** Pointer to either hcd->lock or pcd->lock */
1014         dwc_spinlock_t *lock;
1015
1016         /** Start predict NextEP based on Learning Queue if equal 1,
1017          * also used as counter of disabled NP IN EP's */
1018         uint8_t start_predict;
1019
1020         /** NextEp sequence, including EP0: nextep_seq[] = EP if non-periodic and
1021          * active, 0xff otherwise */
1022         uint8_t nextep_seq[MAX_EPS_CHANNELS];
1023
1024         /** Index of fisrt EP in nextep_seq array which should be re-enabled **/
1025         uint8_t first_in_nextep_seq;
1026
1027         /** Frame number while entering to ISR - needed for ISOCs **/
1028         uint32_t frame_num;
1029
1030         /** Flag to not perform ADP probing if IDSTS event happened */
1031         uint8_t stop_adpprb;
1032
1033 };
1034
1035 #ifdef DEBUG
1036 /*
1037  * This function is called when transfer is timed out.
1038  */
1039 extern void hc_xfer_timeout(void *ptr);
1040 #endif
1041
1042 /*
1043  * This function is called when transfer is timed out on endpoint.
1044  */
1045 extern void ep_xfer_timeout(void *ptr);
1046
1047 /*
1048  * The following functions are functions for works
1049  * using during handling some interrupts
1050  */
1051 extern void w_conn_id_status_change(void *p);
1052
1053 extern void w_wakeup_detected(void *data);
1054
1055 /** Saves global register values into system memory. */
1056 extern int dwc_otg_save_global_regs(dwc_otg_core_if_t *core_if);
1057 /** Saves device register values into system memory. */
1058 extern int dwc_otg_save_dev_regs(dwc_otg_core_if_t *core_if);
1059 /** Saves host register values into system memory. */
1060 extern int dwc_otg_save_host_regs(dwc_otg_core_if_t *core_if);
1061 /** Restore global register values. */
1062 extern int dwc_otg_restore_global_regs(dwc_otg_core_if_t *core_if);
1063 /** Restore host register values. */
1064 extern int dwc_otg_restore_host_regs(dwc_otg_core_if_t *core_if, int reset);
1065 /** Restore device register values. */
1066 extern int dwc_otg_restore_dev_regs(dwc_otg_core_if_t *core_if,
1067                                     int rem_wakeup);
1068 extern int restore_lpm_i2c_regs(dwc_otg_core_if_t *core_if);
1069 extern int restore_essential_regs(dwc_otg_core_if_t *core_if, int rmode,
1070                                   int is_host);
1071
1072 extern int dwc_otg_host_hibernation_restore(dwc_otg_core_if_t *core_if,
1073                                             int restore_mode, int reset);
1074 extern int dwc_otg_device_hibernation_restore(dwc_otg_core_if_t *core_if,
1075                                               int rem_wakeup, int reset);
1076
1077 /*
1078  * The following functions support initialization of the CIL driver component
1079  * and the DWC_otg controller.
1080  */
1081 extern void dwc_otg_core_host_init(dwc_otg_core_if_t *_core_if);
1082 extern void dwc_otg_core_dev_init(dwc_otg_core_if_t *_core_if);
1083
1084 /** @name Device CIL Functions
1085  * The following functions support managing the DWC_otg controller in device
1086  * mode.
1087  */
1088 /**@{*/
1089 extern void dwc_otg_wakeup(dwc_otg_core_if_t *_core_if);
1090 extern void dwc_otg_read_setup_packet(dwc_otg_core_if_t *_core_if,
1091                                       uint32_t *_dest);
1092 extern uint32_t dwc_otg_get_frame_number(dwc_otg_core_if_t *_core_if);
1093 extern void dwc_otg_ep0_activate(dwc_otg_core_if_t *_core_if, dwc_ep_t *_ep);
1094 extern void dwc_otg_ep_activate(dwc_otg_core_if_t *_core_if, dwc_ep_t *_ep);
1095 extern void dwc_otg_ep_deactivate(dwc_otg_core_if_t *_core_if, dwc_ep_t *_ep);
1096 extern void dwc_otg_ep_start_transfer(dwc_otg_core_if_t *_core_if,
1097                                       dwc_ep_t *_ep);
1098 extern void dwc_otg_ep_start_zl_transfer(dwc_otg_core_if_t *_core_if,
1099                                          dwc_ep_t *_ep);
1100 extern void dwc_otg_ep0_start_transfer(dwc_otg_core_if_t *_core_if,
1101                                        dwc_ep_t *_ep);
1102 extern void dwc_otg_ep0_continue_transfer(dwc_otg_core_if_t *_core_if,
1103                                           dwc_ep_t *_ep);
1104 extern void dwc_otg_ep_write_packet(dwc_otg_core_if_t *_core_if,
1105                                     dwc_ep_t *_ep, int _dma);
1106 extern void dwc_otg_ep_set_stall(dwc_otg_core_if_t *_core_if, dwc_ep_t *_ep);
1107 extern void dwc_otg_ep_clear_stall(dwc_otg_core_if_t *_core_if,
1108                                    dwc_ep_t *_ep);
1109 extern void dwc_otg_enable_device_interrupts(dwc_otg_core_if_t *_core_if);
1110
1111 #ifdef DWC_EN_ISOC
1112 extern void dwc_otg_iso_ep_start_frm_transfer(dwc_otg_core_if_t *core_if,
1113                                               dwc_ep_t *ep);
1114 extern void dwc_otg_iso_ep_start_buf_transfer(dwc_otg_core_if_t *core_if,
1115                                               dwc_ep_t *ep);
1116 #endif /* DWC_EN_ISOC */
1117 /**@}*/
1118
1119 /** @name Host CIL Functions
1120  * The following functions support managing the DWC_otg controller in host
1121  * mode.
1122  */
1123 /**@{*/
1124 extern void dwc_otg_hc_init(dwc_otg_core_if_t *_core_if, dwc_hc_t *_hc);
1125 extern void dwc_otg_hc_halt(dwc_otg_core_if_t *_core_if,
1126                             dwc_hc_t *_hc, dwc_otg_halt_status_e _halt_status);
1127 extern void dwc_otg_hc_cleanup(dwc_otg_core_if_t *_core_if, dwc_hc_t *_hc);
1128 extern void dwc_otg_hc_start_transfer(dwc_otg_core_if_t *_core_if,
1129                                       dwc_hc_t *_hc);
1130 extern int dwc_otg_hc_continue_transfer(dwc_otg_core_if_t *_core_if,
1131                                         dwc_hc_t *_hc);
1132 extern void dwc_otg_hc_do_ping(dwc_otg_core_if_t *_core_if, dwc_hc_t *_hc);
1133 extern void dwc_otg_hc_write_packet(dwc_otg_core_if_t *_core_if,
1134                                     dwc_hc_t *_hc);
1135 extern void dwc_otg_enable_host_interrupts(dwc_otg_core_if_t *_core_if);
1136 extern void dwc_otg_disable_host_interrupts(dwc_otg_core_if_t *_core_if);
1137
1138 extern void dwc_otg_hc_start_transfer_ddma(dwc_otg_core_if_t *core_if,
1139                                            dwc_hc_t *hc);
1140
1141 extern uint32_t calc_frame_interval(dwc_otg_core_if_t *core_if);
1142 extern int dwc_otg_check_haps_status(dwc_otg_core_if_t *core_if);
1143
1144 /* Macro used to clear one channel interrupt */
1145 #define clear_hc_int(_hc_regs_, _intr_) \
1146 do { \
1147         hcint_data_t hcint_clear = {.d32 = 0}; \
1148         hcint_clear.b._intr_ = 1; \
1149         DWC_WRITE_REG32(&(_hc_regs_)->hcint, hcint_clear.d32); \
1150 } while (0)
1151
1152 /*
1153  * Macro used to disable one channel interrupt. Channel interrupts are
1154  * disabled when the channel is halted or released by the interrupt handler.
1155  * There is no need to handle further interrupts of that type until the
1156  * channel is re-assigned. In fact, subsequent handling may cause crashes
1157  * because the channel structures are cleaned up when the channel is released.
1158  */
1159 #define disable_hc_int(_hc_regs_, _intr_) \
1160 do { \
1161         hcintmsk_data_t hcintmsk = {.d32 = 0}; \
1162         hcintmsk.b._intr_ = 1; \
1163         DWC_MODIFY_REG32(&(_hc_regs_)->hcintmsk, hcintmsk.d32, 0); \
1164 } while (0)
1165
1166 /**
1167  * This function Reads HPRT0 in preparation to modify. It keeps the
1168  * WC bits 0 so that if they are read as 1, they won't clear when you
1169  * write it back
1170  */
1171 static inline uint32_t dwc_otg_read_hprt0(dwc_otg_core_if_t *_core_if)
1172 {
1173         hprt0_data_t hprt0;
1174         hprt0.d32 = DWC_READ_REG32(_core_if->host_if->hprt0);
1175         hprt0.b.prtena = 0;
1176         hprt0.b.prtconndet = 0;
1177         hprt0.b.prtenchng = 0;
1178         hprt0.b.prtovrcurrchng = 0;
1179         return hprt0.d32;
1180 }
1181
1182 /**@}*/
1183
1184 /** @name Common CIL Functions
1185  * The following functions support managing the DWC_otg controller in either
1186  * device or host mode.
1187  */
1188 /**@{*/
1189
1190 extern void dwc_otg_read_packet(dwc_otg_core_if_t *core_if,
1191                                 uint8_t *dest, uint16_t bytes);
1192
1193 extern void dwc_otg_flush_tx_fifo(dwc_otg_core_if_t *_core_if, const int _num);
1194 extern void dwc_otg_flush_rx_fifo(dwc_otg_core_if_t *_core_if);
1195 extern void dwc_otg_core_reset(dwc_otg_core_if_t *_core_if);
1196
1197 /**
1198  * This function returns the Core Interrupt register.
1199  */
1200 static inline uint32_t dwc_otg_read_core_intr(dwc_otg_core_if_t *core_if)
1201 {
1202         uint32_t retval;
1203         retval = DWC_READ_REG32(&core_if->core_global_regs->gintsts) &
1204                  DWC_READ_REG32(&core_if->core_global_regs->gintmsk);
1205         return retval;
1206 }
1207
1208 /**
1209  * This function returns the OTG Interrupt register.
1210  */
1211 static inline uint32_t dwc_otg_read_otg_intr(dwc_otg_core_if_t *core_if)
1212 {
1213         uint32_t retval;
1214         retval = DWC_READ_REG32(&core_if->core_global_regs->gotgint);
1215         return retval;
1216 }
1217
1218 /**
1219  * This function reads the Device All Endpoints Interrupt register and
1220  * returns the IN endpoint interrupt bits.
1221  */
1222 static inline uint32_t dwc_otg_read_dev_all_in_ep_intr(dwc_otg_core_if_t
1223                                                        *core_if)
1224 {
1225
1226         uint32_t v;
1227
1228         if (core_if->multiproc_int_enable) {
1229                 v = DWC_READ_REG32(&core_if->dev_if->dev_global_regs->
1230                                    deachint) & DWC_READ_REG32(&core_if->dev_if->
1231                                                               dev_global_regs->
1232                                                               deachintmsk);
1233         } else {
1234                 v = DWC_READ_REG32(&core_if->dev_if->dev_global_regs->daint) &
1235                     DWC_READ_REG32(&core_if->dev_if->dev_global_regs->daintmsk);
1236         }
1237         v &= 0xffff;
1238         return v;
1239 }
1240
1241 /**
1242  * This function reads the Device All Endpoints Interrupt register and
1243  * returns the OUT endpoint interrupt bits.
1244  */
1245 static inline uint32_t dwc_otg_read_dev_all_out_ep_intr(dwc_otg_core_if_t
1246                                                         *core_if)
1247 {
1248         uint32_t v;
1249
1250         if (core_if->multiproc_int_enable) {
1251                 v = DWC_READ_REG32(&core_if->dev_if->dev_global_regs->
1252                                    deachint) & DWC_READ_REG32(&core_if->dev_if->
1253                                                               dev_global_regs->
1254                                                               deachintmsk);
1255         } else {
1256                 v = DWC_READ_REG32(&core_if->dev_if->dev_global_regs->daint) &
1257                     DWC_READ_REG32(&core_if->dev_if->dev_global_regs->daintmsk);
1258         }
1259
1260         v = (v & 0xffff0000) >> 16;
1261         return v;
1262 }
1263
1264 /**
1265  * This function returns the Device IN EP Interrupt register
1266  */
1267 static inline uint32_t dwc_otg_read_dev_in_ep_intr(dwc_otg_core_if_t *core_if,
1268                                                    dwc_ep_t *ep)
1269 {
1270         dwc_otg_dev_if_t *dev_if = core_if->dev_if;
1271         uint32_t v, msk, emp;
1272
1273         if (core_if->multiproc_int_enable) {
1274                 msk =
1275                     DWC_READ_REG32(&dev_if->dev_global_regs->
1276                                    diepeachintmsk[ep->num]);
1277                 emp =
1278                     DWC_READ_REG32(&dev_if->dev_global_regs->
1279                                    dtknqr4_fifoemptymsk);
1280                 msk |= ((emp >> ep->num) & 0x1) << 7;
1281                 v = DWC_READ_REG32(&dev_if->in_ep_regs[ep->num]->diepint) & msk;
1282         } else {
1283                 msk = DWC_READ_REG32(&dev_if->dev_global_regs->diepmsk);
1284                 emp =
1285                     DWC_READ_REG32(&dev_if->dev_global_regs->
1286                                    dtknqr4_fifoemptymsk);
1287                 msk |= ((emp >> ep->num) & 0x1) << 7;
1288                 v = DWC_READ_REG32(&dev_if->in_ep_regs[ep->num]->diepint) & msk;
1289         }
1290
1291         return v;
1292 }
1293
1294 /**
1295  * This function returns the Device OUT EP Interrupt register
1296  */
1297 static inline uint32_t dwc_otg_read_dev_out_ep_intr(dwc_otg_core_if_t *
1298                                                     _core_if, dwc_ep_t *_ep)
1299 {
1300         dwc_otg_dev_if_t *dev_if = _core_if->dev_if;
1301         uint32_t v;
1302         doepmsk_data_t msk = {.d32 = 0 };
1303
1304         if (_core_if->multiproc_int_enable) {
1305                 msk.d32 =
1306                     DWC_READ_REG32(&dev_if->dev_global_regs->
1307                                    doepeachintmsk[_ep->num]);
1308                 if (_core_if->pti_enh_enable) {
1309                         msk.b.pktdrpsts = 1;
1310                 }
1311                 v = DWC_READ_REG32(&dev_if->out_ep_regs[_ep->num]->
1312                                    doepint) & msk.d32;
1313         } else {
1314                 msk.d32 = DWC_READ_REG32(&dev_if->dev_global_regs->doepmsk);
1315                 if (_core_if->pti_enh_enable) {
1316                         msk.b.pktdrpsts = 1;
1317                 }
1318                 v = DWC_READ_REG32(&dev_if->out_ep_regs[_ep->num]->
1319                                    doepint) & msk.d32;
1320         }
1321         return v;
1322 }
1323
1324 /**
1325  * This function returns the Host All Channel Interrupt register
1326  */
1327 static inline uint32_t dwc_otg_read_host_all_channels_intr(dwc_otg_core_if_t *
1328                                                            _core_if)
1329 {
1330         uint32_t retval;
1331         retval = DWC_READ_REG32(&_core_if->host_if->host_global_regs->haint);
1332         return retval;
1333 }
1334
1335 static inline uint32_t dwc_otg_read_host_channel_intr(dwc_otg_core_if_t *
1336                                                       _core_if, dwc_hc_t *_hc)
1337 {
1338         uint32_t retval;
1339         retval = DWC_READ_REG32(&_core_if->host_if->hc_regs[_hc->hc_num]->hcint);
1340         return retval;
1341 }
1342
1343 /**
1344  * This function returns the mode of the operation, host or device.
1345  *
1346  * @return 0 - Device Mode, 1 - Host Mode
1347  */
1348 static inline uint32_t dwc_otg_mode(dwc_otg_core_if_t *_core_if)
1349 {
1350         uint32_t retval;
1351         retval = DWC_READ_REG32(&_core_if->core_global_regs->gintsts) & 0x1;
1352         return retval;
1353 }
1354
1355 /**@}*/
1356
1357 /**
1358  * DWC_otg CIL callback structure. This structure allows the HCD and
1359  * PCD to register functions used for starting and stopping the PCD
1360  * and HCD for role change on for a DRD.
1361  */
1362 typedef struct dwc_otg_cil_callbacks {
1363         /** Start function for role change */
1364         int (*start) (void *_p);
1365         /** Stop Function for role change */
1366         int (*stop) (void *_p);
1367         /** Disconnect Function for role change */
1368         int (*disconnect) (void *_p);
1369         /** Resume/Remote wakeup Function */
1370         int (*resume_wakeup) (void *_p);
1371         /** Suspend function */
1372         int (*suspend) (void *_p);
1373         /** Session Start (SRP) */
1374         int (*session_start) (void *_p);
1375 #ifdef CONFIG_USB_DWC_OTG_LPM
1376         /** Sleep (switch to L0 state) */
1377         int (*sleep) (void *_p);
1378 #endif
1379         /** Pointer passed to start() and stop() */
1380         void *p;
1381 } dwc_otg_cil_callbacks_t;
1382
1383 extern void dwc_otg_cil_register_pcd_callbacks(dwc_otg_core_if_t *_core_if,
1384                                                dwc_otg_cil_callbacks_t *_cb,
1385                                                void *_p);
1386 extern void dwc_otg_cil_register_hcd_callbacks(dwc_otg_core_if_t *_core_if,
1387                                                dwc_otg_cil_callbacks_t *_cb,
1388                                                void *_p);
1389
1390 void dwc_otg_initiate_srp(void *core_if);
1391
1392 /** Start the HCD.  Helper function for using the HCD callbacks.
1393  *
1394  * @param core_if Programming view of DWC_otg controller.
1395  */
1396 static inline void cil_hcd_start(dwc_otg_core_if_t *core_if)
1397 {
1398         if (core_if->hcd_cb && core_if->hcd_cb->start) {
1399                 core_if->hcd_cb->start(core_if->hcd_cb_p);
1400         }
1401 }
1402
1403 /** Stop the HCD.  Helper function for using the HCD callbacks.
1404  *
1405  * @param core_if Programming view of DWC_otg controller.
1406  */
1407 static inline void cil_hcd_stop(dwc_otg_core_if_t *core_if)
1408 {
1409         if (core_if->hcd_cb && core_if->hcd_cb->stop) {
1410                 core_if->hcd_cb->stop(core_if->hcd_cb_p);
1411         }
1412 }
1413
1414 /** Disconnect the HCD.  Helper function for using the HCD callbacks.
1415  *
1416  * @param core_if Programming view of DWC_otg controller.
1417  */
1418 static inline void cil_hcd_disconnect(dwc_otg_core_if_t *core_if)
1419 {
1420         if (core_if->hcd_cb && core_if->hcd_cb->disconnect) {
1421                 core_if->hcd_cb->disconnect(core_if->hcd_cb_p);
1422         }
1423 }
1424
1425 /** Inform the HCD the a New Session has begun.  Helper function for
1426  * using the HCD callbacks.
1427  *
1428  * @param core_if Programming view of DWC_otg controller.
1429  */
1430 static inline void cil_hcd_session_start(dwc_otg_core_if_t *core_if)
1431 {
1432         if (core_if->hcd_cb && core_if->hcd_cb->session_start) {
1433                 core_if->hcd_cb->session_start(core_if->hcd_cb_p);
1434         }
1435 }
1436
1437 #ifdef CONFIG_USB_DWC_OTG_LPM
1438 /**
1439  * Inform the HCD about LPM sleep.
1440  * Helper function for using the HCD callbacks.
1441  *
1442  * @param core_if Programming view of DWC_otg controller.
1443  */
1444 static inline void cil_hcd_sleep(dwc_otg_core_if_t *core_if)
1445 {
1446         if (core_if->hcd_cb && core_if->hcd_cb->sleep) {
1447                 core_if->hcd_cb->sleep(core_if->hcd_cb_p);
1448         }
1449 }
1450 #endif
1451
1452 /** Resume the HCD.  Helper function for using the HCD callbacks.
1453  *
1454  * @param core_if Programming view of DWC_otg controller.
1455  */
1456 static inline void cil_hcd_resume(dwc_otg_core_if_t *core_if)
1457 {
1458         if (core_if->hcd_cb && core_if->hcd_cb->resume_wakeup) {
1459                 core_if->hcd_cb->resume_wakeup(core_if->hcd_cb_p);
1460         }
1461 }
1462
1463 /** Start the PCD.  Helper function for using the PCD callbacks.
1464  *
1465  * @param core_if Programming view of DWC_otg controller.
1466  */
1467 static inline void cil_pcd_start(dwc_otg_core_if_t *core_if)
1468 {
1469         if (core_if->pcd_cb && core_if->pcd_cb->start) {
1470                 core_if->pcd_cb->start(core_if->pcd_cb->p);
1471         }
1472 }
1473
1474 /** Stop the PCD.  Helper function for using the PCD callbacks.
1475  *
1476  * @param core_if Programming view of DWC_otg controller.
1477  */
1478 static inline void cil_pcd_stop(dwc_otg_core_if_t *core_if)
1479 {
1480         if (core_if->pcd_cb && core_if->pcd_cb->stop) {
1481                 core_if->pcd_cb->stop(core_if->pcd_cb->p);
1482         }
1483 }
1484
1485 /** Suspend the PCD.  Helper function for using the PCD callbacks.
1486  *
1487  * @param core_if Programming view of DWC_otg controller.
1488  */
1489 static inline void cil_pcd_suspend(dwc_otg_core_if_t *core_if)
1490 {
1491         if (core_if->pcd_cb && core_if->pcd_cb->suspend) {
1492                 core_if->pcd_cb->suspend(core_if->pcd_cb->p);
1493         }
1494 }
1495
1496 /** Resume the PCD.  Helper function for using the PCD callbacks.
1497  *
1498  * @param core_if Programming view of DWC_otg controller.
1499  */
1500 static inline void cil_pcd_resume(dwc_otg_core_if_t *core_if)
1501 {
1502         if (core_if->pcd_cb && core_if->pcd_cb->resume_wakeup) {
1503                 core_if->pcd_cb->resume_wakeup(core_if->pcd_cb->p);
1504         }
1505 }
1506
1507 void dwc_otg_set_force_mode(dwc_otg_core_if_t *core_if, int mode);
1508
1509 #endif