drivers/usb/gadget/udc/aspeed-vhub/vhub.h

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
vhub_dma_workaround
   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 #ifndef __ASPEED_VHUB_H
   3 #define __ASPEED_VHUB_H
   4 
   5 /*****************************
   6  *                           *
   7  * VHUB register definitions *
   8  *                           *
   9  *****************************/
  10 
  11 #define AST_VHUB_CTRL           0x00    /* Root Function Control & Status Register */
  12 #define AST_VHUB_CONF           0x04    /* Root Configuration Setting Register */
  13 #define AST_VHUB_IER            0x08    /* Interrupt Ctrl Register */
  14 #define AST_VHUB_ISR            0x0C    /* Interrupt Status Register */
  15 #define AST_VHUB_EP_ACK_IER     0x10    /* Programmable Endpoint Pool ACK Interrupt Enable Register */
  16 #define AST_VHUB_EP_NACK_IER    0x14    /* Programmable Endpoint Pool NACK Interrupt Enable Register  */
  17 #define AST_VHUB_EP_ACK_ISR     0x18    /* Programmable Endpoint Pool ACK Interrupt Status Register  */
  18 #define AST_VHUB_EP_NACK_ISR    0x1C    /* Programmable Endpoint Pool NACK Interrupt Status Register  */
  19 #define AST_VHUB_SW_RESET       0x20    /* Device Controller Soft Reset Enable Register */
  20 #define AST_VHUB_USBSTS         0x24    /* USB Status Register */
  21 #define AST_VHUB_EP_TOGGLE      0x28    /* Programmable Endpoint Pool Data Toggle Value Set */
  22 #define AST_VHUB_ISO_FAIL_ACC   0x2C    /* Isochronous Transaction Fail Accumulator */
  23 #define AST_VHUB_EP0_CTRL       0x30    /* Endpoint 0 Contrl/Status Register */
  24 #define AST_VHUB_EP0_DATA       0x34    /* Base Address of Endpoint 0 In/OUT Data Buffer Register */
  25 #define AST_VHUB_EP1_CTRL       0x38    /* Endpoint 1 Contrl/Status Register */
  26 #define AST_VHUB_EP1_STS_CHG    0x3C    /* Endpoint 1 Status Change Bitmap Data */
  27 #define AST_VHUB_SETUP0         0x80    /* Root Device Setup Data Buffer0 */
  28 #define AST_VHUB_SETUP1         0x84    /* Root Device Setup Data Buffer1 */
  29 
  30 /* Main control reg */
  31 #define VHUB_CTRL_PHY_CLK                       (1 << 31)
  32 #define VHUB_CTRL_PHY_LOOP_TEST                 (1 << 25)
  33 #define VHUB_CTRL_DN_PWN                        (1 << 24)
  34 #define VHUB_CTRL_DP_PWN                        (1 << 23)
  35 #define VHUB_CTRL_LONG_DESC                     (1 << 18)
  36 #define VHUB_CTRL_ISO_RSP_CTRL                  (1 << 17)
  37 #define VHUB_CTRL_SPLIT_IN                      (1 << 16)
  38 #define VHUB_CTRL_LOOP_T_RESULT                 (1 << 15)
  39 #define VHUB_CTRL_LOOP_T_STS                    (1 << 14)
  40 #define VHUB_CTRL_PHY_BIST_RESULT               (1 << 13)
  41 #define VHUB_CTRL_PHY_BIST_CTRL                 (1 << 12)
  42 #define VHUB_CTRL_PHY_RESET_DIS                 (1 << 11)
  43 #define VHUB_CTRL_SET_TEST_MODE(x)              ((x) << 8)
  44 #define VHUB_CTRL_MANUAL_REMOTE_WAKEUP          (1 << 4)
  45 #define VHUB_CTRL_AUTO_REMOTE_WAKEUP            (1 << 3)
  46 #define VHUB_CTRL_CLK_STOP_SUSPEND              (1 << 2)
  47 #define VHUB_CTRL_FULL_SPEED_ONLY               (1 << 1)
  48 #define VHUB_CTRL_UPSTREAM_CONNECT              (1 << 0)
  49 
  50 /* IER & ISR */
  51 #define VHUB_IRQ_USB_CMD_DEADLOCK               (1 << 18)
  52 #define VHUB_IRQ_EP_POOL_NAK                    (1 << 17)
  53 #define VHUB_IRQ_EP_POOL_ACK_STALL              (1 << 16)
  54 #define VHUB_IRQ_DEVICE5                        (1 << 13)
  55 #define VHUB_IRQ_DEVICE4                        (1 << 12)
  56 #define VHUB_IRQ_DEVICE3                        (1 << 11)
  57 #define VHUB_IRQ_DEVICE2                        (1 << 10)
  58 #define VHUB_IRQ_DEVICE1                        (1 << 9)
  59 #define VHUB_IRQ_BUS_RESUME                     (1 << 8)
  60 #define VHUB_IRQ_BUS_SUSPEND                    (1 << 7)
  61 #define VHUB_IRQ_BUS_RESET                      (1 << 6)
  62 #define VHUB_IRQ_HUB_EP1_IN_DATA_ACK            (1 << 5)
  63 #define VHUB_IRQ_HUB_EP0_IN_DATA_NAK            (1 << 4)
  64 #define VHUB_IRQ_HUB_EP0_IN_ACK_STALL           (1 << 3)
  65 #define VHUB_IRQ_HUB_EP0_OUT_NAK                (1 << 2)
  66 #define VHUB_IRQ_HUB_EP0_OUT_ACK_STALL          (1 << 1)
  67 #define VHUB_IRQ_HUB_EP0_SETUP                  (1 << 0)
  68 #define VHUB_IRQ_ACK_ALL                        0x1ff
  69 
  70 /* SW reset reg */
  71 #define VHUB_SW_RESET_EP_POOL                   (1 << 9)
  72 #define VHUB_SW_RESET_DMA_CONTROLLER            (1 << 8)
  73 #define VHUB_SW_RESET_DEVICE5                   (1 << 5)
  74 #define VHUB_SW_RESET_DEVICE4                   (1 << 4)
  75 #define VHUB_SW_RESET_DEVICE3                   (1 << 3)
  76 #define VHUB_SW_RESET_DEVICE2                   (1 << 2)
  77 #define VHUB_SW_RESET_DEVICE1                   (1 << 1)
  78 #define VHUB_SW_RESET_ROOT_HUB                  (1 << 0)
  79 #define VHUB_SW_RESET_ALL                       (VHUB_SW_RESET_EP_POOL | \
  80                                                  VHUB_SW_RESET_DMA_CONTROLLER | \
  81                                                  VHUB_SW_RESET_DEVICE5 | \
  82                                                  VHUB_SW_RESET_DEVICE4 | \
  83                                                  VHUB_SW_RESET_DEVICE3 | \
  84                                                  VHUB_SW_RESET_DEVICE2 | \
  85                                                  VHUB_SW_RESET_DEVICE1 | \
  86                                                  VHUB_SW_RESET_ROOT_HUB)
  87 /* EP ACK/NACK IRQ masks */
  88 #define VHUB_EP_IRQ(n)                          (1 << (n))
  89 #define VHUB_EP_IRQ_ALL                         0x7fff  /* 15 EPs */
  90 
  91 /* USB status reg */
  92 #define VHUB_USBSTS_HISPEED                     (1 << 27)
  93 
  94 /* EP toggle */
  95 #define VHUB_EP_TOGGLE_VALUE                    (1 << 8)
  96 #define VHUB_EP_TOGGLE_SET_EPNUM(x)             ((x) & 0x1f)
  97 
  98 /* HUB EP0 control */
  99 #define VHUB_EP0_CTRL_STALL                     (1 << 0)
 100 #define VHUB_EP0_TX_BUFF_RDY                    (1 << 1)
 101 #define VHUB_EP0_RX_BUFF_RDY                    (1 << 2)
 102 #define VHUB_EP0_RX_LEN(x)                      (((x) >> 16) & 0x7f)
 103 #define VHUB_EP0_SET_TX_LEN(x)                  (((x) & 0x7f) << 8)
 104 
 105 /* HUB EP1 control */
 106 #define VHUB_EP1_CTRL_RESET_TOGGLE              (1 << 2)
 107 #define VHUB_EP1_CTRL_STALL                     (1 << 1)
 108 #define VHUB_EP1_CTRL_ENABLE                    (1 << 0)
 109 
 110 /***********************************
 111  *                                 *
 112  * per-device register definitions *
 113  *                                 *
 114  ***********************************/
 115 #define AST_VHUB_DEV_EN_CTRL            0x00
 116 #define AST_VHUB_DEV_ISR                0x04
 117 #define AST_VHUB_DEV_EP0_CTRL           0x08
 118 #define AST_VHUB_DEV_EP0_DATA           0x0c
 119 
 120 /* Device enable control */
 121 #define VHUB_DEV_EN_SET_ADDR(x)                 ((x) << 8)
 122 #define VHUB_DEV_EN_ADDR_MASK                   ((0xff) << 8)
 123 #define VHUB_DEV_EN_EP0_NAK_IRQEN               (1 << 6)
 124 #define VHUB_DEV_EN_EP0_IN_ACK_IRQEN            (1 << 5)
 125 #define VHUB_DEV_EN_EP0_OUT_NAK_IRQEN           (1 << 4)
 126 #define VHUB_DEV_EN_EP0_OUT_ACK_IRQEN           (1 << 3)
 127 #define VHUB_DEV_EN_EP0_SETUP_IRQEN             (1 << 2)
 128 #define VHUB_DEV_EN_SPEED_SEL_HIGH              (1 << 1)
 129 #define VHUB_DEV_EN_ENABLE_PORT                 (1 << 0)
 130 
 131 /* Interrupt status */
 132 #define VHUV_DEV_IRQ_EP0_IN_DATA_NACK           (1 << 4)
 133 #define VHUV_DEV_IRQ_EP0_IN_ACK_STALL           (1 << 3)
 134 #define VHUV_DEV_IRQ_EP0_OUT_DATA_NACK          (1 << 2)
 135 #define VHUV_DEV_IRQ_EP0_OUT_ACK_STALL          (1 << 1)
 136 #define VHUV_DEV_IRQ_EP0_SETUP                  (1 << 0)
 137 
 138 /* Control bits.
 139  *
 140  * Note: The driver relies on the bulk of those bits
 141  *       matching corresponding vHub EP0 control bits
 142  */
 143 #define VHUB_DEV_EP0_CTRL_STALL                 VHUB_EP0_CTRL_STALL
 144 #define VHUB_DEV_EP0_TX_BUFF_RDY                VHUB_EP0_TX_BUFF_RDY
 145 #define VHUB_DEV_EP0_RX_BUFF_RDY                VHUB_EP0_RX_BUFF_RDY
 146 #define VHUB_DEV_EP0_RX_LEN(x)                  VHUB_EP0_RX_LEN(x)
 147 #define VHUB_DEV_EP0_SET_TX_LEN(x)              VHUB_EP0_SET_TX_LEN(x)
 148 
 149 /*************************************
 150  *                                   *
 151  * per-endpoint register definitions *
 152  *                                   *
 153  *************************************/
 154 
 155 #define AST_VHUB_EP_CONFIG              0x00
 156 #define AST_VHUB_EP_DMA_CTLSTAT         0x04
 157 #define AST_VHUB_EP_DESC_BASE           0x08
 158 #define AST_VHUB_EP_DESC_STATUS         0x0C
 159 
 160 /* EP config reg */
 161 #define VHUB_EP_CFG_SET_MAX_PKT(x)      (((x) & 0x3ff) << 16)
 162 #define VHUB_EP_CFG_AUTO_DATA_DISABLE   (1 << 13)
 163 #define VHUB_EP_CFG_STALL_CTRL          (1 << 12)
 164 #define VHUB_EP_CFG_SET_EP_NUM(x)       (((x) & 0xf) << 8)
 165 #define VHUB_EP_CFG_SET_TYPE(x)         ((x) << 5)
 166 #define   EP_TYPE_OFF                   0
 167 #define   EP_TYPE_BULK                  1
 168 #define   EP_TYPE_INT                   2
 169 #define   EP_TYPE_ISO                   3
 170 #define VHUB_EP_CFG_DIR_OUT             (1 << 4)
 171 #define VHUB_EP_CFG_SET_DEV(x)          ((x) << 1)
 172 #define VHUB_EP_CFG_ENABLE              (1 << 0)
 173 
 174 /* EP DMA control */
 175 #define VHUB_EP_DMA_PROC_STATUS(x)      (((x) >> 4) & 0xf)
 176 #define   EP_DMA_PROC_RX_IDLE           0
 177 #define   EP_DMA_PROC_TX_IDLE           8
 178 #define VHUB_EP_DMA_IN_LONG_MODE        (1 << 3)
 179 #define VHUB_EP_DMA_OUT_CONTIG_MODE     (1 << 3)
 180 #define VHUB_EP_DMA_CTRL_RESET          (1 << 2)
 181 #define VHUB_EP_DMA_SINGLE_STAGE        (1 << 1)
 182 #define VHUB_EP_DMA_DESC_MODE           (1 << 0)
 183 
 184 /* EP DMA status */
 185 #define VHUB_EP_DMA_SET_TX_SIZE(x)      ((x) << 16)
 186 #define VHUB_EP_DMA_TX_SIZE(x)          (((x) >> 16) & 0x7ff)
 187 #define VHUB_EP_DMA_RPTR(x)             (((x) >> 8) & 0xff)
 188 #define VHUB_EP_DMA_SET_RPTR(x)         (((x) & 0xff) << 8)
 189 #define VHUB_EP_DMA_SET_CPU_WPTR(x)     (x)
 190 #define VHUB_EP_DMA_SINGLE_KICK         (1 << 0) /* WPTR = 1 for single mode */
 191 
 192 /*******************************
 193  *                             *
 194  * DMA descriptors definitions *
 195  *                             *
 196  *******************************/
 197 
 198 /* Desc W1 IN */
 199 #define VHUB_DSC1_IN_INTERRUPT          (1 << 31)
 200 #define VHUB_DSC1_IN_SPID_DATA0         (0 << 14)
 201 #define VHUB_DSC1_IN_SPID_DATA2         (1 << 14)
 202 #define VHUB_DSC1_IN_SPID_DATA1         (2 << 14)
 203 #define VHUB_DSC1_IN_SPID_MDATA         (3 << 14)
 204 #define VHUB_DSC1_IN_SET_LEN(x)         ((x) & 0xfff)
 205 #define VHUB_DSC1_IN_LEN(x)             ((x) & 0xfff)
 206 
 207 /****************************************
 208  *                                      *
 209  * Data structures and misc definitions *
 210  *                                      *
 211  ****************************************/
 212 
 213 #define AST_VHUB_NUM_GEN_EPs    15      /* Generic non-0 EPs */
 214 #define AST_VHUB_NUM_PORTS      5       /* vHub ports */
 215 #define AST_VHUB_EP0_MAX_PACKET 64      /* EP0's max packet size */
 216 #define AST_VHUB_EPn_MAX_PACKET 1024    /* Generic EPs max packet size */
 217 #define AST_VHUB_DESCS_COUNT    256     /* Use 256 descriptor mode (valid
 218                                          * values are 256 and 32)
 219                                          */
 220 
 221 struct ast_vhub;
 222 struct ast_vhub_dev;
 223 
 224 /*
 225  * DMA descriptor (generic EPs only, currently only used
 226  * for IN endpoints
 227  */
 228 struct ast_vhub_desc {
 229         __le32  w0;
 230         __le32  w1;
 231 };
 232 
 233 /* A transfer request, either core-originated or internal */
 234 struct ast_vhub_req {
 235         struct usb_request      req;
 236         struct list_head        queue;
 237 
 238         /* Actual count written to descriptors (desc mode only) */
 239         unsigned int            act_count;
 240 
 241         /*
 242          * Desc number of the final packet or -1. For non-desc
 243          * mode (or ep0), any >= 0 value means "last packet"
 244          */
 245         int                     last_desc;
 246 
 247         /* Request active (pending DMAs) */
 248         bool                    active  : 1;
 249 
 250         /* Internal request (don't call back core) */
 251         bool                    internal : 1;
 252 };
 253 #define to_ast_req(__ureq) container_of(__ureq, struct ast_vhub_req, req)
 254 
 255 /* Current state of an EP0 */
 256 enum ep0_state {
 257         ep0_state_token,
 258         ep0_state_data,
 259         ep0_state_status,
 260         ep0_state_stall,
 261 };
 262 
 263 /*
 264  * An endpoint, either generic, ep0, actual gadget EP
 265  * or internal use vhub EP0. vhub EP1 doesn't have an
 266  * associated structure as it's mostly HW managed.
 267  */
 268 struct ast_vhub_ep {
 269         struct usb_ep           ep;
 270 
 271         /* Request queue */
 272         struct list_head        queue;
 273 
 274         /* EP index in the device, 0 means this is an EP0 */
 275         unsigned int            d_idx;
 276 
 277         /* Dev pointer or NULL for vHub EP0 */
 278         struct ast_vhub_dev     *dev;
 279 
 280         /* vHub itself */
 281         struct ast_vhub         *vhub;
 282 
 283         /*
 284          * DMA buffer for EP0, fallback DMA buffer for misaligned
 285          * OUT transfers for generic EPs
 286          */
 287         void                    *buf;
 288         dma_addr_t              buf_dma;
 289 
 290         /* The rest depends on the EP type */
 291         union {
 292                 /* EP0 (either device or vhub) */
 293                 struct {
 294                         /*
 295                          * EP0 registers are "similar" for
 296                          * vHub and devices but located in
 297                          * different places.
 298                          */
 299                         void __iomem            *ctlstat;
 300                         void __iomem            *setup;
 301 
 302                         /* Current state & direction */
 303                         enum ep0_state          state;
 304                         bool                    dir_in;
 305 
 306                         /* Internal use request */
 307                         struct ast_vhub_req     req;
 308                 } ep0;
 309 
 310                 /* Generic endpoint (aka EPn) */
 311                 struct {
 312                         /* Registers */
 313                         void __iomem            *regs;
 314 
 315                         /* Index in global pool (0..14) */
 316                         unsigned int            g_idx;
 317 
 318                         /* DMA Descriptors */
 319                         struct ast_vhub_desc    *descs;
 320                         dma_addr_t              descs_dma;
 321                         unsigned int            d_next;
 322                         unsigned int            d_last;
 323                         unsigned int            dma_conf;
 324 
 325                         /* Max chunk size for IN EPs */
 326                         unsigned int            chunk_max;
 327 
 328                         /* State flags */
 329                         bool                    is_in :  1;
 330                         bool                    is_iso : 1;
 331                         bool                    stalled : 1;
 332                         bool                    wedged : 1;
 333                         bool                    enabled : 1;
 334                         bool                    desc_mode : 1;
 335                 } epn;
 336         };
 337 };
 338 #define to_ast_ep(__uep) container_of(__uep, struct ast_vhub_ep, ep)
 339 
 340 /* A device attached to a vHub port */
 341 struct ast_vhub_dev {
 342         struct ast_vhub                 *vhub;
 343         void __iomem                    *regs;
 344 
 345         /* Device index (0...4) and name string */
 346         unsigned int                    index;
 347         const char                      *name;
 348 
 349         /* sysfs enclosure for the gadget gunk */
 350         struct device                   *port_dev;
 351 
 352         /* Link to gadget core */
 353         struct usb_gadget               gadget;
 354         struct usb_gadget_driver        *driver;
 355         bool                            registered : 1;
 356         bool                            wakeup_en : 1;
 357         bool                            enabled : 1;
 358 
 359         /* Endpoint structures */
 360         struct ast_vhub_ep              ep0;
 361         struct ast_vhub_ep              *epns[AST_VHUB_NUM_GEN_EPs];
 362 
 363 };
 364 #define to_ast_dev(__g) container_of(__g, struct ast_vhub_dev, gadget)
 365 
 366 /* Per vhub port stateinfo structure */
 367 struct ast_vhub_port {
 368         /* Port status & status change registers */
 369         u16                     status;
 370         u16                     change;
 371 
 372         /* Associated device slot */
 373         struct ast_vhub_dev     dev;
 374 };
 375 
 376 /* Global vhub structure */
 377 struct ast_vhub {
 378         struct platform_device          *pdev;
 379         void __iomem                    *regs;
 380         int                             irq;
 381         spinlock_t                      lock;
 382         struct work_struct              wake_work;
 383         struct clk                      *clk;
 384 
 385         /* EP0 DMA buffers allocated in one chunk */
 386         void                            *ep0_bufs;
 387         dma_addr_t                      ep0_bufs_dma;
 388 
 389         /* EP0 of the vhub itself */
 390         struct ast_vhub_ep              ep0;
 391 
 392         /* State of vhub ep1 */
 393         bool                            ep1_stalled : 1;
 394 
 395         /* Per-port info */
 396         struct ast_vhub_port            ports[AST_VHUB_NUM_PORTS];
 397 
 398         /* Generic EP data structures */
 399         struct ast_vhub_ep              epns[AST_VHUB_NUM_GEN_EPs];
 400 
 401         /* Upstream bus is suspended ? */
 402         bool                            suspended : 1;
 403 
 404         /* Hub itself can signal remote wakeup */
 405         bool                            wakeup_en : 1;
 406 
 407         /* Force full speed only */
 408         bool                            force_usb1 : 1;
 409 
 410         /* Upstream bus speed captured at bus reset */
 411         unsigned int                    speed;
 412 };
 413 
 414 /* Standard request handlers result codes */
 415 enum std_req_rc {
 416         std_req_stall = -1,     /* Stall requested */
 417         std_req_complete = 0,   /* Request completed with no data */
 418         std_req_data = 1,       /* Request completed with data */
 419         std_req_driver = 2,     /* Pass to driver pls */
 420 };
 421 
 422 #ifdef CONFIG_USB_GADGET_VERBOSE
 423 #define UDCVDBG(u, fmt...)      dev_dbg(&(u)->pdev->dev, fmt)
 424 
 425 #define EPVDBG(ep, fmt, ...)    do {                    \
 426         dev_dbg(&(ep)->vhub->pdev->dev,                 \
 427                 "%s:EP%d " fmt,                         \
 428                 (ep)->dev ? (ep)->dev->name : "hub",    \
 429                 (ep)->d_idx, ##__VA_ARGS__);            \
 430         } while(0)
 431 
 432 #define DVDBG(d, fmt, ...)      do {                    \
 433         dev_dbg(&(d)->vhub->pdev->dev,                  \
 434                 "%s " fmt, (d)->name,                   \
 435                 ##__VA_ARGS__);                         \
 436         } while(0)
 437 
 438 #else
 439 #define UDCVDBG(u, fmt...)      do { } while(0)
 440 #define EPVDBG(ep, fmt, ...)    do { } while(0)
 441 #define DVDBG(d, fmt, ...)      do { } while(0)
 442 #endif
 443 
 444 #ifdef CONFIG_USB_GADGET_DEBUG
 445 #define UDCDBG(u, fmt...)       dev_dbg(&(u)->pdev->dev, fmt)
 446 
 447 #define EPDBG(ep, fmt, ...)     do {                    \
 448         dev_dbg(&(ep)->vhub->pdev->dev,                 \
 449                 "%s:EP%d " fmt,                         \
 450                 (ep)->dev ? (ep)->dev->name : "hub",    \
 451                 (ep)->d_idx, ##__VA_ARGS__);            \
 452         } while(0)
 453 
 454 #define DDBG(d, fmt, ...)       do {                    \
 455         dev_dbg(&(d)->vhub->pdev->dev,                  \
 456                 "%s " fmt, (d)->name,                   \
 457                 ##__VA_ARGS__);                         \
 458         } while(0)
 459 #else
 460 #define UDCDBG(u, fmt...)       do { } while(0)
 461 #define EPDBG(ep, fmt, ...)     do { } while(0)
 462 #define DDBG(d, fmt, ...)       do { } while(0)
 463 #endif
 464 
 465 static inline void vhub_dma_workaround(void *addr)
 466 {
 467         /*
 468          * This works around a confirmed HW issue with the Aspeed chip.
 469          *
 470          * The core uses a different bus to memory than the AHB going to
 471          * the USB device controller. Due to the latter having a higher
 472          * priority than the core for arbitration on that bus, it's
 473          * possible for an MMIO to the device, followed by a DMA by the
 474          * device from memory to all be performed and services before
 475          * a previous store to memory gets completed.
 476          *
 477          * This the following scenario can happen:
 478          *
 479          *    - Driver writes to a DMA descriptor (Mbus)
 480          *    - Driver writes to the MMIO register to start the DMA (AHB)
 481          *    - The gadget sees the second write and sends a read of the
 482          *      descriptor to the memory controller (Mbus)
 483          *    - The gadget hits memory before the descriptor write
 484          *      causing it to read an obsolete value.
 485          *
 486          * Thankfully the problem is limited to the USB gadget device, other
 487          * masters in the SoC all have a lower priority than the core, thus
 488          * ensuring that the store by the core arrives first.
 489          *
 490          * The workaround consists of using a dummy read of the memory before
 491          * doing the MMIO writes. This will ensure that the previous writes
 492          * have been "pushed out".
 493          */
 494         mb();
 495         (void)__raw_readl((void __iomem *)addr);
 496 }
 497 
 498 /* core.c */
 499 void ast_vhub_done(struct ast_vhub_ep *ep, struct ast_vhub_req *req,
 500                    int status);
 501 void ast_vhub_nuke(struct ast_vhub_ep *ep, int status);
 502 struct usb_request *ast_vhub_alloc_request(struct usb_ep *u_ep,
 503                                            gfp_t gfp_flags);
 504 void ast_vhub_free_request(struct usb_ep *u_ep, struct usb_request *u_req);
 505 void ast_vhub_init_hw(struct ast_vhub *vhub);
 506 
 507 /* ep0.c */
 508 void ast_vhub_ep0_handle_ack(struct ast_vhub_ep *ep, bool in_ack);
 509 void ast_vhub_ep0_handle_setup(struct ast_vhub_ep *ep);
 510 void ast_vhub_reset_ep0(struct ast_vhub_dev *dev);
 511 void ast_vhub_init_ep0(struct ast_vhub *vhub, struct ast_vhub_ep *ep,
 512                        struct ast_vhub_dev *dev);
 513 int ast_vhub_reply(struct ast_vhub_ep *ep, char *ptr, int len);
 514 int __ast_vhub_simple_reply(struct ast_vhub_ep *ep, int len, ...);
 515 #define ast_vhub_simple_reply(udc, ...)                                        \
 516         __ast_vhub_simple_reply((udc),                                         \
 517                                sizeof((u8[]) { __VA_ARGS__ })/sizeof(u8),      \
 518                                __VA_ARGS__)
 519 
 520 /* hub.c */
 521 void ast_vhub_init_hub(struct ast_vhub *vhub);
 522 enum std_req_rc ast_vhub_std_hub_request(struct ast_vhub_ep *ep,
 523                                          struct usb_ctrlrequest *crq);
 524 enum std_req_rc ast_vhub_class_hub_request(struct ast_vhub_ep *ep,
 525                                            struct usb_ctrlrequest *crq);
 526 void ast_vhub_device_connect(struct ast_vhub *vhub, unsigned int port,
 527                              bool on);
 528 void ast_vhub_hub_suspend(struct ast_vhub *vhub);
 529 void ast_vhub_hub_resume(struct ast_vhub *vhub);
 530 void ast_vhub_hub_reset(struct ast_vhub *vhub);
 531 void ast_vhub_hub_wake_all(struct ast_vhub *vhub);
 532 
 533 /* dev.c */
 534 int ast_vhub_init_dev(struct ast_vhub *vhub, unsigned int idx);
 535 void ast_vhub_del_dev(struct ast_vhub_dev *d);
 536 void ast_vhub_dev_irq(struct ast_vhub_dev *d);
 537 int ast_vhub_std_dev_request(struct ast_vhub_ep *ep,
 538                              struct usb_ctrlrequest *crq);
 539 
 540 /* epn.c */
 541 void ast_vhub_epn_ack_irq(struct ast_vhub_ep *ep);
 542 void ast_vhub_update_epn_stall(struct ast_vhub_ep *ep);
 543 struct ast_vhub_ep *ast_vhub_alloc_epn(struct ast_vhub_dev *d, u8 addr);
 544 void ast_vhub_dev_suspend(struct ast_vhub_dev *d);
 545 void ast_vhub_dev_resume(struct ast_vhub_dev *d);
 546 void ast_vhub_dev_reset(struct ast_vhub_dev *d);
 547 
 548 #endif /* __ASPEED_VHUB_H */
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/usb/gadget/udc/aspeed-vhub/vhub.h

INCLUDED FROM

DEFINITIONS
