docs/api_guide_am261x/pcd_8h_source.html

/* ==========================================================================

 * $File: //dwh/usb_iip/dev/software/DWC_usb3/driver/pcd.h $

 * $Revision: #66 $

 * $Date: 2013/12/17 $

 * $Change: 2392669 $

 *

 * Synopsys SS USB3 Linux Software Driver and documentation (hereinafter,

 * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless

 * otherwise expressly agreed to in writing between Synopsys and you.

 *

 * The Software IS NOT an item of Licensed Software or Licensed Product under

 * any End User Software License Agreement or Agreement for Licensed Product

 * with Synopsys or any supplement thereto. You are permitted to use and

 * redistribute this Software in source and binary forms, with or without

 * modification, provided that redistributions of source code must retain this

 * notice. You may not view, use, disclose, copy or distribute this file or

 * any information contained herein except pursuant to this license grant from

 * Synopsys. If you do not agree with this notice, including the disclaimer

 * below, then you are not authorized to use the Software.

 *

 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS BE LIABLE FOR ANY DIRECT,

 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH

 * DAMAGE.

 * ========================================================================== */

#ifndef _DWC_PCD_H_

#define _DWC_PCD_H_


#ifdef __cplusplus

extern "C" {

#endif


#include "dwc_queue.h"


#define DWC_MAX_TX_FIFOS    16


#define DWC_MAX_PHYS_EP     32


#define DWC_MAX_DATA_BUFS   13


/*16 TODO reducing the memory foot print */

#define DWC_MAX_EPS     5U


#define DWC_MAX_EP0_SIZE    512


#define DWC_MAX_PACKET_SIZE 1024


typedef enum ep0_state {

    EP0_IDLE,

    EP0_IN_DATA_PHASE,

    EP0_OUT_DATA_PHASE,

    EP0_IN_WAIT_GADGET,

    EP0_OUT_WAIT_GADGET,

    EP0_IN_WAIT_NRDY,

    EP0_OUT_WAIT_NRDY,

    EP0_IN_STATUS_PHASE,

    EP0_OUT_STATUS_PHASE,

    EP0_STALL,

} ep0state_e;


typedef enum pcd_state {

    DWC_STATE_UNCONNECTED,

    DWC_STATE_DEFAULT,

    DWC_STATE_ADDRESSED,

    DWC_STATE_CONFIGURED,

} pcdstate_e;


struct dwc_usb3_device;

struct dwc_usb3_pcd;


typedef struct dwc_reqt {

    dwc_usb3_dma_desc_t *trb;

    dwc_dma_t trbdma;

    u32 length;

    u32 actual;

    u32 stream;

    u32 flags;

#define DWC_PCD_REQ_ZERO    0x001U

#define DWC_PCD_REQ_STARTED 0x002U

#define DWC_PCD_REQ_MAP_DMA 0x100

#define DWC_PCD_REQ_IN      0x200

    int numbuf;

    char *buf[DWC_MAX_DATA_BUFS];

    dwc_dma_t bufdma[DWC_MAX_DATA_BUFS];

    u32 buflen[DWC_MAX_DATA_BUFS];

} dwc_req_t;


typedef struct dwc_usb3_pcd_req {

    dwc_req_t dwc_req;


    /* ==== The rest is OS-specific ==== */


#if defined(__linux__) || defined(SELA_PLATFORM)

    struct list_head entry;

#else

    DWC_CIRCLEQ_ENTRY(dwc_usb3_pcd_req) entry;

#endif


    struct usb_request usb_req;

} dwc_usb3_pcd_req_t;


typedef struct dwc_usb3_event_req{

    u32 event;

    DWC_SIMPLEQ_ENTRY(dwc_usb3_event_req) entry;

}  dwc_usb3_event_req_t ;

typedef struct dwc_ept {

    struct dwc_usb3_pcd *pcd;


    dwc_usb3_dev_ep_regs_t __iomem *out_ep_reg;


    dwc_usb3_dev_ep_regs_t __iomem *in_ep_reg;


    u8 phys;


    u8 num;


    u8 type;


    u8 intvl;


    u16 maxpacket;


    u8 mult;


    u8 maxburst;


    u8 num_streams;


    u8 tx_fifo_num;


    u8 tri_out;

    u8 tri_in;

    unsigned int stopped        : 1;

    unsigned int disabling      : 1;

    unsigned int queue_sof      : 1;

    unsigned int send_zlp       : 1;


    unsigned int stall_clear_flag   : 1;


    unsigned int three_stage    : 1;


    unsigned int xfer_started   : 1;

    unsigned int is_in      : 1;


    unsigned int active     : 1;


    unsigned int desc_link      : 1;


    unsigned int data_pid_start : 1;


    unsigned int ena_once       : 1;


    unsigned int stalled_save   : 1;


    u32 param0out;

    u32 param1out;

    u32 param0in;

    u32 param1in;

    u32 save_state;


    const usb_endpoint_descriptor_t *usb_ep_desc;


    dwc_usb3_dma_desc_t *dma_desc;

    dwc_dma_t dma_desc_dma;

    int desc_size;

    int num_desc;

    int desc_avail;


    int desc_idx;


    int hiber_desc_idx;


    /* ==== The rest is OS-specific ==== */


    u32 condition;


#if defined(__linux__) || defined(SELA_PLATFORM)

    struct list_head queue;

#else

    DWC_CIRCLEQ_HEAD(circleq, dwc_usb3_pcd_req) queue;

#endif

} dwc_ep_t;


typedef union dwc_setup_pkt {

    usb_device_request_t req;

    u32 d32[2];

    char d8[8];

} dwc_setup_pkt_t;


typedef struct dwc_usb3_pcd_ep {

    dwc_ep_t dwc_ep;


    /* ==== The rest is OS-specific ==== */


    struct usb_ept usb_ep;

} dwc_usb3_pcd_ep_t;


/* PCD EP accessor functions */

#define dwc_usb3_pcd_ep_to_pcd(pcd_ep)  ((pcd_ep)->dwc_ep.pcd)


#define dwc_usb3_pcd_ep_num(pcd_ep) ((pcd_ep)->dwc_ep.num)


#define dwc_usb3_pcd_ep_type(pcd_ep)    ((pcd_ep)->dwc_ep.type)


#define dwc_usb3_pcd_ep_is_in(pcd_ep)   ((pcd_ep)->dwc_ep.is_in)


struct dwc_hiber_scratchpad_array {

    u64 dma_addr[15];

};


typedef struct dwc_usb3_pcd {

    struct dwc_usb3_device *usb3_dev;


    int link_state;


    pcdstate_e state;


    ep0state_e ep0state;


    unsigned int ep0_status_pending     : 1;


    unsigned int request_config     : 1;


    unsigned int remote_wakeup_enable   : 1;


    unsigned int ltm_enable         : 1;


    unsigned int send_lpm           : 1;


    unsigned int wkup_rdy           : 1;


    unsigned int eps_enabled        : 1;


    unsigned int ute_change         : 1;


#ifdef DWC_STAR_9000463548_WORKAROUND

    unsigned int configuring        : 1;

#endif


#ifdef CONFIG_USB_OTG_DWC


    unsigned int wants_host         : 1;


    unsigned int b_hnp_enable       : 1;

#endif


    volatile dwc_usb3_pcd_ep_t *ep0;


    volatile dwc_usb3_pcd_ep_t *out_ep[DWC_MAX_EPS - 1U];


    volatile dwc_usb3_pcd_ep_t *in_ep[DWC_MAX_EPS - 1U];


    dwc_usb3_dev_global_regs_t __iomem *dev_global_regs;


    dwc_usb3_dev_ep_regs_t __iomem *out_ep_regs;


    dwc_usb3_dev_ep_regs_t __iomem *in_ep_regs;


    void *hiber_scratchpad[15];

    struct dwc_hiber_scratchpad_array *hiber_scratchpad_array;

    dwc_dma_t hiber_scratchpad_array_dma;

    u32 ep0_out_save_state;

    u32 ep0_in_save_state;

    volatile dwc_usb3_pcd_req_t *ep0_req;


#ifdef DWC_UTE


    unsigned rxf_size;


    unsigned txf_size[DWC_MAX_TX_FIFOS];


    unsigned txf_map[DWC_MAX_PHYS_EP];


    unsigned def_rxf_size;


    unsigned def_txf_size[DWC_MAX_TX_FIFOS];

#endif


    u16 rx_thr_en;

    u16 iso_tx_thr_en;

    u16 non_iso_tx_thr_en;

    u16 rx_thr_length;

    u16 tx_thr_length;

    u8 speed;

    u8 num_out_eps;

    u8 num_in_eps;

    u8 test_mode;


    unsigned request_pending;


    /* ==== The rest is OS-specific ==== */

#ifdef SELA_PLATFORM


    int max_in_eps, max_out_eps;


    int *dev_event, *ep_event;

#endif

#if defined(__linux__) || defined(LINUXTEST)


    spinlock_t lock;

#endif

#ifdef __linux__


    struct usb_gadget *gadget;

#endif


    struct tasklet_struct test_mode_tasklet;


    dwc_usb3_dma_desc_t *ep0_setup_desc;

    dwc_dma_t ep0_setup_desc_dma;

    dwc_usb3_dma_desc_t *ep0_out_desc;

    dwc_dma_t ep0_out_desc_dma;

    dwc_usb3_dma_desc_t *ep0_in_desc;

    dwc_dma_t ep0_in_desc_dma;

    u8 *ep0_status_buf;

    dwc_dma_t ep0_status_buf_dma;

#define DWC_STATUS_BUF_SIZE 512U


    dwc_setup_pkt_t *ep0_setup_pkt;

    dwc_dma_t ep0_setup_pkt_dma;

    dwc_queue_t event_q;

} dwc_usb3_pcd_t;


/* PCD accessor functions */

#define dwc_usb3_ep0_setup_desc(pcd)        (pcd)->ep0_setup_desc


#define dwc_usb3_ep0_setup_desc_dma(pcd)    (pcd)->ep0_setup_desc_dma


#define dwc_usb3_ep0_out_desc(pcd)      (pcd)->ep0_out_desc


#define dwc_usb3_ep0_out_desc_dma(pcd)      (pcd)->ep0_out_desc_dma


#define dwc_usb3_ep0_in_desc(pcd)       (pcd)->ep0_in_desc


#define dwc_usb3_ep0_in_desc_dma(pcd)       (pcd)->ep0_in_desc_dma


#define dwc_usb3_ep0_setup_pkt(pcd)     (pcd)->ep0_setup_pkt


#define dwc_usb3_ep0_setup_pkt_dma(pcd)     (pcd)->ep0_setup_pkt_dma


extern void dwc_usb3_stop_all_xfers(volatile dwc_usb3_pcd_t *pcd);

extern void dwc_usb3_complete_request(volatile dwc_usb3_pcd_t *pcd,

                     volatile dwc_usb3_pcd_ep_t *ep, u32 event);

extern volatile dwc_usb3_pcd_ep_t *dwc_usb3_get_out_ep(volatile dwc_usb3_pcd_t *pcd, u32 ep_num);

extern volatile dwc_usb3_pcd_ep_t *dwc_usb3_get_in_ep(volatile dwc_usb3_pcd_t *pcd, u32 ep_num);

#ifdef DEBUG_EP0

extern void dwc_usb3_print_ep0_state(volatile dwc_usb3_pcd_t *pcd);

#endif

extern void dwc_usb3_handle_ep_intr(volatile dwc_usb3_pcd_t *pcd, u32 physep, u32 event);

extern int dwc_usb3_handle_dev_intr(volatile dwc_usb3_pcd_t *pcd, u32 event);

extern void dwc_usb3_handle_connect_done_intr(volatile dwc_usb3_pcd_t *pcd);

extern void dwc_enter_hibernation(volatile dwc_usb3_pcd_t *pcd, int save_state);

extern void dwc_exit_hibernation_after_connect(volatile dwc_usb3_pcd_t *pcd,

                           int connected);

extern int dwc_exit_hibernation(volatile dwc_usb3_pcd_t *pcd, int restore_state);

extern int dwc_usb3_handle_pme_intr(volatile struct dwc_usb3_device *dev);

extern void dwc_usb3_power_ctl(volatile struct dwc_usb3_device *dev, int on);


extern int dwc_usb3_pcd_init(volatile struct dwc_usb3_device *dev);

extern void dwc_usb3_pcd_remove(volatile struct dwc_usb3_device *dev);

extern dwc_usb3_dma_desc_t *dwc_usb3_pcd_trb_alloc(volatile dwc_usb3_pcd_ep_t *ep,

        int num_trbs, uByte trb_type, int iso_intvl, int link,

        dwc_dma_t *trbs_dma_ret);

extern void dwc_usb3_pcd_trb_free(volatile dwc_usb3_pcd_ep_t *ep /*, int num_trbs, int link,

                  void *trbs, dwc_dma_t trbs_dma*/);

extern void dwc_usb3_pcd_fill_trbs(volatile dwc_usb3_pcd_t *pcd, volatile dwc_usb3_pcd_ep_t *ep,

                   dwc_usb3_pcd_req_t *req);

extern void dwc_usb3_ep_activate(volatile dwc_usb3_pcd_t *pcd, volatile dwc_usb3_pcd_ep_t *ep,

    int restore);

extern int dwc_usb3_pcd_ep_enable(volatile dwc_usb3_pcd_t *pcd, volatile dwc_usb3_pcd_ep_t *ep,

            const usb_endpoint_descriptor_t *ep_desc,

            const ss_endpoint_companion_descriptor_t *ep_comp);

extern int dwc_usb3_pcd_ep_disable(volatile dwc_usb3_pcd_t *pcd, volatile dwc_usb3_pcd_ep_t *ep);

extern int dwc_usb3_pcd_ep_submit_req(volatile dwc_usb3_pcd_t *pcd,

                      dwc_usb3_pcd_ep_t *ep,

                      dwc_usb3_pcd_req_t *req, u32 req_flags);

extern void dwc_usb3_pcd_ep_cancel_req(volatile dwc_usb3_pcd_t *pcd,

                       dwc_usb3_pcd_ep_t *ep,

                       dwc_usb3_pcd_req_t *req, u32 stream);

extern void dwc_usb3_pcd_request_done(volatile dwc_usb3_pcd_t *pcd,

                      volatile dwc_usb3_pcd_ep_t *ep,

                      volatile dwc_usb3_pcd_req_t *req, int status);

extern void dwc_usb3_pcd_ep_start_transfer(volatile dwc_usb3_pcd_t *pcd,

                       volatile dwc_usb3_pcd_ep_t *ep,

                       volatile dwc_usb3_pcd_req_t *req, u32 event);

extern void dwc_usb3_pcd_ep_set_stall(volatile dwc_usb3_pcd_t *pcd,

                      volatile dwc_usb3_pcd_ep_t *ep);

extern void dwc_usb3_pcd_ep_clear_stall(volatile dwc_usb3_pcd_t *pcd,

                    volatile dwc_usb3_pcd_ep_t *ep);

extern void dwc_usb3_pcd_ep_set_halt(volatile dwc_usb3_pcd_t *pcd, volatile dwc_usb3_pcd_ep_t *ep,

                     int value);

extern void dwc_usb3_ep0_activate(volatile dwc_usb3_pcd_t *pcd, int restore);

extern void dwc_usb3_pcd_ep0_out_start(volatile dwc_usb3_pcd_t *pcd);

extern void dwc_usb3_pcd_ep0_start_transfer(volatile dwc_usb3_pcd_t *pcd,

                       volatile dwc_usb3_pcd_req_t *req);

extern void dwc_usb3_pcd_ep0_data_stage(volatile dwc_usb3_pcd_t *pcd, int length);

extern void dwc_usb3_handle_ep0_xfer(volatile dwc_usb3_pcd_t *pcd, u32 event);


extern volatile dwc_usb3_pcd_ep_t *dwc_usb3_pcd_get_ep_by_addr(volatile dwc_usb3_pcd_t *pcd,

                              u16 idx);

extern int dwc_usb3_pcd_get_frame_number(volatile dwc_usb3_pcd_t *pcd);

extern int dwc_usb3_pcd_isoc_ep_hiber_restart(volatile dwc_usb3_pcd_t *pcd,

                         volatile dwc_usb3_pcd_ep_t *ep);

extern void dwc_usb3_pcd_stop(volatile dwc_usb3_pcd_t *pcd);

extern int dwc_usb3_gadget_connect(volatile dwc_usb3_pcd_t *pcd, int speed);

extern int dwc_usb3_gadget_disconnect(volatile dwc_usb3_pcd_t *pcd);

extern int dwc_usb3_gadget_suspend(volatile dwc_usb3_pcd_t *pcd);

extern int dwc_usb3_gadget_resume(volatile dwc_usb3_pcd_t *pcd);

extern int dwc_usb3_gadget_setup(volatile dwc_usb3_pcd_t *pcd,

                 usb_device_request_t *ctrl);

extern int dwc_usb3_gadget_complete(volatile dwc_usb3_pcd_t *pcd, volatile dwc_usb3_pcd_ep_t *ep,

                    volatile dwc_usb3_pcd_req_t *pcd_req, int status);

extern void *dwc_usb3_gadget_alloc_dma(volatile dwc_usb3_pcd_ep_t *ep, int size,

                       dwc_dma_t *mem_dma_ret);

extern void dwc_usb3_gadget_free_dma(volatile dwc_usb3_pcd_ep_t *ep, int size, void *mem,

                     dwc_dma_t mem_dma);

extern dwc_usb3_pcd_req_t *dwc_usb3_gadget_get_request(volatile dwc_usb3_pcd_t *pcd,

                               volatile dwc_usb3_pcd_ep_t *ep);

extern void dwc_usb3_gadget_start_next_request(volatile dwc_usb3_pcd_t *pcd,

                          volatile dwc_usb3_pcd_ep_t *ep);

extern void dwc_usb3_gadget_isoc_ep_start(volatile dwc_usb3_pcd_t *pcd,

                     volatile dwc_usb3_pcd_ep_t *ep, u32 event);

extern void dwc_usb3_gadget_request_nuke(volatile dwc_usb3_pcd_t *pcd,

                    volatile dwc_usb3_pcd_ep_t *ep);

extern void dwc_usb3_gadget_set_ep_not_started(volatile dwc_usb3_pcd_t *pcd,

                          volatile dwc_usb3_pcd_ep_t *ep);

extern void dwc_usb3_task_schedule(volatile struct tasklet_struct *tasklet);


#ifdef CONFIG_USB_OTG_DWC

extern void dwc_usb3_start_hnp(volatile dwc_usb3_pcd_t *pcd);

extern void dwc_usb3_host_release(volatile dwc_usb3_pcd_t *pcd);

#endif


#ifdef __cplusplus

}

#endif


#endif /* _DWC_PCD_H_ */