drivers/usb/gadget/udc/renesas_usb3.c

   1 /*
   2  * Renesas USB3.0 Peripheral driver (USB gadget)
   3  *
   4  * Copyright (C) 2015  Renesas Electronics Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  */
  10
  11 #include <linux/debugfs.h>
  12 #include <linux/delay.h>
  13 #include <linux/dma-mapping.h>
  14 #include <linux/err.h>
  15 #include <linux/extcon.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/io.h>
  18 #include <linux/module.h>
  19 #include <linux/of_device.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/pm_runtime.h>
  22 #include <linux/sizes.h>
  23 #include <linux/slab.h>
  24 #include <linux/sys_soc.h>
  25 #include <linux/uaccess.h>
  26 #include <linux/usb/ch9.h>
  27 #include <linux/usb/gadget.h>
  28
  29 /* register definitions */
  30 #define USB3_AXI_INT_STA        0x008
  31 #define USB3_AXI_INT_ENA        0x00c
  32 #define USB3_DMA_INT_STA        0x010
  33 #define USB3_DMA_INT_ENA        0x014
  34 #define USB3_DMA_CH0_CON(n)     (0x030 + ((n) - 1) * 0x10) /* n = 1 to 4 */
  35 #define USB3_DMA_CH0_PRD_ADR(n) (0x034 + ((n) - 1) * 0x10) /* n = 1 to 4 */
  36 #define USB3_USB_COM_CON        0x200
  37 #define USB3_USB20_CON          0x204
  38 #define USB3_USB30_CON          0x208
  39 #define USB3_USB_STA            0x210
  40 #define USB3_DRD_CON            0x218
  41 #define USB3_USB_INT_STA_1      0x220
  42 #define USB3_USB_INT_STA_2      0x224
  43 #define USB3_USB_INT_ENA_1      0x228
  44 #define USB3_USB_INT_ENA_2      0x22c
  45 #define USB3_STUP_DAT_0         0x230
  46 #define USB3_STUP_DAT_1         0x234
  47 #define USB3_USB_OTG_STA        0x268
  48 #define USB3_USB_OTG_INT_STA    0x26c
  49 #define USB3_USB_OTG_INT_ENA    0x270
  50 #define USB3_P0_MOD             0x280
  51 #define USB3_P0_CON             0x288
  52 #define USB3_P0_STA             0x28c
  53 #define USB3_P0_INT_STA         0x290
  54 #define USB3_P0_INT_ENA         0x294
  55 #define USB3_P0_LNG             0x2a0
  56 #define USB3_P0_READ            0x2a4
  57 #define USB3_P0_WRITE           0x2a8
  58 #define USB3_PIPE_COM           0x2b0
  59 #define USB3_PN_MOD             0x2c0
  60 #define USB3_PN_RAMMAP          0x2c4
  61 #define USB3_PN_CON             0x2c8
  62 #define USB3_PN_STA             0x2cc
  63 #define USB3_PN_INT_STA         0x2d0
  64 #define USB3_PN_INT_ENA         0x2d4
  65 #define USB3_PN_LNG             0x2e0
  66 #define USB3_PN_READ            0x2e4
  67 #define USB3_PN_WRITE           0x2e8
  68 #define USB3_SSIFCMD            0x340
  69
  70 /* AXI_INT_ENA and AXI_INT_STA */
  71 #define AXI_INT_DMAINT          BIT(31)
  72 #define AXI_INT_EPCINT          BIT(30)
  73 /* PRD's n = from 1 to 4 */
  74 #define AXI_INT_PRDEN_CLR_STA_SHIFT(n)  (16 + (n) - 1)
  75 #define AXI_INT_PRDERR_STA_SHIFT(n)     (0 + (n) - 1)
  76 #define AXI_INT_PRDEN_CLR_STA(n)        (1 << AXI_INT_PRDEN_CLR_STA_SHIFT(n))
  77 #define AXI_INT_PRDERR_STA(n)           (1 << AXI_INT_PRDERR_STA_SHIFT(n))
  78
  79 /* DMA_INT_ENA and DMA_INT_STA */
  80 #define DMA_INT(n)              BIT(n)
  81
  82 /* DMA_CH0_CONn */
  83 #define DMA_CON_PIPE_DIR        BIT(15)         /* 1: In Transfer */
  84 #define DMA_CON_PIPE_NO_SHIFT   8
  85 #define DMA_CON_PIPE_NO_MASK    GENMASK(12, DMA_CON_PIPE_NO_SHIFT)
  86 #define DMA_COM_PIPE_NO(n)      (((n) << DMA_CON_PIPE_NO_SHIFT) & \
  87                                          DMA_CON_PIPE_NO_MASK)
  88 #define DMA_CON_PRD_EN          BIT(0)
  89
  90 /* LCLKSEL */
  91 #define LCLKSEL_LSEL            BIT(18)
  92
  93 /* USB_COM_CON */
  94 #define USB_COM_CON_CONF                BIT(24)
  95 #define USB_COM_CON_PN_WDATAIF_NL       BIT(23)
  96 #define USB_COM_CON_PN_RDATAIF_NL       BIT(22)
  97 #define USB_COM_CON_PN_LSTTR_PP         BIT(21)
  98 #define USB_COM_CON_SPD_MODE            BIT(17)
  99 #define USB_COM_CON_EP0_EN              BIT(16)
 100 #define USB_COM_CON_DEV_ADDR_SHIFT      8
 101 #define USB_COM_CON_DEV_ADDR_MASK       GENMASK(14, USB_COM_CON_DEV_ADDR_SHIFT)
 102 #define USB_COM_CON_DEV_ADDR(n)         (((n) << USB_COM_CON_DEV_ADDR_SHIFT) & \
 103                                          USB_COM_CON_DEV_ADDR_MASK)
 104 #define USB_COM_CON_RX_DETECTION        BIT(1)
 105 #define USB_COM_CON_PIPE_CLR            BIT(0)
 106
 107 /* USB20_CON */
 108 #define USB20_CON_B2_PUE                BIT(31)
 109 #define USB20_CON_B2_SUSPEND            BIT(24)
 110 #define USB20_CON_B2_CONNECT            BIT(17)
 111 #define USB20_CON_B2_TSTMOD_SHIFT       8
 112 #define USB20_CON_B2_TSTMOD_MASK        GENMASK(10, USB20_CON_B2_TSTMOD_SHIFT)
 113 #define USB20_CON_B2_TSTMOD(n)          (((n) << USB20_CON_B2_TSTMOD_SHIFT) & \
 114                                          USB20_CON_B2_TSTMOD_MASK)
 115 #define USB20_CON_B2_TSTMOD_EN          BIT(0)
 116
 117 /* USB30_CON */
 118 #define USB30_CON_POW_SEL_SHIFT         24
 119 #define USB30_CON_POW_SEL_MASK          GENMASK(26, USB30_CON_POW_SEL_SHIFT)
 120 #define USB30_CON_POW_SEL_IN_U3         BIT(26)
 121 #define USB30_CON_POW_SEL_IN_DISCON     0
 122 #define USB30_CON_POW_SEL_P2_TO_P0      BIT(25)
 123 #define USB30_CON_POW_SEL_P0_TO_P3      BIT(24)
 124 #define USB30_CON_POW_SEL_P0_TO_P2      0
 125 #define USB30_CON_B3_PLLWAKE            BIT(23)
 126 #define USB30_CON_B3_CONNECT            BIT(17)
 127 #define USB30_CON_B3_HOTRST_CMP         BIT(1)
 128
 129 /* USB_STA */
 130 #define USB_STA_SPEED_MASK      (BIT(2) | BIT(1))
 131 #define USB_STA_SPEED_HS        BIT(2)
 132 #define USB_STA_SPEED_FS        BIT(1)
 133 #define USB_STA_SPEED_SS        0
 134 #define USB_STA_VBUS_STA        BIT(0)
 135
 136 /* DRD_CON */
 137 #define DRD_CON_PERI_CON        BIT(24)
 138 #define DRD_CON_VBOUT           BIT(0)
 139
 140 /* USB_INT_ENA_1 and USB_INT_STA_1 */
 141 #define USB_INT_1_B3_PLLWKUP    BIT(31)
 142 #define USB_INT_1_B3_LUPSUCS    BIT(30)
 143 #define USB_INT_1_B3_DISABLE    BIT(27)
 144 #define USB_INT_1_B3_WRMRST     BIT(21)
 145 #define USB_INT_1_B3_HOTRST     BIT(20)
 146 #define USB_INT_1_B2_USBRST     BIT(12)
 147 #define USB_INT_1_B2_L1SPND     BIT(11)
 148 #define USB_INT_1_B2_SPND       BIT(9)
 149 #define USB_INT_1_B2_RSUM       BIT(8)
 150 #define USB_INT_1_SPEED         BIT(1)
 151 #define USB_INT_1_VBUS_CNG      BIT(0)
 152
 153 /* USB_INT_ENA_2 and USB_INT_STA_2 */
 154 #define USB_INT_2_PIPE(n)       BIT(n)
 155
 156 /* USB_OTG_STA, USB_OTG_INT_STA and USB_OTG_INT_ENA */
 157 #define USB_OTG_IDMON           BIT(4)
 158
 159 /* P0_MOD */
 160 #define P0_MOD_DIR              BIT(6)
 161
 162 /* P0_CON and PN_CON */
 163 #define PX_CON_BYTE_EN_MASK             (BIT(10) | BIT(9))
 164 #define PX_CON_BYTE_EN_SHIFT            9
 165 #define PX_CON_BYTE_EN_BYTES(n)         (((n) << PX_CON_BYTE_EN_SHIFT) & \
 166                                          PX_CON_BYTE_EN_MASK)
 167 #define PX_CON_SEND                     BIT(8)
 168
 169 /* P0_CON */
 170 #define P0_CON_ST_RES_MASK              (BIT(27) | BIT(26))
 171 #define P0_CON_ST_RES_FORCE_STALL       BIT(27)
 172 #define P0_CON_ST_RES_NORMAL            BIT(26)
 173 #define P0_CON_ST_RES_FORCE_NRDY        0
 174 #define P0_CON_OT_RES_MASK              (BIT(25) | BIT(24))
 175 #define P0_CON_OT_RES_FORCE_STALL       BIT(25)
 176 #define P0_CON_OT_RES_NORMAL            BIT(24)
 177 #define P0_CON_OT_RES_FORCE_NRDY        0
 178 #define P0_CON_IN_RES_MASK              (BIT(17) | BIT(16))
 179 #define P0_CON_IN_RES_FORCE_STALL       BIT(17)
 180 #define P0_CON_IN_RES_NORMAL            BIT(16)
 181 #define P0_CON_IN_RES_FORCE_NRDY        0
 182 #define P0_CON_RES_WEN                  BIT(7)
 183 #define P0_CON_BCLR                     BIT(1)
 184
 185 /* P0_STA and PN_STA */
 186 #define PX_STA_BUFSTS           BIT(0)
 187
 188 /* P0_INT_ENA and P0_INT_STA */
 189 #define P0_INT_STSED            BIT(18)
 190 #define P0_INT_STSST            BIT(17)
 191 #define P0_INT_SETUP            BIT(16)
 192 #define P0_INT_RCVNL            BIT(8)
 193 #define P0_INT_ERDY             BIT(7)
 194 #define P0_INT_FLOW             BIT(6)
 195 #define P0_INT_STALL            BIT(2)
 196 #define P0_INT_NRDY             BIT(1)
 197 #define P0_INT_BFRDY            BIT(0)
 198 #define P0_INT_ALL_BITS         (P0_INT_STSED | P0_INT_SETUP | P0_INT_BFRDY)
 199
 200 /* PN_MOD */
 201 #define PN_MOD_DIR              BIT(6)
 202 #define PN_MOD_TYPE_SHIFT       4
 203 #define PN_MOD_TYPE_MASK        GENMASK(5, PN_MOD_TYPE_SHIFT)
 204 #define PN_MOD_TYPE(n)          (((n) << PN_MOD_TYPE_SHIFT) & \
 205                                  PN_MOD_TYPE_MASK)
 206 #define PN_MOD_EPNUM_MASK       GENMASK(3, 0)
 207 #define PN_MOD_EPNUM(n)         ((n) & PN_MOD_EPNUM_MASK)
 208
 209 /* PN_RAMMAP */
 210 #define PN_RAMMAP_RAMAREA_SHIFT 29
 211 #define PN_RAMMAP_RAMAREA_MASK  GENMASK(31, PN_RAMMAP_RAMAREA_SHIFT)
 212 #define PN_RAMMAP_RAMAREA_16KB  BIT(31)
 213 #define PN_RAMMAP_RAMAREA_8KB   (BIT(30) | BIT(29))
 214 #define PN_RAMMAP_RAMAREA_4KB   BIT(30)
 215 #define PN_RAMMAP_RAMAREA_2KB   BIT(29)
 216 #define PN_RAMMAP_RAMAREA_1KB   0
 217 #define PN_RAMMAP_MPKT_SHIFT    16
 218 #define PN_RAMMAP_MPKT_MASK     GENMASK(26, PN_RAMMAP_MPKT_SHIFT)
 219 #define PN_RAMMAP_MPKT(n)       (((n) << PN_RAMMAP_MPKT_SHIFT) & \
 220                                  PN_RAMMAP_MPKT_MASK)
 221 #define PN_RAMMAP_RAMIF_SHIFT   14
 222 #define PN_RAMMAP_RAMIF_MASK    GENMASK(15, PN_RAMMAP_RAMIF_SHIFT)
 223 #define PN_RAMMAP_RAMIF(n)      (((n) << PN_RAMMAP_RAMIF_SHIFT) & \
 224                                  PN_RAMMAP_RAMIF_MASK)
 225 #define PN_RAMMAP_BASEAD_MASK   GENMASK(13, 0)
 226 #define PN_RAMMAP_BASEAD(offs)  (((offs) >> 3) & PN_RAMMAP_BASEAD_MASK)
 227 #define PN_RAMMAP_DATA(area, ramif, basead)     ((PN_RAMMAP_##area) | \
 228                                                  (PN_RAMMAP_RAMIF(ramif)) | \
 229                                                  (PN_RAMMAP_BASEAD(basead)))
 230
 231 /* PN_CON */
 232 #define PN_CON_EN               BIT(31)
 233 #define PN_CON_DATAIF_EN        BIT(30)
 234 #define PN_CON_RES_MASK         (BIT(17) | BIT(16))
 235 #define PN_CON_RES_FORCE_STALL  BIT(17)
 236 #define PN_CON_RES_NORMAL       BIT(16)
 237 #define PN_CON_RES_FORCE_NRDY   0
 238 #define PN_CON_LAST             BIT(11)
 239 #define PN_CON_RES_WEN          BIT(7)
 240 #define PN_CON_CLR              BIT(0)
 241
 242 /* PN_INT_STA and PN_INT_ENA */
 243 #define PN_INT_LSTTR    BIT(4)
 244 #define PN_INT_BFRDY    BIT(0)
 245
 246 /* USB3_SSIFCMD */
 247 #define SSIFCMD_URES_U2         BIT(9)
 248 #define SSIFCMD_URES_U1         BIT(8)
 249 #define SSIFCMD_UDIR_U2         BIT(7)
 250 #define SSIFCMD_UDIR_U1         BIT(6)
 251 #define SSIFCMD_UREQ_U2         BIT(5)
 252 #define SSIFCMD_UREQ_U1         BIT(4)
 253
 254 #define USB3_EP0_SS_MAX_PACKET_SIZE     512
 255 #define USB3_EP0_HSFS_MAX_PACKET_SIZE   64
 256 #define USB3_EP0_BUF_SIZE               8
 257 #define USB3_MAX_NUM_PIPES              30
 258 #define USB3_WAIT_US                    3
 259 #define USB3_DMA_NUM_SETTING_AREA       4
 260 /*
 261  * To avoid double-meaning of "0" (xferred 65536 bytes or received zlp if
 262  * buffer size is 65536), this driver uses the maximum size per a entry is
 263  * 32768 bytes.
 264  */
 265 #define USB3_DMA_MAX_XFER_SIZE          32768
 266 #define USB3_DMA_PRD_SIZE               4096
 267
 268 struct renesas_usb3;
 269
 270 /* Physical Region Descriptor Table */
 271 struct renesas_usb3_prd {
 272         u32 word1;
 273 #define USB3_PRD1_E             BIT(30)         /* the end of chain */
 274 #define USB3_PRD1_U             BIT(29)         /* completion of transfer */
 275 #define USB3_PRD1_D             BIT(28)         /* Error occurred */
 276 #define USB3_PRD1_INT           BIT(27)         /* Interrupt occurred */
 277 #define USB3_PRD1_LST           BIT(26)         /* Last Packet */
 278 #define USB3_PRD1_B_INC         BIT(24)
 279 #define USB3_PRD1_MPS_8         0
 280 #define USB3_PRD1_MPS_16        BIT(21)
 281 #define USB3_PRD1_MPS_32        BIT(22)
 282 #define USB3_PRD1_MPS_64        (BIT(22) | BIT(21))
 283 #define USB3_PRD1_MPS_512       BIT(23)
 284 #define USB3_PRD1_MPS_1024      (BIT(23) | BIT(21))
 285 #define USB3_PRD1_MPS_RESERVED  (BIT(23) | BIT(22) | BIT(21))
 286 #define USB3_PRD1_SIZE_MASK     GENMASK(15, 0)
 287
 288         u32 bap;
 289 };
 290 #define USB3_DMA_NUM_PRD_ENTRIES        (USB3_DMA_PRD_SIZE / \
 291                                           sizeof(struct renesas_usb3_prd))
 292 #define USB3_DMA_MAX_XFER_SIZE_ALL_PRDS (USB3_DMA_PRD_SIZE / \
 293                                          sizeof(struct renesas_usb3_prd) * \
 294                                          USB3_DMA_MAX_XFER_SIZE)
 295
 296 struct renesas_usb3_dma {
 297         struct renesas_usb3_prd *prd;
 298         dma_addr_t prd_dma;
 299         int num;        /* Setting area number (from 1 to 4) */
 300         bool used;
 301 };
 302
 303 struct renesas_usb3_request {
 304         struct usb_request      req;
 305         struct list_head        queue;
 306 };
 307
 308 #define USB3_EP_NAME_SIZE       8
 309 struct renesas_usb3_ep {
 310         struct usb_ep ep;
 311         struct renesas_usb3 *usb3;
 312         struct renesas_usb3_dma *dma;
 313         int num;
 314         char ep_name[USB3_EP_NAME_SIZE];
 315         struct list_head queue;
 316         u32 rammap_val;
 317         bool dir_in;
 318         bool halt;
 319         bool wedge;
 320         bool started;
 321 };
 322
 323 struct renesas_usb3_priv {
 324         int ramsize_per_ramif;          /* unit = bytes */
 325         int num_ramif;
 326         int ramsize_per_pipe;           /* unit = bytes */
 327         bool workaround_for_vbus;       /* if true, don't check vbus signal */
 328 };
 329
 330 struct renesas_usb3 {
 331         void __iomem *reg;
 332
 333         struct usb_gadget gadget;
 334         struct usb_gadget_driver *driver;
 335         struct extcon_dev *extcon;
 336         struct work_struct extcon_work;
 337
 338         struct renesas_usb3_ep *usb3_ep;
 339         int num_usb3_eps;
 340
 341         struct renesas_usb3_dma dma[USB3_DMA_NUM_SETTING_AREA];
 342
 343         spinlock_t lock;
 344         int disabled_count;
 345
 346         struct usb_request *ep0_req;
 347         u16 test_mode;
 348         u8 ep0_buf[USB3_EP0_BUF_SIZE];
 349         bool softconnect;
 350         bool workaround_for_vbus;
 351         bool extcon_host;               /* check id and set EXTCON_USB_HOST */
 352         bool extcon_usb;                /* check vbus and set EXTCON_USB */
 353         bool forced_b_device;
 354 };
 355
 356 #define gadget_to_renesas_usb3(_gadget) \
 357                 container_of(_gadget, struct renesas_usb3, gadget)
 358 #define renesas_usb3_to_gadget(renesas_usb3) (&renesas_usb3->gadget)
 359 #define usb3_to_dev(_usb3)      (_usb3->gadget.dev.parent)
 360
 361 #define usb_ep_to_usb3_ep(_ep) container_of(_ep, struct renesas_usb3_ep, ep)
 362 #define usb3_ep_to_usb3(_usb3_ep) (_usb3_ep->usb3)
 363 #define usb_req_to_usb3_req(_req) container_of(_req, \
 364                                             struct renesas_usb3_request, req)
 365
 366 #define usb3_get_ep(usb3, n) ((usb3)->usb3_ep + (n))
 367 #define usb3_for_each_ep(usb3_ep, usb3, i)                      \
 368                 for ((i) = 0, usb3_ep = usb3_get_ep(usb3, (i)); \
 369                      (i) < (usb3)->num_usb3_eps;                \
 370                      (i)++, usb3_ep = usb3_get_ep(usb3, (i)))
 371
 372 #define usb3_get_dma(usb3, i)   (&(usb3)->dma[i])
 373 #define usb3_for_each_dma(usb3, dma, i)                         \
 374                 for ((i) = 0, dma = usb3_get_dma((usb3), (i));  \
 375                      (i) < USB3_DMA_NUM_SETTING_AREA;           \
 376                      (i)++, dma = usb3_get_dma((usb3), (i)))
 377
 378 static const char udc_name[] = "renesas_usb3";
 379
 380 static bool use_dma = 1;
 381 module_param(use_dma, bool, 0644);
 382 MODULE_PARM_DESC(use_dma, "use dedicated DMAC");
 383
 384 static void usb3_write(struct renesas_usb3 *usb3, u32 data, u32 offs)
 385 {
 386         iowrite32(data, usb3->reg + offs);
 387 }
 388
 389 static u32 usb3_read(struct renesas_usb3 *usb3, u32 offs)
 390 {
 391         return ioread32(usb3->reg + offs);
 392 }
 393
 394 static void usb3_set_bit(struct renesas_usb3 *usb3, u32 bits, u32 offs)
 395 {
 396         u32 val = usb3_read(usb3, offs);
 397
 398         val |= bits;
 399         usb3_write(usb3, val, offs);
 400 }
 401
 402 static void usb3_clear_bit(struct renesas_usb3 *usb3, u32 bits, u32 offs)
 403 {
 404         u32 val = usb3_read(usb3, offs);
 405
 406         val &= ~bits;
 407         usb3_write(usb3, val, offs);
 408 }
 409
 410 static int usb3_wait(struct renesas_usb3 *usb3, u32 reg, u32 mask,
 411                      u32 expected)
 412 {
 413         int i;
 414
 415         for (i = 0; i < USB3_WAIT_US; i++) {
 416                 if ((usb3_read(usb3, reg) & mask) == expected)
 417                         return 0;
 418                 udelay(1);
 419         }
 420
 421         dev_dbg(usb3_to_dev(usb3), "%s: timed out (%8x, %08x, %08x)\n",
 422                 __func__, reg, mask, expected);
 423
 424         return -EBUSY;
 425 }
 426
 427 static void renesas_usb3_extcon_work(struct work_struct *work)
 428 {
 429         struct renesas_usb3 *usb3 = container_of(work, struct renesas_usb3,
 430                                                  extcon_work);
 431
 432         extcon_set_state_sync(usb3->extcon, EXTCON_USB_HOST, usb3->extcon_host);
 433         extcon_set_state_sync(usb3->extcon, EXTCON_USB, usb3->extcon_usb);
 434 }
 435
 436 static void usb3_enable_irq_1(struct renesas_usb3 *usb3, u32 bits)
 437 {
 438         usb3_set_bit(usb3, bits, USB3_USB_INT_ENA_1);
 439 }
 440
 441 static void usb3_disable_irq_1(struct renesas_usb3 *usb3, u32 bits)
 442 {
 443         usb3_clear_bit(usb3, bits, USB3_USB_INT_ENA_1);
 444 }
 445
 446 static void usb3_enable_pipe_irq(struct renesas_usb3 *usb3, int num)
 447 {
 448         usb3_set_bit(usb3, USB_INT_2_PIPE(num), USB3_USB_INT_ENA_2);
 449 }
 450
 451 static void usb3_disable_pipe_irq(struct renesas_usb3 *usb3, int num)
 452 {
 453         usb3_clear_bit(usb3, USB_INT_2_PIPE(num), USB3_USB_INT_ENA_2);
 454 }
 455
 456 static bool usb3_is_host(struct renesas_usb3 *usb3)
 457 {
 458         return !(usb3_read(usb3, USB3_DRD_CON) & DRD_CON_PERI_CON);
 459 }
 460
 461 static void usb3_init_axi_bridge(struct renesas_usb3 *usb3)
 462 {
 463         /* Set AXI_INT */
 464         usb3_write(usb3, ~0, USB3_DMA_INT_STA);
 465         usb3_write(usb3, 0, USB3_DMA_INT_ENA);
 466         usb3_set_bit(usb3, AXI_INT_DMAINT | AXI_INT_EPCINT, USB3_AXI_INT_ENA);
 467 }
 468
 469 static void usb3_init_epc_registers(struct renesas_usb3 *usb3)
 470 {
 471         usb3_write(usb3, ~0, USB3_USB_INT_STA_1);
 472         usb3_enable_irq_1(usb3, USB_INT_1_VBUS_CNG);
 473 }
 474
 475 static bool usb3_wakeup_usb2_phy(struct renesas_usb3 *usb3)
 476 {
 477         if (!(usb3_read(usb3, USB3_USB20_CON) & USB20_CON_B2_SUSPEND))
 478                 return true;    /* already waked it up */
 479
 480         usb3_clear_bit(usb3, USB20_CON_B2_SUSPEND, USB3_USB20_CON);
 481         usb3_enable_irq_1(usb3, USB_INT_1_B2_RSUM);
 482
 483         return false;
 484 }
 485
 486 static void usb3_usb2_pullup(struct renesas_usb3 *usb3, int pullup)
 487 {
 488         u32 bits = USB20_CON_B2_PUE | USB20_CON_B2_CONNECT;
 489
 490         if (usb3->softconnect && pullup)
 491                 usb3_set_bit(usb3, bits, USB3_USB20_CON);
 492         else
 493                 usb3_clear_bit(usb3, bits, USB3_USB20_CON);
 494 }
 495
 496 static void usb3_set_test_mode(struct renesas_usb3 *usb3)
 497 {
 498         u32 val = usb3_read(usb3, USB3_USB20_CON);
 499
 500         val &= ~USB20_CON_B2_TSTMOD_MASK;
 501         val |= USB20_CON_B2_TSTMOD(usb3->test_mode);
 502         usb3_write(usb3, val | USB20_CON_B2_TSTMOD_EN, USB3_USB20_CON);
 503         if (!usb3->test_mode)
 504                 usb3_clear_bit(usb3, USB20_CON_B2_TSTMOD_EN, USB3_USB20_CON);
 505 }
 506
 507 static void usb3_start_usb2_connection(struct renesas_usb3 *usb3)
 508 {
 509         usb3->disabled_count++;
 510         usb3_set_bit(usb3, USB_COM_CON_EP0_EN, USB3_USB_COM_CON);
 511         usb3_set_bit(usb3, USB_COM_CON_SPD_MODE, USB3_USB_COM_CON);
 512         usb3_usb2_pullup(usb3, 1);
 513 }
 514
 515 static int usb3_is_usb3_phy_in_u3(struct renesas_usb3 *usb3)
 516 {
 517         return usb3_read(usb3, USB3_USB30_CON) & USB30_CON_POW_SEL_IN_U3;
 518 }
 519
 520 static bool usb3_wakeup_usb3_phy(struct renesas_usb3 *usb3)
 521 {
 522         if (!usb3_is_usb3_phy_in_u3(usb3))
 523                 return true;    /* already waked it up */
 524
 525         usb3_set_bit(usb3, USB30_CON_B3_PLLWAKE, USB3_USB30_CON);
 526         usb3_enable_irq_1(usb3, USB_INT_1_B3_PLLWKUP);
 527
 528         return false;
 529 }
 530
 531 static u16 usb3_feature_get_un_enabled(struct renesas_usb3 *usb3)
 532 {
 533         u32 mask_u2 = SSIFCMD_UDIR_U2 | SSIFCMD_UREQ_U2;
 534         u32 mask_u1 = SSIFCMD_UDIR_U1 | SSIFCMD_UREQ_U1;
 535         u32 val = usb3_read(usb3, USB3_SSIFCMD);
 536         u16 ret = 0;
 537
 538         /* Enables {U2,U1} if the bits of UDIR and UREQ are set to 0 */
 539         if (!(val & mask_u2))
 540                 ret |= 1 << USB_DEV_STAT_U2_ENABLED;
 541         if (!(val & mask_u1))
 542                 ret |= 1 << USB_DEV_STAT_U1_ENABLED;
 543
 544         return ret;
 545 }
 546
 547 static void usb3_feature_u2_enable(struct renesas_usb3 *usb3, bool enable)
 548 {
 549         u32 bits = SSIFCMD_UDIR_U2 | SSIFCMD_UREQ_U2;
 550
 551         /* Enables U2 if the bits of UDIR and UREQ are set to 0 */
 552         if (enable)
 553                 usb3_clear_bit(usb3, bits, USB3_SSIFCMD);
 554         else
 555                 usb3_set_bit(usb3, bits, USB3_SSIFCMD);
 556 }
 557
 558 static void usb3_feature_u1_enable(struct renesas_usb3 *usb3, bool enable)
 559 {
 560         u32 bits = SSIFCMD_UDIR_U1 | SSIFCMD_UREQ_U1;
 561
 562         /* Enables U1 if the bits of UDIR and UREQ are set to 0 */
 563         if (enable)
 564                 usb3_clear_bit(usb3, bits, USB3_SSIFCMD);
 565         else
 566                 usb3_set_bit(usb3, bits, USB3_SSIFCMD);
 567 }
 568
 569 static void usb3_start_operation_for_usb3(struct renesas_usb3 *usb3)
 570 {
 571         usb3_set_bit(usb3, USB_COM_CON_EP0_EN, USB3_USB_COM_CON);
 572         usb3_clear_bit(usb3, USB_COM_CON_SPD_MODE, USB3_USB_COM_CON);
 573         usb3_set_bit(usb3, USB30_CON_B3_CONNECT, USB3_USB30_CON);
 574 }
 575
 576 static void usb3_start_usb3_connection(struct renesas_usb3 *usb3)
 577 {
 578         usb3_start_operation_for_usb3(usb3);
 579         usb3_set_bit(usb3, USB_COM_CON_RX_DETECTION, USB3_USB_COM_CON);
 580
 581         usb3_enable_irq_1(usb3, USB_INT_1_B3_LUPSUCS | USB_INT_1_B3_DISABLE |
 582                           USB_INT_1_SPEED);
 583 }
 584
 585 static void usb3_stop_usb3_connection(struct renesas_usb3 *usb3)
 586 {
 587         usb3_clear_bit(usb3, USB30_CON_B3_CONNECT, USB3_USB30_CON);
 588 }
 589
 590 static void usb3_transition_to_default_state(struct renesas_usb3 *usb3,
 591                                              bool is_usb3)
 592 {
 593         usb3_set_bit(usb3, USB_INT_2_PIPE(0), USB3_USB_INT_ENA_2);
 594         usb3_write(usb3, P0_INT_ALL_BITS, USB3_P0_INT_STA);
 595         usb3_set_bit(usb3, P0_INT_ALL_BITS, USB3_P0_INT_ENA);
 596
 597         if (is_usb3)
 598                 usb3_enable_irq_1(usb3, USB_INT_1_B3_WRMRST |
 599                                   USB_INT_1_B3_HOTRST);
 600         else
 601                 usb3_enable_irq_1(usb3, USB_INT_1_B2_SPND |
 602                                   USB_INT_1_B2_L1SPND | USB_INT_1_B2_USBRST);
 603 }
 604
 605 static void usb3_connect(struct renesas_usb3 *usb3)
 606 {
 607         if (usb3_wakeup_usb3_phy(usb3))
 608                 usb3_start_usb3_connection(usb3);
 609 }
 610
 611 static void usb3_reset_epc(struct renesas_usb3 *usb3)
 612 {
 613         usb3_clear_bit(usb3, USB_COM_CON_CONF, USB3_USB_COM_CON);
 614         usb3_clear_bit(usb3, USB_COM_CON_EP0_EN, USB3_USB_COM_CON);
 615         usb3_set_bit(usb3, USB_COM_CON_PIPE_CLR, USB3_USB_COM_CON);
 616         usb3->test_mode = 0;
 617         usb3_set_test_mode(usb3);
 618 }
 619
 620 static void usb3_disconnect(struct renesas_usb3 *usb3)
 621 {
 622         usb3->disabled_count = 0;
 623         usb3_usb2_pullup(usb3, 0);
 624         usb3_clear_bit(usb3, USB30_CON_B3_CONNECT, USB3_USB30_CON);
 625         usb3_reset_epc(usb3);
 626
 627         if (usb3->driver)
 628                 usb3->driver->disconnect(&usb3->gadget);
 629 }
 630
 631 static void usb3_check_vbus(struct renesas_usb3 *usb3)
 632 {
 633         if (usb3->workaround_for_vbus) {
 634                 usb3_connect(usb3);
 635         } else {
 636                 usb3->extcon_usb = !!(usb3_read(usb3, USB3_USB_STA) &
 637                                                         USB_STA_VBUS_STA);
 638                 if (usb3->extcon_usb)
 639                         usb3_connect(usb3);
 640                 else
 641                         usb3_disconnect(usb3);
 642
 643                 schedule_work(&usb3->extcon_work);
 644         }
 645 }
 646
 647 static void usb3_set_mode(struct renesas_usb3 *usb3, bool host)
 648 {
 649         if (host)
 650                 usb3_clear_bit(usb3, DRD_CON_PERI_CON, USB3_DRD_CON);
 651         else
 652                 usb3_set_bit(usb3, DRD_CON_PERI_CON, USB3_DRD_CON);
 653 }
 654
 655 static void usb3_vbus_out(struct renesas_usb3 *usb3, bool enable)
 656 {
 657         if (enable)
 658                 usb3_set_bit(usb3, DRD_CON_VBOUT, USB3_DRD_CON);
 659         else
 660                 usb3_clear_bit(usb3, DRD_CON_VBOUT, USB3_DRD_CON);
 661 }
 662
 663 static void usb3_mode_config(struct renesas_usb3 *usb3, bool host, bool a_dev)
 664 {
 665         unsigned long flags;
 666
 667         spin_lock_irqsave(&usb3->lock, flags);
 668         usb3_set_mode(usb3, host);
 669         usb3_vbus_out(usb3, a_dev);
 670         /* for A-Peripheral or forced B-device mode */
 671         if ((!host && a_dev) ||
 672             (usb3->workaround_for_vbus && usb3->forced_b_device))
 673                 usb3_connect(usb3);
 674         spin_unlock_irqrestore(&usb3->lock, flags);
 675 }
 676
 677 static bool usb3_is_a_device(struct renesas_usb3 *usb3)
 678 {
 679         return !(usb3_read(usb3, USB3_USB_OTG_STA) & USB_OTG_IDMON);
 680 }
 681
 682 static void usb3_check_id(struct renesas_usb3 *usb3)
 683 {
 684         usb3->extcon_host = usb3_is_a_device(usb3);
 685
 686         if (usb3->extcon_host && !usb3->forced_b_device)
 687                 usb3_mode_config(usb3, true, true);
 688         else
 689                 usb3_mode_config(usb3, false, false);
 690
 691         schedule_work(&usb3->extcon_work);
 692 }
 693
 694 static void renesas_usb3_init_controller(struct renesas_usb3 *usb3)
 695 {
 696         usb3_init_axi_bridge(usb3);
 697         usb3_init_epc_registers(usb3);
 698         usb3_set_bit(usb3, USB_COM_CON_PN_WDATAIF_NL |
 699                      USB_COM_CON_PN_RDATAIF_NL | USB_COM_CON_PN_LSTTR_PP,
 700                      USB3_USB_COM_CON);
 701         usb3_write(usb3, USB_OTG_IDMON, USB3_USB_OTG_INT_STA);
 702         usb3_write(usb3, USB_OTG_IDMON, USB3_USB_OTG_INT_ENA);
 703
 704         usb3_check_id(usb3);
 705         usb3_check_vbus(usb3);
 706 }
 707
 708 static void renesas_usb3_stop_controller(struct renesas_usb3 *usb3)
 709 {
 710         usb3_disconnect(usb3);
 711         usb3_write(usb3, 0, USB3_P0_INT_ENA);
 712         usb3_write(usb3, 0, USB3_USB_OTG_INT_ENA);
 713         usb3_write(usb3, 0, USB3_USB_INT_ENA_1);
 714         usb3_write(usb3, 0, USB3_USB_INT_ENA_2);
 715         usb3_write(usb3, 0, USB3_AXI_INT_ENA);
 716 }
 717
 718 static void usb3_irq_epc_int_1_pll_wakeup(struct renesas_usb3 *usb3)
 719 {
 720         usb3_disable_irq_1(usb3, USB_INT_1_B3_PLLWKUP);
 721         usb3_clear_bit(usb3, USB30_CON_B3_PLLWAKE, USB3_USB30_CON);
 722         usb3_start_usb3_connection(usb3);
 723 }
 724
 725 static void usb3_irq_epc_int_1_linkup_success(struct renesas_usb3 *usb3)
 726 {
 727         usb3_transition_to_default_state(usb3, true);
 728 }
 729
 730 static void usb3_irq_epc_int_1_resume(struct renesas_usb3 *usb3)
 731 {
 732         usb3_disable_irq_1(usb3, USB_INT_1_B2_RSUM);
 733         usb3_start_usb2_connection(usb3);
 734         usb3_transition_to_default_state(usb3, false);
 735 }
 736
 737 static void usb3_irq_epc_int_1_disable(struct renesas_usb3 *usb3)
 738 {
 739         usb3_stop_usb3_connection(usb3);
 740         if (usb3_wakeup_usb2_phy(usb3))
 741                 usb3_irq_epc_int_1_resume(usb3);
 742 }
 743
 744 static void usb3_irq_epc_int_1_bus_reset(struct renesas_usb3 *usb3)
 745 {
 746         usb3_reset_epc(usb3);
 747         if (usb3->disabled_count < 3)
 748                 usb3_start_usb3_connection(usb3);
 749         else
 750                 usb3_start_usb2_connection(usb3);
 751 }
 752
 753 static void usb3_irq_epc_int_1_vbus_change(struct renesas_usb3 *usb3)
 754 {
 755         usb3_check_vbus(usb3);
 756 }
 757
 758 static void usb3_irq_epc_int_1_hot_reset(struct renesas_usb3 *usb3)
 759 {
 760         usb3_reset_epc(usb3);
 761         usb3_set_bit(usb3, USB_COM_CON_EP0_EN, USB3_USB_COM_CON);
 762
 763         /* This bit shall be set within 12ms from the start of HotReset */
 764         usb3_set_bit(usb3, USB30_CON_B3_HOTRST_CMP, USB3_USB30_CON);
 765 }
 766
 767 static void usb3_irq_epc_int_1_warm_reset(struct renesas_usb3 *usb3)
 768 {
 769         usb3_reset_epc(usb3);
 770         usb3_set_bit(usb3, USB_COM_CON_EP0_EN, USB3_USB_COM_CON);
 771
 772         usb3_start_operation_for_usb3(usb3);
 773         usb3_enable_irq_1(usb3, USB_INT_1_SPEED);
 774 }
 775
 776 static void usb3_irq_epc_int_1_speed(struct renesas_usb3 *usb3)
 777 {
 778         u32 speed = usb3_read(usb3, USB3_USB_STA) & USB_STA_SPEED_MASK;
 779
 780         switch (speed) {
 781         case USB_STA_SPEED_SS:
 782                 usb3->gadget.speed = USB_SPEED_SUPER;
 783                 break;
 784         case USB_STA_SPEED_HS:
 785                 usb3->gadget.speed = USB_SPEED_HIGH;
 786                 break;
 787         case USB_STA_SPEED_FS:
 788                 usb3->gadget.speed = USB_SPEED_FULL;
 789                 break;
 790         default:
 791                 usb3->gadget.speed = USB_SPEED_UNKNOWN;
 792                 break;
 793         }
 794 }
 795
 796 static void usb3_irq_epc_int_1(struct renesas_usb3 *usb3, u32 int_sta_1)
 797 {
 798         if (int_sta_1 & USB_INT_1_B3_PLLWKUP)
 799                 usb3_irq_epc_int_1_pll_wakeup(usb3);
 800
 801         if (int_sta_1 & USB_INT_1_B3_LUPSUCS)
 802                 usb3_irq_epc_int_1_linkup_success(usb3);
 803
 804         if (int_sta_1 & USB_INT_1_B3_HOTRST)
 805                 usb3_irq_epc_int_1_hot_reset(usb3);
 806
 807         if (int_sta_1 & USB_INT_1_B3_WRMRST)
 808                 usb3_irq_epc_int_1_warm_reset(usb3);
 809
 810         if (int_sta_1 & USB_INT_1_B3_DISABLE)
 811                 usb3_irq_epc_int_1_disable(usb3);
 812
 813         if (int_sta_1 & USB_INT_1_B2_USBRST)
 814                 usb3_irq_epc_int_1_bus_reset(usb3);
 815
 816         if (int_sta_1 & USB_INT_1_B2_RSUM)
 817                 usb3_irq_epc_int_1_resume(usb3);
 818
 819         if (int_sta_1 & USB_INT_1_SPEED)
 820                 usb3_irq_epc_int_1_speed(usb3);
 821
 822         if (int_sta_1 & USB_INT_1_VBUS_CNG)
 823                 usb3_irq_epc_int_1_vbus_change(usb3);
 824 }
 825
 826 static struct renesas_usb3_request *__usb3_get_request(struct renesas_usb3_ep
 827                                                        *usb3_ep)
 828 {
 829         return list_first_entry_or_null(&usb3_ep->queue,
 830                                         struct renesas_usb3_request, queue);
 831 }
 832
 833 static struct renesas_usb3_request *usb3_get_request(struct renesas_usb3_ep
 834                                                      *usb3_ep)
 835 {
 836         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
 837         struct renesas_usb3_request *usb3_req;
 838         unsigned long flags;
 839
 840         spin_lock_irqsave(&usb3->lock, flags);
 841         usb3_req = __usb3_get_request(usb3_ep);
 842         spin_unlock_irqrestore(&usb3->lock, flags);
 843
 844         return usb3_req;
 845 }
 846
 847 static void __usb3_request_done(struct renesas_usb3_ep *usb3_ep,
 848                                 struct renesas_usb3_request *usb3_req,
 849                                 int status)
 850 {
 851         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
 852
 853         dev_dbg(usb3_to_dev(usb3), "giveback: ep%2d, %u, %u, %d\n",
 854                 usb3_ep->num, usb3_req->req.length, usb3_req->req.actual,
 855                 status);
 856         usb3_req->req.status = status;
 857         usb3_ep->started = false;
 858         list_del_init(&usb3_req->queue);
 859         spin_unlock(&usb3->lock);
 860         usb_gadget_giveback_request(&usb3_ep->ep, &usb3_req->req);
 861         spin_lock(&usb3->lock);
 862 }
 863
 864 static void usb3_request_done(struct renesas_usb3_ep *usb3_ep,
 865                               struct renesas_usb3_request *usb3_req, int status)
 866 {
 867         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
 868         unsigned long flags;
 869
 870         spin_lock_irqsave(&usb3->lock, flags);
 871         __usb3_request_done(usb3_ep, usb3_req, status);
 872         spin_unlock_irqrestore(&usb3->lock, flags);
 873 }
 874
 875 static void usb3_irq_epc_pipe0_status_end(struct renesas_usb3 *usb3)
 876 {
 877         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, 0);
 878         struct renesas_usb3_request *usb3_req = usb3_get_request(usb3_ep);
 879
 880         if (usb3_req)
 881                 usb3_request_done(usb3_ep, usb3_req, 0);
 882         if (usb3->test_mode)
 883                 usb3_set_test_mode(usb3);
 884 }
 885
 886 static void usb3_get_setup_data(struct renesas_usb3 *usb3,
 887                                 struct usb_ctrlrequest *ctrl)
 888 {
 889         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, 0);
 890         u32 *data = (u32 *)ctrl;
 891
 892         *data++ = usb3_read(usb3, USB3_STUP_DAT_0);
 893         *data = usb3_read(usb3, USB3_STUP_DAT_1);
 894
 895         /* update this driver's flag */
 896         usb3_ep->dir_in = !!(ctrl->bRequestType & USB_DIR_IN);
 897 }
 898
 899 static void usb3_set_p0_con_update_res(struct renesas_usb3 *usb3, u32 res)
 900 {
 901         u32 val = usb3_read(usb3, USB3_P0_CON);
 902
 903         val &= ~(P0_CON_ST_RES_MASK | P0_CON_OT_RES_MASK | P0_CON_IN_RES_MASK);
 904         val |= res | P0_CON_RES_WEN;
 905         usb3_write(usb3, val, USB3_P0_CON);
 906 }
 907
 908 static void usb3_set_p0_con_for_ctrl_read_data(struct renesas_usb3 *usb3)
 909 {
 910         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_FORCE_NRDY |
 911                                    P0_CON_OT_RES_FORCE_STALL |
 912                                    P0_CON_IN_RES_NORMAL);
 913 }
 914
 915 static void usb3_set_p0_con_for_ctrl_read_status(struct renesas_usb3 *usb3)
 916 {
 917         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_NORMAL |
 918                                    P0_CON_OT_RES_FORCE_STALL |
 919                                    P0_CON_IN_RES_NORMAL);
 920 }
 921
 922 static void usb3_set_p0_con_for_ctrl_write_data(struct renesas_usb3 *usb3)
 923 {
 924         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_FORCE_NRDY |
 925                                    P0_CON_OT_RES_NORMAL |
 926                                    P0_CON_IN_RES_FORCE_STALL);
 927 }
 928
 929 static void usb3_set_p0_con_for_ctrl_write_status(struct renesas_usb3 *usb3)
 930 {
 931         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_NORMAL |
 932                                    P0_CON_OT_RES_NORMAL |
 933                                    P0_CON_IN_RES_FORCE_STALL);
 934 }
 935
 936 static void usb3_set_p0_con_for_no_data(struct renesas_usb3 *usb3)
 937 {
 938         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_NORMAL |
 939                                    P0_CON_OT_RES_FORCE_STALL |
 940                                    P0_CON_IN_RES_FORCE_STALL);
 941 }
 942
 943 static void usb3_set_p0_con_stall(struct renesas_usb3 *usb3)
 944 {
 945         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_FORCE_STALL |
 946                                    P0_CON_OT_RES_FORCE_STALL |
 947                                    P0_CON_IN_RES_FORCE_STALL);
 948 }
 949
 950 static void usb3_set_p0_con_stop(struct renesas_usb3 *usb3)
 951 {
 952         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_FORCE_NRDY |
 953                                    P0_CON_OT_RES_FORCE_NRDY |
 954                                    P0_CON_IN_RES_FORCE_NRDY);
 955 }
 956
 957 static int usb3_pn_change(struct renesas_usb3 *usb3, int num)
 958 {
 959         if (num == 0 || num > usb3->num_usb3_eps)
 960                 return -ENXIO;
 961
 962         usb3_write(usb3, num, USB3_PIPE_COM);
 963
 964         return 0;
 965 }
 966
 967 static void usb3_set_pn_con_update_res(struct renesas_usb3 *usb3, u32 res)
 968 {
 969         u32 val = usb3_read(usb3, USB3_PN_CON);
 970
 971         val &= ~PN_CON_RES_MASK;
 972         val |= res & PN_CON_RES_MASK;
 973         val |= PN_CON_RES_WEN;
 974         usb3_write(usb3, val, USB3_PN_CON);
 975 }
 976
 977 static void usb3_pn_start(struct renesas_usb3 *usb3)
 978 {
 979         usb3_set_pn_con_update_res(usb3, PN_CON_RES_NORMAL);
 980 }
 981
 982 static void usb3_pn_stop(struct renesas_usb3 *usb3)
 983 {
 984         usb3_set_pn_con_update_res(usb3, PN_CON_RES_FORCE_NRDY);
 985 }
 986
 987 static void usb3_pn_stall(struct renesas_usb3 *usb3)
 988 {
 989         usb3_set_pn_con_update_res(usb3, PN_CON_RES_FORCE_STALL);
 990 }
 991
 992 static int usb3_pn_con_clear(struct renesas_usb3 *usb3)
 993 {
 994         usb3_set_bit(usb3, PN_CON_CLR, USB3_PN_CON);
 995
 996         return usb3_wait(usb3, USB3_PN_CON, PN_CON_CLR, 0);
 997 }
 998
 999 static bool usb3_is_transfer_complete(struct renesas_usb3_ep *usb3_ep,
1000                                       struct renesas_usb3_request *usb3_req)
1001 {
1002         struct usb_request *req = &usb3_req->req;
1003
1004         if ((!req->zero && req->actual == req->length) ||
1005             (req->actual % usb3_ep->ep.maxpacket) || (req->length == 0))
1006                 return true;
1007         else
1008                 return false;
1009 }
1010
1011 static int usb3_wait_pipe_status(struct renesas_usb3_ep *usb3_ep, u32 mask)
1012 {
1013         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1014         u32 sta_reg = usb3_ep->num ? USB3_PN_STA : USB3_P0_STA;
1015
1016         return usb3_wait(usb3, sta_reg, mask, mask);
1017 }
1018
1019 static void usb3_set_px_con_send(struct renesas_usb3_ep *usb3_ep, int bytes,
1020                                  bool last)
1021 {
1022         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1023         u32 con_reg = usb3_ep->num ? USB3_PN_CON : USB3_P0_CON;
1024         u32 val = usb3_read(usb3, con_reg);
1025
1026         val |= PX_CON_SEND | PX_CON_BYTE_EN_BYTES(bytes);
1027         val |= (usb3_ep->num && last) ? PN_CON_LAST : 0;
1028         usb3_write(usb3, val, con_reg);
1029 }
1030
1031 static int usb3_write_pipe(struct renesas_usb3_ep *usb3_ep,
1032                            struct renesas_usb3_request *usb3_req,
1033                            u32 fifo_reg)
1034 {
1035         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1036         int i;
1037         int len = min_t(unsigned, usb3_req->req.length - usb3_req->req.actual,
1038                         usb3_ep->ep.maxpacket);
1039         u8 *buf = usb3_req->req.buf + usb3_req->req.actual;
1040         u32 tmp = 0;
1041         bool is_last = !len ? true : false;
1042
1043         if (usb3_wait_pipe_status(usb3_ep, PX_STA_BUFSTS) < 0)
1044                 return -EBUSY;
1045
1046         /* Update gadget driver parameter */
1047         usb3_req->req.actual += len;
1048
1049         /* Write data to the register */
1050         if (len >= 4) {
1051                 iowrite32_rep(usb3->reg + fifo_reg, buf, len / 4);
1052                 buf += (len / 4) * 4;
1053                 len %= 4;       /* update len to use usb3_set_pX_con_send() */
1054         }
1055
1056         if (len) {
1057                 for (i = 0; i < len; i++)
1058                         tmp |= buf[i] << (8 * i);
1059                 usb3_write(usb3, tmp, fifo_reg);
1060         }
1061
1062         if (!is_last)
1063                 is_last = usb3_is_transfer_complete(usb3_ep, usb3_req);
1064         /* Send the data */
1065         usb3_set_px_con_send(usb3_ep, len, is_last);
1066
1067         return is_last ? 0 : -EAGAIN;
1068 }
1069
1070 static u32 usb3_get_received_length(struct renesas_usb3_ep *usb3_ep)
1071 {
1072         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1073         u32 lng_reg = usb3_ep->num ? USB3_PN_LNG : USB3_P0_LNG;
1074
1075         return usb3_read(usb3, lng_reg);
1076 }
1077
1078 static int usb3_read_pipe(struct renesas_usb3_ep *usb3_ep,
1079                           struct renesas_usb3_request *usb3_req, u32 fifo_reg)
1080 {
1081         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1082         int i;
1083         int len = min_t(unsigned, usb3_req->req.length - usb3_req->req.actual,
1084                         usb3_get_received_length(usb3_ep));
1085         u8 *buf = usb3_req->req.buf + usb3_req->req.actual;
1086         u32 tmp = 0;
1087
1088         if (!len)
1089                 return 0;
1090
1091         /* Update gadget driver parameter */
1092         usb3_req->req.actual += len;
1093
1094         /* Read data from the register */
1095         if (len >= 4) {
1096                 ioread32_rep(usb3->reg + fifo_reg, buf, len / 4);
1097                 buf += (len / 4) * 4;
1098                 len %= 4;
1099         }
1100
1101         if (len) {
1102                 tmp = usb3_read(usb3, fifo_reg);
1103                 for (i = 0; i < len; i++)
1104                         buf[i] = (tmp >> (8 * i)) & 0xff;
1105         }
1106
1107         return usb3_is_transfer_complete(usb3_ep, usb3_req) ? 0 : -EAGAIN;
1108 }
1109
1110 static void usb3_set_status_stage(struct renesas_usb3_ep *usb3_ep,
1111                                   struct renesas_usb3_request *usb3_req)
1112 {
1113         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1114
1115         if (usb3_ep->dir_in) {
1116                 usb3_set_p0_con_for_ctrl_read_status(usb3);
1117         } else {
1118                 if (!usb3_req->req.length)
1119                         usb3_set_p0_con_for_no_data(usb3);
1120                 else
1121                         usb3_set_p0_con_for_ctrl_write_status(usb3);
1122         }
1123 }
1124
1125 static void usb3_p0_xfer(struct renesas_usb3_ep *usb3_ep,
1126                          struct renesas_usb3_request *usb3_req)
1127 {
1128         int ret = -EAGAIN;
1129
1130         if (usb3_ep->dir_in)
1131                 ret = usb3_write_pipe(usb3_ep, usb3_req, USB3_P0_WRITE);
1132         else
1133                 ret = usb3_read_pipe(usb3_ep, usb3_req, USB3_P0_READ);
1134
1135         if (!ret)
1136                 usb3_set_status_stage(usb3_ep, usb3_req);
1137 }
1138
1139 static void usb3_start_pipe0(struct renesas_usb3_ep *usb3_ep,
1140                              struct renesas_usb3_request *usb3_req)
1141 {
1142         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1143
1144         if (usb3_ep->started)
1145                 return;
1146
1147         usb3_ep->started = true;
1148
1149         if (usb3_ep->dir_in) {
1150                 usb3_set_bit(usb3, P0_MOD_DIR, USB3_P0_MOD);
1151                 usb3_set_p0_con_for_ctrl_read_data(usb3);
1152         } else {
1153                 usb3_clear_bit(usb3, P0_MOD_DIR, USB3_P0_MOD);
1154                 if (usb3_req->req.length)
1155                         usb3_set_p0_con_for_ctrl_write_data(usb3);
1156         }
1157
1158         usb3_p0_xfer(usb3_ep, usb3_req);
1159 }
1160
1161 static void usb3_enable_dma_pipen(struct renesas_usb3 *usb3)
1162 {
1163         usb3_set_bit(usb3, PN_CON_DATAIF_EN, USB3_PN_CON);
1164 }
1165
1166 static void usb3_disable_dma_pipen(struct renesas_usb3 *usb3)
1167 {
1168         usb3_clear_bit(usb3, PN_CON_DATAIF_EN, USB3_PN_CON);
1169 }
1170
1171 static void usb3_enable_dma_irq(struct renesas_usb3 *usb3, int num)
1172 {
1173         usb3_set_bit(usb3, DMA_INT(num), USB3_DMA_INT_ENA);
1174 }
1175
1176 static void usb3_disable_dma_irq(struct renesas_usb3 *usb3, int num)
1177 {
1178         usb3_clear_bit(usb3, DMA_INT(num), USB3_DMA_INT_ENA);
1179 }
1180
1181 static u32 usb3_dma_mps_to_prd_word1(struct renesas_usb3_ep *usb3_ep)
1182 {
1183         switch (usb3_ep->ep.maxpacket) {
1184         case 8:
1185                 return USB3_PRD1_MPS_8;
1186         case 16:
1187                 return USB3_PRD1_MPS_16;
1188         case 32:
1189                 return USB3_PRD1_MPS_32;
1190         case 64:
1191                 return USB3_PRD1_MPS_64;
1192         case 512:
1193                 return USB3_PRD1_MPS_512;
1194         case 1024:
1195                 return USB3_PRD1_MPS_1024;
1196         default:
1197                 return USB3_PRD1_MPS_RESERVED;
1198         }
1199 }
1200
1201 static bool usb3_dma_get_setting_area(struct renesas_usb3_ep *usb3_ep,
1202                                       struct renesas_usb3_request *usb3_req)
1203 {
1204         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1205         struct renesas_usb3_dma *dma;
1206         int i;
1207         bool ret = false;
1208
1209         if (usb3_req->req.length > USB3_DMA_MAX_XFER_SIZE_ALL_PRDS) {
1210                 dev_dbg(usb3_to_dev(usb3), "%s: the length is too big (%d)\n",
1211                         __func__, usb3_req->req.length);
1212                 return false;
1213         }
1214
1215         /* The driver doesn't handle zero-length packet via dmac */
1216         if (!usb3_req->req.length)
1217                 return false;
1218
1219         if (usb3_dma_mps_to_prd_word1(usb3_ep) == USB3_PRD1_MPS_RESERVED)
1220                 return false;
1221
1222         usb3_for_each_dma(usb3, dma, i) {
1223                 if (dma->used)
1224                         continue;
1225
1226                 if (usb_gadget_map_request(&usb3->gadget, &usb3_req->req,
1227                                            usb3_ep->dir_in) < 0)
1228                         break;
1229
1230                 dma->used = true;
1231                 usb3_ep->dma = dma;
1232                 ret = true;
1233                 break;
1234         }
1235
1236         return ret;
1237 }
1238
1239 static void usb3_dma_put_setting_area(struct renesas_usb3_ep *usb3_ep,
1240                                       struct renesas_usb3_request *usb3_req)
1241 {
1242         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1243         int i;
1244         struct renesas_usb3_dma *dma;
1245
1246         usb3_for_each_dma(usb3, dma, i) {
1247                 if (usb3_ep->dma == dma) {
1248                         usb_gadget_unmap_request(&usb3->gadget, &usb3_req->req,
1249                                                  usb3_ep->dir_in);
1250                         dma->used = false;
1251                         usb3_ep->dma = NULL;
1252                         break;
1253                 }
1254         }
1255 }
1256
1257 static void usb3_dma_fill_prd(struct renesas_usb3_ep *usb3_ep,
1258                               struct renesas_usb3_request *usb3_req)
1259 {
1260         struct renesas_usb3_prd *cur_prd = usb3_ep->dma->prd;
1261         u32 remain = usb3_req->req.length;
1262         u32 dma = usb3_req->req.dma;
1263         u32 len;
1264         int i = 0;
1265
1266         do {
1267                 len = min_t(u32, remain, USB3_DMA_MAX_XFER_SIZE) &
1268                             USB3_PRD1_SIZE_MASK;
1269                 cur_prd->word1 = usb3_dma_mps_to_prd_word1(usb3_ep) |
1270                                  USB3_PRD1_B_INC | len;
1271                 cur_prd->bap = dma;
1272                 remain -= len;
1273                 dma += len;
1274                 if (!remain || (i + 1) < USB3_DMA_NUM_PRD_ENTRIES)
1275                         break;
1276
1277                 cur_prd++;
1278                 i++;
1279         } while (1);
1280
1281         cur_prd->word1 |= USB3_PRD1_E | USB3_PRD1_INT;
1282         if (usb3_ep->dir_in)
1283                 cur_prd->word1 |= USB3_PRD1_LST;
1284 }
1285
1286 static void usb3_dma_kick_prd(struct renesas_usb3_ep *usb3_ep)
1287 {
1288         struct renesas_usb3_dma *dma = usb3_ep->dma;
1289         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1290         u32 dma_con = DMA_COM_PIPE_NO(usb3_ep->num) | DMA_CON_PRD_EN;
1291
1292         if (usb3_ep->dir_in)
1293                 dma_con |= DMA_CON_PIPE_DIR;
1294
1295         wmb();  /* prd entries should be in system memory here */
1296
1297         usb3_write(usb3, 1 << usb3_ep->num, USB3_DMA_INT_STA);
1298         usb3_write(usb3, AXI_INT_PRDEN_CLR_STA(dma->num) |
1299                    AXI_INT_PRDERR_STA(dma->num), USB3_AXI_INT_STA);
1300
1301         usb3_write(usb3, dma->prd_dma, USB3_DMA_CH0_PRD_ADR(dma->num));
1302         usb3_write(usb3, dma_con, USB3_DMA_CH0_CON(dma->num));
1303         usb3_enable_dma_irq(usb3, usb3_ep->num);
1304 }
1305
1306 static void usb3_dma_stop_prd(struct renesas_usb3_ep *usb3_ep)
1307 {
1308         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1309         struct renesas_usb3_dma *dma = usb3_ep->dma;
1310
1311         usb3_disable_dma_irq(usb3, usb3_ep->num);
1312         usb3_write(usb3, 0, USB3_DMA_CH0_CON(dma->num));
1313 }
1314
1315 static int usb3_dma_update_status(struct renesas_usb3_ep *usb3_ep,
1316                                   struct renesas_usb3_request *usb3_req)
1317 {
1318         struct renesas_usb3_prd *cur_prd = usb3_ep->dma->prd;
1319         struct usb_request *req = &usb3_req->req;
1320         u32 remain, len;
1321         int i = 0;
1322         int status = 0;
1323
1324         rmb();  /* The controller updated prd entries */
1325
1326         do {
1327                 if (cur_prd->word1 & USB3_PRD1_D)
1328                         status = -EIO;
1329                 if (cur_prd->word1 & USB3_PRD1_E)
1330                         len = req->length % USB3_DMA_MAX_XFER_SIZE;
1331                 else
1332                         len = USB3_DMA_MAX_XFER_SIZE;
1333                 remain = cur_prd->word1 & USB3_PRD1_SIZE_MASK;
1334                 req->actual += len - remain;
1335
1336                 if (cur_prd->word1 & USB3_PRD1_E ||
1337                     (i + 1) < USB3_DMA_NUM_PRD_ENTRIES)
1338                         break;
1339
1340                 cur_prd++;
1341                 i++;
1342         } while (1);
1343
1344         return status;
1345 }
1346
1347 static bool usb3_dma_try_start(struct renesas_usb3_ep *usb3_ep,
1348                                struct renesas_usb3_request *usb3_req)
1349 {
1350         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1351
1352         if (!use_dma)
1353                 return false;
1354
1355         if (usb3_dma_get_setting_area(usb3_ep, usb3_req)) {
1356                 usb3_pn_stop(usb3);
1357                 usb3_enable_dma_pipen(usb3);
1358                 usb3_dma_fill_prd(usb3_ep, usb3_req);
1359                 usb3_dma_kick_prd(usb3_ep);
1360                 usb3_pn_start(usb3);
1361                 return true;
1362         }
1363
1364         return false;
1365 }
1366
1367 static int usb3_dma_try_stop(struct renesas_usb3_ep *usb3_ep,
1368                              struct renesas_usb3_request *usb3_req)
1369 {
1370         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1371         unsigned long flags;
1372         int status = 0;
1373
1374         spin_lock_irqsave(&usb3->lock, flags);
1375         if (!usb3_ep->dma)
1376                 goto out;
1377
1378         if (!usb3_pn_change(usb3, usb3_ep->num))
1379                 usb3_disable_dma_pipen(usb3);
1380         usb3_dma_stop_prd(usb3_ep);
1381         status = usb3_dma_update_status(usb3_ep, usb3_req);
1382         usb3_dma_put_setting_area(usb3_ep, usb3_req);
1383
1384 out:
1385         spin_unlock_irqrestore(&usb3->lock, flags);
1386         return status;
1387 }
1388
1389 static int renesas_usb3_dma_free_prd(struct renesas_usb3 *usb3,
1390                                      struct device *dev)
1391 {
1392         int i;
1393         struct renesas_usb3_dma *dma;
1394
1395         usb3_for_each_dma(usb3, dma, i) {
1396                 if (dma->prd) {
1397                         dma_free_coherent(dev, USB3_DMA_PRD_SIZE,
1398                                           dma->prd, dma->prd_dma);
1399                         dma->prd = NULL;
1400                 }
1401         }
1402
1403         return 0;
1404 }
1405
1406 static int renesas_usb3_dma_alloc_prd(struct renesas_usb3 *usb3,
1407                                       struct device *dev)
1408 {
1409         int i;
1410         struct renesas_usb3_dma *dma;
1411
1412         if (!use_dma)
1413                 return 0;
1414
1415         usb3_for_each_dma(usb3, dma, i) {
1416                 dma->prd = dma_alloc_coherent(dev, USB3_DMA_PRD_SIZE,
1417                                               &dma->prd_dma, GFP_KERNEL);
1418                 if (!dma->prd) {
1419                         renesas_usb3_dma_free_prd(usb3, dev);
1420                         return -ENOMEM;
1421                 }
1422                 dma->num = i + 1;
1423         }
1424
1425         return 0;
1426 }
1427
1428 static void usb3_start_pipen(struct renesas_usb3_ep *usb3_ep,
1429                              struct renesas_usb3_request *usb3_req)
1430 {
1431         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1432         struct renesas_usb3_request *usb3_req_first = usb3_get_request(usb3_ep);
1433         unsigned long flags;
1434         int ret = -EAGAIN;
1435         u32 enable_bits = 0;
1436
1437         spin_lock_irqsave(&usb3->lock, flags);
1438         if (usb3_ep->halt || usb3_ep->started)
1439                 goto out;
1440         if (usb3_req != usb3_req_first)
1441                 goto out;
1442
1443         if (usb3_pn_change(usb3, usb3_ep->num) < 0)
1444                 goto out;
1445
1446         usb3_ep->started = true;
1447
1448         if (usb3_dma_try_start(usb3_ep, usb3_req))
1449                 goto out;
1450
1451         usb3_pn_start(usb3);
1452
1453         if (usb3_ep->dir_in) {
1454                 ret = usb3_write_pipe(usb3_ep, usb3_req, USB3_PN_WRITE);
1455                 enable_bits |= PN_INT_LSTTR;
1456         }
1457
1458         if (ret < 0)
1459                 enable_bits |= PN_INT_BFRDY;
1460
1461         if (enable_bits) {
1462                 usb3_set_bit(usb3, enable_bits, USB3_PN_INT_ENA);
1463                 usb3_enable_pipe_irq(usb3, usb3_ep->num);
1464         }
1465 out:
1466         spin_unlock_irqrestore(&usb3->lock, flags);
1467 }
1468
1469 static int renesas_usb3_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
1470                                  gfp_t gfp_flags)
1471 {
1472         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
1473         struct renesas_usb3_request *usb3_req = usb_req_to_usb3_req(_req);
1474         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1475         unsigned long flags;
1476
1477         dev_dbg(usb3_to_dev(usb3), "ep_queue: ep%2d, %u\n", usb3_ep->num,
1478                 _req->length);
1479
1480         _req->status = -EINPROGRESS;
1481         _req->actual = 0;
1482         spin_lock_irqsave(&usb3->lock, flags);
1483         list_add_tail(&usb3_req->queue, &usb3_ep->queue);
1484         spin_unlock_irqrestore(&usb3->lock, flags);
1485
1486         if (!usb3_ep->num)
1487                 usb3_start_pipe0(usb3_ep, usb3_req);
1488         else
1489                 usb3_start_pipen(usb3_ep, usb3_req);
1490
1491         return 0;
1492 }
1493
1494 static void usb3_set_device_address(struct renesas_usb3 *usb3, u16 addr)
1495 {
1496         /* DEV_ADDR bit field is cleared by WarmReset, HotReset and BusReset */
1497         usb3_set_bit(usb3, USB_COM_CON_DEV_ADDR(addr), USB3_USB_COM_CON);
1498 }
1499
1500 static bool usb3_std_req_set_address(struct renesas_usb3 *usb3,
1501                                      struct usb_ctrlrequest *ctrl)
1502 {
1503         if (ctrl->wValue >= 128)
1504                 return true;    /* stall */
1505
1506         usb3_set_device_address(usb3, ctrl->wValue);
1507         usb3_set_p0_con_for_no_data(usb3);
1508
1509         return false;
1510 }
1511
1512 static void usb3_pipe0_internal_xfer(struct renesas_usb3 *usb3,
1513                                      void *tx_data, size_t len,
1514                                      void (*complete)(struct usb_ep *ep,
1515                                                       struct usb_request *req))
1516 {
1517         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, 0);
1518
1519         if (tx_data)
1520                 memcpy(usb3->ep0_buf, tx_data,
1521                        min_t(size_t, len, USB3_EP0_BUF_SIZE));
1522
1523         usb3->ep0_req->buf = &usb3->ep0_buf;
1524         usb3->ep0_req->length = len;
1525         usb3->ep0_req->complete = complete;
1526         renesas_usb3_ep_queue(&usb3_ep->ep, usb3->ep0_req, GFP_ATOMIC);
1527 }
1528
1529 static void usb3_pipe0_get_status_completion(struct usb_ep *ep,
1530                                              struct usb_request *req)
1531 {
1532 }
1533
1534 static bool usb3_std_req_get_status(struct renesas_usb3 *usb3,
1535                                     struct usb_ctrlrequest *ctrl)
1536 {
1537         bool stall = false;
1538         struct renesas_usb3_ep *usb3_ep;
1539         int num;
1540         u16 status = 0;
1541
1542         switch (ctrl->bRequestType & USB_RECIP_MASK) {
1543         case USB_RECIP_DEVICE:
1544                 if (usb3->gadget.is_selfpowered)
1545                         status |= 1 << USB_DEVICE_SELF_POWERED;
1546                 if (usb3->gadget.speed == USB_SPEED_SUPER)
1547                         status |= usb3_feature_get_un_enabled(usb3);
1548                 break;
1549         case USB_RECIP_INTERFACE:
1550                 break;
1551         case USB_RECIP_ENDPOINT:
1552                 num = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK;
1553                 usb3_ep = usb3_get_ep(usb3, num);
1554                 if (usb3_ep->halt)
1555                         status |= 1 << USB_ENDPOINT_HALT;
1556                 break;
1557         default:
1558                 stall = true;
1559                 break;
1560         }
1561
1562         if (!stall) {
1563                 status = cpu_to_le16(status);
1564                 dev_dbg(usb3_to_dev(usb3), "get_status: req = %p\n",
1565                         usb_req_to_usb3_req(usb3->ep0_req));
1566                 usb3_pipe0_internal_xfer(usb3, &status, sizeof(status),
1567                                          usb3_pipe0_get_status_completion);
1568         }
1569
1570         return stall;
1571 }
1572
1573 static bool usb3_std_req_feature_device(struct renesas_usb3 *usb3,
1574                                         struct usb_ctrlrequest *ctrl, bool set)
1575 {
1576         bool stall = true;
1577         u16 w_value = le16_to_cpu(ctrl->wValue);
1578
1579         switch (w_value) {
1580         case USB_DEVICE_TEST_MODE:
1581                 if (!set)
1582                         break;
1583                 usb3->test_mode = le16_to_cpu(ctrl->wIndex) >> 8;
1584                 stall = false;
1585                 break;
1586         case USB_DEVICE_U1_ENABLE:
1587         case USB_DEVICE_U2_ENABLE:
1588                 if (usb3->gadget.speed != USB_SPEED_SUPER)
1589                         break;
1590                 if (w_value == USB_DEVICE_U1_ENABLE)
1591                         usb3_feature_u1_enable(usb3, set);
1592                 if (w_value == USB_DEVICE_U2_ENABLE)
1593                         usb3_feature_u2_enable(usb3, set);
1594                 stall = false;
1595                 break;
1596         default:
1597                 break;
1598         }
1599
1600         return stall;
1601 }
1602
1603 static int usb3_set_halt_p0(struct renesas_usb3_ep *usb3_ep, bool halt)
1604 {
1605         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1606
1607         if (unlikely(usb3_ep->num))
1608                 return -EINVAL;
1609
1610         usb3_ep->halt = halt;
1611         if (halt)
1612                 usb3_set_p0_con_stall(usb3);
1613         else
1614                 usb3_set_p0_con_stop(usb3);
1615
1616         return 0;
1617 }
1618
1619 static int usb3_set_halt_pn(struct renesas_usb3_ep *usb3_ep, bool halt,
1620                             bool is_clear_feature)
1621 {
1622         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1623         unsigned long flags;
1624
1625         spin_lock_irqsave(&usb3->lock, flags);
1626         if (!usb3_pn_change(usb3, usb3_ep->num)) {
1627                 usb3_ep->halt = halt;
1628                 if (halt) {
1629                         usb3_pn_stall(usb3);
1630                 } else if (!is_clear_feature || !usb3_ep->wedge) {
1631                         usb3_pn_con_clear(usb3);
1632                         usb3_set_bit(usb3, PN_CON_EN, USB3_PN_CON);
1633                         usb3_pn_stop(usb3);
1634                 }
1635         }
1636         spin_unlock_irqrestore(&usb3->lock, flags);
1637
1638         return 0;
1639 }
1640
1641 static int usb3_set_halt(struct renesas_usb3_ep *usb3_ep, bool halt,
1642                          bool is_clear_feature)
1643 {
1644         int ret = 0;
1645
1646         if (halt && usb3_ep->started)
1647                 return -EAGAIN;
1648
1649         if (usb3_ep->num)
1650                 ret = usb3_set_halt_pn(usb3_ep, halt, is_clear_feature);
1651         else
1652                 ret = usb3_set_halt_p0(usb3_ep, halt);
1653
1654         return ret;
1655 }
1656
1657 static bool usb3_std_req_feature_endpoint(struct renesas_usb3 *usb3,
1658                                           struct usb_ctrlrequest *ctrl,
1659                                           bool set)
1660 {
1661         int num = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK;
1662         struct renesas_usb3_ep *usb3_ep;
1663         struct renesas_usb3_request *usb3_req;
1664
1665         if (le16_to_cpu(ctrl->wValue) != USB_ENDPOINT_HALT)
1666                 return true;    /* stall */
1667
1668         usb3_ep = usb3_get_ep(usb3, num);
1669         usb3_set_halt(usb3_ep, set, true);
1670
1671         /* Restarts a queue if clear feature */
1672         if (!set) {
1673                 usb3_ep->started = false;
1674                 usb3_req = usb3_get_request(usb3_ep);
1675                 if (usb3_req)
1676                         usb3_start_pipen(usb3_ep, usb3_req);
1677         }
1678
1679         return false;
1680 }
1681
1682 static bool usb3_std_req_feature(struct renesas_usb3 *usb3,
1683                                  struct usb_ctrlrequest *ctrl, bool set)
1684 {
1685         bool stall = false;
1686
1687         switch (ctrl->bRequestType & USB_RECIP_MASK) {
1688         case USB_RECIP_DEVICE:
1689                 stall = usb3_std_req_feature_device(usb3, ctrl, set);
1690                 break;
1691         case USB_RECIP_INTERFACE:
1692                 break;
1693         case USB_RECIP_ENDPOINT:
1694                 stall = usb3_std_req_feature_endpoint(usb3, ctrl, set);
1695                 break;
1696         default:
1697                 stall = true;
1698                 break;
1699         }
1700
1701         if (!stall)
1702                 usb3_set_p0_con_for_no_data(usb3);
1703
1704         return stall;
1705 }
1706
1707 static void usb3_pipe0_set_sel_completion(struct usb_ep *ep,
1708                                           struct usb_request *req)
1709 {
1710         /* TODO */
1711 }
1712
1713 static bool usb3_std_req_set_sel(struct renesas_usb3 *usb3,
1714                                  struct usb_ctrlrequest *ctrl)
1715 {
1716         u16 w_length = le16_to_cpu(ctrl->wLength);
1717
1718         if (w_length != 6)
1719                 return true;    /* stall */
1720
1721         dev_dbg(usb3_to_dev(usb3), "set_sel: req = %p\n",
1722                 usb_req_to_usb3_req(usb3->ep0_req));
1723         usb3_pipe0_internal_xfer(usb3, NULL, 6, usb3_pipe0_set_sel_completion);
1724
1725         return false;
1726 }
1727
1728 static bool usb3_std_req_set_configuration(struct renesas_usb3 *usb3,
1729                                            struct usb_ctrlrequest *ctrl)
1730 {
1731         if (ctrl->wValue > 0)
1732                 usb3_set_bit(usb3, USB_COM_CON_CONF, USB3_USB_COM_CON);
1733         else
1734                 usb3_clear_bit(usb3, USB_COM_CON_CONF, USB3_USB_COM_CON);
1735
1736         return false;
1737 }
1738
1739 /**
1740  * usb3_handle_standard_request - handle some standard requests
1741  * @usb3: the renesas_usb3 pointer
1742  * @ctrl: a pointer of setup data
1743  *
1744  * Returns true if this function handled a standard request
1745  */
1746 static bool usb3_handle_standard_request(struct renesas_usb3 *usb3,
1747                                          struct usb_ctrlrequest *ctrl)
1748 {
1749         bool ret = false;
1750         bool stall = false;
1751
1752         if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
1753                 switch (ctrl->bRequest) {
1754                 case USB_REQ_SET_ADDRESS:
1755                         stall = usb3_std_req_set_address(usb3, ctrl);
1756                         ret = true;
1757                         break;
1758                 case USB_REQ_GET_STATUS:
1759                         stall = usb3_std_req_get_status(usb3, ctrl);
1760                         ret = true;
1761                         break;
1762                 case USB_REQ_CLEAR_FEATURE:
1763                         stall = usb3_std_req_feature(usb3, ctrl, false);
1764                         ret = true;
1765                         break;
1766                 case USB_REQ_SET_FEATURE:
1767                         stall = usb3_std_req_feature(usb3, ctrl, true);
1768                         ret = true;
1769                         break;
1770                 case USB_REQ_SET_SEL:
1771                         stall = usb3_std_req_set_sel(usb3, ctrl);
1772                         ret = true;
1773                         break;
1774                 case USB_REQ_SET_ISOCH_DELAY:
1775                         /* This hardware doesn't support Isochronous xfer */
1776                         stall = true;
1777                         ret = true;
1778                         break;
1779                 case USB_REQ_SET_CONFIGURATION:
1780                         usb3_std_req_set_configuration(usb3, ctrl);
1781                         break;
1782                 default:
1783                         break;
1784                 }
1785         }
1786
1787         if (stall)
1788                 usb3_set_p0_con_stall(usb3);
1789
1790         return ret;
1791 }
1792
1793 static int usb3_p0_con_clear_buffer(struct renesas_usb3 *usb3)
1794 {
1795         usb3_set_bit(usb3, P0_CON_BCLR, USB3_P0_CON);
1796
1797         return usb3_wait(usb3, USB3_P0_CON, P0_CON_BCLR, 0);
1798 }
1799
1800 static void usb3_irq_epc_pipe0_setup(struct renesas_usb3 *usb3)
1801 {
1802         struct usb_ctrlrequest ctrl;
1803         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, 0);
1804
1805         /* Call giveback function if previous transfer is not completed */
1806         if (usb3_ep->started)
1807                 usb3_request_done(usb3_ep, usb3_get_request(usb3_ep),
1808                                   -ECONNRESET);
1809
1810         usb3_p0_con_clear_buffer(usb3);
1811         usb3_get_setup_data(usb3, &ctrl);
1812         if (!usb3_handle_standard_request(usb3, &ctrl))
1813                 if (usb3->driver->setup(&usb3->gadget, &ctrl) < 0)
1814                         usb3_set_p0_con_stall(usb3);
1815 }
1816
1817 static void usb3_irq_epc_pipe0_bfrdy(struct renesas_usb3 *usb3)
1818 {
1819         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, 0);
1820         struct renesas_usb3_request *usb3_req = usb3_get_request(usb3_ep);
1821
1822         if (!usb3_req)
1823                 return;
1824
1825         usb3_p0_xfer(usb3_ep, usb3_req);
1826 }
1827
1828 static void usb3_irq_epc_pipe0(struct renesas_usb3 *usb3)
1829 {
1830         u32 p0_int_sta = usb3_read(usb3, USB3_P0_INT_STA);
1831
1832         p0_int_sta &= usb3_read(usb3, USB3_P0_INT_ENA);
1833         usb3_write(usb3, p0_int_sta, USB3_P0_INT_STA);
1834         if (p0_int_sta & P0_INT_STSED)
1835                 usb3_irq_epc_pipe0_status_end(usb3);
1836         if (p0_int_sta & P0_INT_SETUP)
1837                 usb3_irq_epc_pipe0_setup(usb3);
1838         if (p0_int_sta & P0_INT_BFRDY)
1839                 usb3_irq_epc_pipe0_bfrdy(usb3);
1840 }
1841
1842 static void usb3_request_done_pipen(struct renesas_usb3 *usb3,
1843                                     struct renesas_usb3_ep *usb3_ep,
1844                                     struct renesas_usb3_request *usb3_req,
1845                                     int status)
1846 {
1847         unsigned long flags;
1848
1849         spin_lock_irqsave(&usb3->lock, flags);
1850         if (usb3_pn_change(usb3, usb3_ep->num))
1851                 usb3_pn_stop(usb3);
1852         spin_unlock_irqrestore(&usb3->lock, flags);
1853
1854         usb3_disable_pipe_irq(usb3, usb3_ep->num);
1855         usb3_request_done(usb3_ep, usb3_req, status);
1856
1857         /* get next usb3_req */
1858         usb3_req = usb3_get_request(usb3_ep);
1859         if (usb3_req)
1860                 usb3_start_pipen(usb3_ep, usb3_req);
1861 }
1862
1863 static void usb3_irq_epc_pipen_lsttr(struct renesas_usb3 *usb3, int num)
1864 {
1865         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, num);
1866         struct renesas_usb3_request *usb3_req = usb3_get_request(usb3_ep);
1867
1868         if (!usb3_req)
1869                 return;
1870
1871         if (usb3_ep->dir_in) {
1872                 dev_dbg(usb3_to_dev(usb3), "%s: len = %u, actual = %u\n",
1873                         __func__, usb3_req->req.length, usb3_req->req.actual);
1874                 usb3_request_done_pipen(usb3, usb3_ep, usb3_req, 0);
1875         }
1876 }
1877
1878 static void usb3_irq_epc_pipen_bfrdy(struct renesas_usb3 *usb3, int num)
1879 {
1880         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, num);
1881         struct renesas_usb3_request *usb3_req = usb3_get_request(usb3_ep);
1882         bool done = false;
1883
1884         if (!usb3_req)
1885                 return;
1886
1887         spin_lock(&usb3->lock);
1888         if (usb3_pn_change(usb3, num))
1889                 goto out;
1890
1891         if (usb3_ep->dir_in) {
1892                 /* Do not stop the IN pipe here to detect LSTTR interrupt */
1893                 if (!usb3_write_pipe(usb3_ep, usb3_req, USB3_PN_WRITE))
1894                         usb3_clear_bit(usb3, PN_INT_BFRDY, USB3_PN_INT_ENA);
1895         } else {
1896                 if (!usb3_read_pipe(usb3_ep, usb3_req, USB3_PN_READ))
1897                         done = true;
1898         }
1899
1900 out:
1901         /* need to unlock because usb3_request_done_pipen() locks it */
1902         spin_unlock(&usb3->lock);
1903
1904         if (done)
1905                 usb3_request_done_pipen(usb3, usb3_ep, usb3_req, 0);
1906 }
1907
1908 static void usb3_irq_epc_pipen(struct renesas_usb3 *usb3, int num)
1909 {
1910         u32 pn_int_sta;
1911
1912         spin_lock(&usb3->lock);
1913         if (usb3_pn_change(usb3, num) < 0) {
1914                 spin_unlock(&usb3->lock);
1915                 return;
1916         }
1917
1918         pn_int_sta = usb3_read(usb3, USB3_PN_INT_STA);
1919         pn_int_sta &= usb3_read(usb3, USB3_PN_INT_ENA);
1920         usb3_write(usb3, pn_int_sta, USB3_PN_INT_STA);
1921         spin_unlock(&usb3->lock);
1922         if (pn_int_sta & PN_INT_LSTTR)
1923                 usb3_irq_epc_pipen_lsttr(usb3, num);
1924         if (pn_int_sta & PN_INT_BFRDY)
1925                 usb3_irq_epc_pipen_bfrdy(usb3, num);
1926 }
1927
1928 static void usb3_irq_epc_int_2(struct renesas_usb3 *usb3, u32 int_sta_2)
1929 {
1930         int i;
1931
1932         for (i = 0; i < usb3->num_usb3_eps; i++) {
1933                 if (int_sta_2 & USB_INT_2_PIPE(i)) {
1934                         if (!i)
1935                                 usb3_irq_epc_pipe0(usb3);
1936                         else
1937                                 usb3_irq_epc_pipen(usb3, i);
1938                 }
1939         }
1940 }
1941
1942 static void usb3_irq_idmon_change(struct renesas_usb3 *usb3)
1943 {
1944         usb3_check_id(usb3);
1945 }
1946
1947 static void usb3_irq_otg_int(struct renesas_usb3 *usb3, u32 otg_int_sta)
1948 {
1949         if (otg_int_sta & USB_OTG_IDMON)
1950                 usb3_irq_idmon_change(usb3);
1951 }
1952
1953 static void usb3_irq_epc(struct renesas_usb3 *usb3)
1954 {
1955         u32 int_sta_1 = usb3_read(usb3, USB3_USB_INT_STA_1);
1956         u32 int_sta_2 = usb3_read(usb3, USB3_USB_INT_STA_2);
1957         u32 otg_int_sta = usb3_read(usb3, USB3_USB_OTG_INT_STA);
1958
1959         int_sta_1 &= usb3_read(usb3, USB3_USB_INT_ENA_1);
1960         if (int_sta_1) {
1961                 usb3_write(usb3, int_sta_1, USB3_USB_INT_STA_1);
1962                 usb3_irq_epc_int_1(usb3, int_sta_1);
1963         }
1964
1965         int_sta_2 &= usb3_read(usb3, USB3_USB_INT_ENA_2);
1966         if (int_sta_2)
1967                 usb3_irq_epc_int_2(usb3, int_sta_2);
1968
1969         otg_int_sta &= usb3_read(usb3, USB3_USB_OTG_INT_ENA);
1970         if (otg_int_sta) {
1971                 usb3_write(usb3, otg_int_sta, USB3_USB_OTG_INT_STA);
1972                 usb3_irq_otg_int(usb3, otg_int_sta);
1973         }
1974 }
1975
1976 static void usb3_irq_dma_int(struct renesas_usb3 *usb3, u32 dma_sta)
1977 {
1978         struct renesas_usb3_ep *usb3_ep;
1979         struct renesas_usb3_request *usb3_req;
1980         int i, status;
1981
1982         for (i = 0; i < usb3->num_usb3_eps; i++) {
1983                 if (!(dma_sta & DMA_INT(i)))
1984                         continue;
1985
1986                 usb3_ep = usb3_get_ep(usb3, i);
1987                 if (!(usb3_read(usb3, USB3_AXI_INT_STA) &
1988                     AXI_INT_PRDEN_CLR_STA(usb3_ep->dma->num)))
1989                         continue;
1990
1991                 usb3_req = usb3_get_request(usb3_ep);
1992                 status = usb3_dma_try_stop(usb3_ep, usb3_req);
1993                 usb3_request_done_pipen(usb3, usb3_ep, usb3_req, status);
1994         }
1995 }
1996
1997 static void usb3_irq_dma(struct renesas_usb3 *usb3)
1998 {
1999         u32 dma_sta = usb3_read(usb3, USB3_DMA_INT_STA);
2000
2001         dma_sta &= usb3_read(usb3, USB3_DMA_INT_ENA);
2002         if (dma_sta) {
2003                 usb3_write(usb3, dma_sta, USB3_DMA_INT_STA);
2004                 usb3_irq_dma_int(usb3, dma_sta);
2005         }
2006 }
2007
2008 static irqreturn_t renesas_usb3_irq(int irq, void *_usb3)
2009 {
2010         struct renesas_usb3 *usb3 = _usb3;
2011         irqreturn_t ret = IRQ_NONE;
2012         u32 axi_int_sta = usb3_read(usb3, USB3_AXI_INT_STA);
2013
2014         if (axi_int_sta & AXI_INT_DMAINT) {
2015                 usb3_irq_dma(usb3);
2016                 ret = IRQ_HANDLED;
2017         }
2018
2019         if (axi_int_sta & AXI_INT_EPCINT) {
2020                 usb3_irq_epc(usb3);
2021                 ret = IRQ_HANDLED;
2022         }
2023
2024         return ret;
2025 }
2026
2027 static void usb3_write_pn_mod(struct renesas_usb3_ep *usb3_ep,
2028                               const struct usb_endpoint_descriptor *desc)
2029 {
2030         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
2031         u32 val = 0;
2032
2033         val |= usb3_ep->dir_in ? PN_MOD_DIR : 0;
2034         val |= PN_MOD_TYPE(usb_endpoint_type(desc));
2035         val |= PN_MOD_EPNUM(usb_endpoint_num(desc));
2036         usb3_write(usb3, val, USB3_PN_MOD);
2037 }
2038
2039 static u32 usb3_calc_ramarea(int ram_size)
2040 {
2041         WARN_ON(ram_size > SZ_16K);
2042
2043         if (ram_size <= SZ_1K)
2044                 return PN_RAMMAP_RAMAREA_1KB;
2045         else if (ram_size <= SZ_2K)
2046                 return PN_RAMMAP_RAMAREA_2KB;
2047         else if (ram_size <= SZ_4K)
2048                 return PN_RAMMAP_RAMAREA_4KB;
2049         else if (ram_size <= SZ_8K)
2050                 return PN_RAMMAP_RAMAREA_8KB;
2051         else
2052                 return PN_RAMMAP_RAMAREA_16KB;
2053 }
2054
2055 static u32 usb3_calc_rammap_val(struct renesas_usb3_ep *usb3_ep,
2056                                 const struct usb_endpoint_descriptor *desc)
2057 {
2058         int i;
2059         const u32 max_packet_array[] = {8, 16, 32, 64, 512};
2060         u32 mpkt = PN_RAMMAP_MPKT(1024);
2061
2062         for (i = 0; i < ARRAY_SIZE(max_packet_array); i++) {
2063                 if (usb_endpoint_maxp(desc) <= max_packet_array[i])
2064                         mpkt = PN_RAMMAP_MPKT(max_packet_array[i]);
2065         }
2066
2067         return usb3_ep->rammap_val | mpkt;
2068 }
2069
2070 static int usb3_enable_pipe_n(struct renesas_usb3_ep *usb3_ep,
2071                               const struct usb_endpoint_descriptor *desc)
2072 {
2073         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
2074         unsigned long flags;
2075
2076         usb3_ep->dir_in = usb_endpoint_dir_in(desc);
2077
2078         spin_lock_irqsave(&usb3->lock, flags);
2079         if (!usb3_pn_change(usb3, usb3_ep->num)) {
2080                 usb3_write_pn_mod(usb3_ep, desc);
2081                 usb3_write(usb3, usb3_calc_rammap_val(usb3_ep, desc),
2082                            USB3_PN_RAMMAP);
2083                 usb3_pn_con_clear(usb3);
2084                 usb3_set_bit(usb3, PN_CON_EN, USB3_PN_CON);
2085         }
2086         spin_unlock_irqrestore(&usb3->lock, flags);
2087
2088         return 0;
2089 }
2090
2091 static int usb3_disable_pipe_n(struct renesas_usb3_ep *usb3_ep)
2092 {
2093         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
2094         unsigned long flags;
2095
2096         usb3_ep->halt = false;
2097
2098         spin_lock_irqsave(&usb3->lock, flags);
2099         if (!usb3_pn_change(usb3, usb3_ep->num)) {
2100                 usb3_write(usb3, 0, USB3_PN_INT_ENA);
2101                 usb3_write(usb3, 0, USB3_PN_RAMMAP);
2102                 usb3_clear_bit(usb3, PN_CON_EN, USB3_PN_CON);
2103         }
2104         spin_unlock_irqrestore(&usb3->lock, flags);
2105
2106         return 0;
2107 }
2108
2109 /*------- usb_ep_ops -----------------------------------------------------*/
2110 static int renesas_usb3_ep_enable(struct usb_ep *_ep,
2111                                   const struct usb_endpoint_descriptor *desc)
2112 {
2113         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
2114
2115         return usb3_enable_pipe_n(usb3_ep, desc);
2116 }
2117
2118 static int renesas_usb3_ep_disable(struct usb_ep *_ep)
2119 {
2120         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
2121         struct renesas_usb3_request *usb3_req;
2122
2123         do {
2124                 usb3_req = usb3_get_request(usb3_ep);
2125                 if (!usb3_req)
2126                         break;
2127                 usb3_dma_try_stop(usb3_ep, usb3_req);
2128                 usb3_request_done(usb3_ep, usb3_req, -ESHUTDOWN);
2129         } while (1);
2130
2131         return usb3_disable_pipe_n(usb3_ep);
2132 }
2133
2134 static struct usb_request *__renesas_usb3_ep_alloc_request(gfp_t gfp_flags)
2135 {
2136         struct renesas_usb3_request *usb3_req;
2137
2138         usb3_req = kzalloc(sizeof(struct renesas_usb3_request), gfp_flags);
2139         if (!usb3_req)
2140                 return NULL;
2141
2142         INIT_LIST_HEAD(&usb3_req->queue);
2143
2144         return &usb3_req->req;
2145 }
2146
2147 static void __renesas_usb3_ep_free_request(struct usb_request *_req)
2148 {
2149         struct renesas_usb3_request *usb3_req = usb_req_to_usb3_req(_req);
2150
2151         kfree(usb3_req);
2152 }
2153
2154 static struct usb_request *renesas_usb3_ep_alloc_request(struct usb_ep *_ep,
2155                                                          gfp_t gfp_flags)
2156 {
2157         return __renesas_usb3_ep_alloc_request(gfp_flags);
2158 }
2159
2160 static void renesas_usb3_ep_free_request(struct usb_ep *_ep,
2161                                          struct usb_request *_req)
2162 {
2163         __renesas_usb3_ep_free_request(_req);
2164 }
2165
2166 static int renesas_usb3_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
2167 {
2168         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
2169         struct renesas_usb3_request *usb3_req = usb_req_to_usb3_req(_req);
2170         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
2171
2172         dev_dbg(usb3_to_dev(usb3), "ep_dequeue: ep%2d, %u\n", usb3_ep->num,
2173                 _req->length);
2174
2175         usb3_dma_try_stop(usb3_ep, usb3_req);
2176         usb3_request_done_pipen(usb3, usb3_ep, usb3_req, -ECONNRESET);
2177
2178         return 0;
2179 }
2180
2181 static int renesas_usb3_ep_set_halt(struct usb_ep *_ep, int value)
2182 {
2183         return usb3_set_halt(usb_ep_to_usb3_ep(_ep), !!value, false);
2184 }
2185
2186 static int renesas_usb3_ep_set_wedge(struct usb_ep *_ep)
2187 {
2188         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
2189
2190         usb3_ep->wedge = true;
2191         return usb3_set_halt(usb3_ep, true, false);
2192 }
2193
2194 static void renesas_usb3_ep_fifo_flush(struct usb_ep *_ep)
2195 {
2196         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
2197         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
2198         unsigned long flags;
2199
2200         if (usb3_ep->num) {
2201                 spin_lock_irqsave(&usb3->lock, flags);
2202                 if (!usb3_pn_change(usb3, usb3_ep->num)) {
2203                         usb3_pn_con_clear(usb3);
2204                         usb3_set_bit(usb3, PN_CON_EN, USB3_PN_CON);
2205                 }
2206                 spin_unlock_irqrestore(&usb3->lock, flags);
2207         } else {
2208                 usb3_p0_con_clear_buffer(usb3);
2209         }
2210 }
2211
2212 static const struct usb_ep_ops renesas_usb3_ep_ops = {
2213         .enable         = renesas_usb3_ep_enable,
2214         .disable        = renesas_usb3_ep_disable,
2215
2216         .alloc_request  = renesas_usb3_ep_alloc_request,
2217         .free_request   = renesas_usb3_ep_free_request,
2218
2219         .queue          = renesas_usb3_ep_queue,
2220         .dequeue        = renesas_usb3_ep_dequeue,
2221
2222         .set_halt       = renesas_usb3_ep_set_halt,
2223         .set_wedge      = renesas_usb3_ep_set_wedge,
2224         .fifo_flush     = renesas_usb3_ep_fifo_flush,
2225 };
2226
2227 /*------- usb_gadget_ops -------------------------------------------------*/
2228 static int renesas_usb3_start(struct usb_gadget *gadget,
2229                               struct usb_gadget_driver *driver)
2230 {
2231         struct renesas_usb3 *usb3;
2232
2233         if (!driver || driver->max_speed < USB_SPEED_FULL ||
2234             !driver->setup)
2235                 return -EINVAL;
2236
2237         usb3 = gadget_to_renesas_usb3(gadget);
2238
2239         /* hook up the driver */
2240         usb3->driver = driver;
2241
2242         pm_runtime_enable(usb3_to_dev(usb3));
2243         pm_runtime_get_sync(usb3_to_dev(usb3));
2244
2245         renesas_usb3_init_controller(usb3);
2246
2247         return 0;
2248 }
2249
2250 static int renesas_usb3_stop(struct usb_gadget *gadget)
2251 {
2252         struct renesas_usb3 *usb3 = gadget_to_renesas_usb3(gadget);
2253
2254         usb3->softconnect = false;
2255         usb3->gadget.speed = USB_SPEED_UNKNOWN;
2256         usb3->driver = NULL;
2257         renesas_usb3_stop_controller(usb3);
2258
2259         pm_runtime_put(usb3_to_dev(usb3));
2260         pm_runtime_disable(usb3_to_dev(usb3));
2261
2262         return 0;
2263 }
2264
2265 static int renesas_usb3_get_frame(struct usb_gadget *_gadget)
2266 {
2267         return -EOPNOTSUPP;
2268 }
2269
2270 static int renesas_usb3_pullup(struct usb_gadget *gadget, int is_on)
2271 {
2272         struct renesas_usb3 *usb3 = gadget_to_renesas_usb3(gadget);
2273
2274         usb3->softconnect = !!is_on;
2275
2276         return 0;
2277 }
2278
2279 static int renesas_usb3_set_selfpowered(struct usb_gadget *gadget, int is_self)
2280 {
2281         gadget->is_selfpowered = !!is_self;
2282
2283         return 0;
2284 }
2285
2286 static const struct usb_gadget_ops renesas_usb3_gadget_ops = {
2287         .get_frame              = renesas_usb3_get_frame,
2288         .udc_start              = renesas_usb3_start,
2289         .udc_stop               = renesas_usb3_stop,
2290         .pullup                 = renesas_usb3_pullup,
2291         .set_selfpowered        = renesas_usb3_set_selfpowered,
2292 };
2293
2294 static ssize_t role_store(struct device *dev, struct device_attribute *attr,
2295                           const char *buf, size_t count)
2296 {
2297         struct renesas_usb3 *usb3 = dev_get_drvdata(dev);
2298         bool new_mode_is_host;
2299
2300         if (!usb3->driver)
2301                 return -ENODEV;
2302
2303         if (usb3->forced_b_device)
2304                 return -EBUSY;
2305
2306         if (!strncmp(buf, "host", strlen("host")))
2307                 new_mode_is_host = true;
2308         else if (!strncmp(buf, "peripheral", strlen("peripheral")))
2309                 new_mode_is_host = false;
2310         else
2311                 return -EINVAL;
2312
2313         if (new_mode_is_host == usb3_is_host(usb3))
2314                 return -EINVAL;
2315
2316         usb3_mode_config(usb3, new_mode_is_host, usb3_is_a_device(usb3));
2317
2318         return count;
2319 }
2320
2321 static ssize_t role_show(struct device *dev, struct device_attribute *attr,
2322                          char *buf)
2323 {
2324         struct renesas_usb3 *usb3 = dev_get_drvdata(dev);
2325
2326         if (!usb3->driver)
2327                 return -ENODEV;
2328
2329         return sprintf(buf, "%s\n", usb3_is_host(usb3) ? "host" : "peripheral");
2330 }
2331 static DEVICE_ATTR_RW(role);
2332
2333 static int renesas_usb3_b_device_show(struct seq_file *s, void *unused)
2334 {
2335         struct renesas_usb3 *usb3 = s->private;
2336
2337         seq_printf(s, "%d\n", usb3->forced_b_device);
2338
2339         return 0;
2340 }
2341
2342 static int renesas_usb3_b_device_open(struct inode *inode, struct file *file)
2343 {
2344         return single_open(file, renesas_usb3_b_device_show, inode->i_private);
2345 }
2346
2347 static ssize_t renesas_usb3_b_device_write(struct file *file,
2348                                            const char __user *ubuf,
2349                                            size_t count, loff_t *ppos)
2350 {
2351         struct seq_file *s = file->private_data;
2352         struct renesas_usb3 *usb3 = s->private;
2353         char buf[32];
2354
2355         if (!usb3->driver)
2356                 return -ENODEV;
2357
2358         if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
2359                 return -EFAULT;
2360
2361         if (!strncmp(buf, "1", 1))
2362                 usb3->forced_b_device = true;
2363         else
2364                 usb3->forced_b_device = false;
2365
2366         /* Let this driver call usb3_connect() anyway */
2367         usb3_check_id(usb3);
2368
2369         return count;
2370 }
2371
2372 static const struct file_operations renesas_usb3_b_device_fops = {
2373         .open = renesas_usb3_b_device_open,
2374         .write = renesas_usb3_b_device_write,
2375         .read = seq_read,
2376         .llseek = seq_lseek,
2377         .release = single_release,
2378 };
2379
2380 static void renesas_usb3_debugfs_init(struct renesas_usb3 *usb3,
2381                                       struct device *dev)
2382 {
2383         struct dentry *root, *file;
2384
2385         root = debugfs_create_dir(dev_name(dev), NULL);
2386         if (IS_ERR_OR_NULL(root)) {
2387                 dev_info(dev, "%s: Can't create the root\n", __func__);
2388                 return;
2389         }
2390
2391         file = debugfs_create_file("b_device", 0644, root, usb3,
2392                                    &renesas_usb3_b_device_fops);
2393         if (!file)
2394                 dev_info(dev, "%s: Can't create debugfs mode\n", __func__);
2395 }
2396
2397 /*------- platform_driver ------------------------------------------------*/
2398 static int renesas_usb3_remove(struct platform_device *pdev)
2399 {
2400         struct renesas_usb3 *usb3 = platform_get_drvdata(pdev);
2401
2402         device_remove_file(&pdev->dev, &dev_attr_role);
2403
2404         usb_del_gadget_udc(&usb3->gadget);
2405         renesas_usb3_dma_free_prd(usb3, &pdev->dev);
2406
2407         __renesas_usb3_ep_free_request(usb3->ep0_req);
2408
2409         return 0;
2410 }
2411
2412 static int renesas_usb3_init_ep(struct renesas_usb3 *usb3, struct device *dev,
2413                                 const struct renesas_usb3_priv *priv)
2414 {
2415         struct renesas_usb3_ep *usb3_ep;
2416         int i;
2417
2418         /* calculate num_usb3_eps from renesas_usb3_priv */
2419         usb3->num_usb3_eps = priv->ramsize_per_ramif * priv->num_ramif * 2 /
2420                              priv->ramsize_per_pipe + 1;
2421
2422         if (usb3->num_usb3_eps > USB3_MAX_NUM_PIPES)
2423                 usb3->num_usb3_eps = USB3_MAX_NUM_PIPES;
2424
2425         usb3->usb3_ep = devm_kzalloc(dev, sizeof(*usb3_ep) * usb3->num_usb3_eps,
2426                                      GFP_KERNEL);
2427         if (!usb3->usb3_ep)
2428                 return -ENOMEM;
2429
2430         dev_dbg(dev, "%s: num_usb3_eps = %d\n", __func__, usb3->num_usb3_eps);
2431         /*
2432          * This driver prepares pipes as follows:
2433          *  - odd pipes = IN pipe
2434          *  - even pipes = OUT pipe (except pipe 0)
2435          */
2436         usb3_for_each_ep(usb3_ep, usb3, i) {
2437                 snprintf(usb3_ep->ep_name, sizeof(usb3_ep->ep_name), "ep%d", i);
2438                 usb3_ep->usb3 = usb3;
2439                 usb3_ep->num = i;
2440                 usb3_ep->ep.name = usb3_ep->ep_name;
2441                 usb3_ep->ep.ops = &renesas_usb3_ep_ops;
2442                 INIT_LIST_HEAD(&usb3_ep->queue);
2443                 INIT_LIST_HEAD(&usb3_ep->ep.ep_list);
2444                 if (!i) {
2445                         /* for control pipe */
2446                         usb3->gadget.ep0 = &usb3_ep->ep;
2447                         usb_ep_set_maxpacket_limit(&usb3_ep->ep,
2448                                                 USB3_EP0_HSFS_MAX_PACKET_SIZE);
2449                         usb3_ep->ep.caps.type_control = true;
2450                         usb3_ep->ep.caps.dir_in = true;
2451                         usb3_ep->ep.caps.dir_out = true;
2452                         continue;
2453                 }
2454
2455                 /* for bulk or interrupt pipe */
2456                 usb_ep_set_maxpacket_limit(&usb3_ep->ep, ~0);
2457                 list_add_tail(&usb3_ep->ep.ep_list, &usb3->gadget.ep_list);
2458                 usb3_ep->ep.caps.type_bulk = true;
2459                 usb3_ep->ep.caps.type_int = true;
2460                 if (i & 1)
2461                         usb3_ep->ep.caps.dir_in = true;
2462                 else
2463                         usb3_ep->ep.caps.dir_out = true;
2464         }
2465
2466         return 0;
2467 }
2468
2469 static void renesas_usb3_init_ram(struct renesas_usb3 *usb3, struct device *dev,
2470                                   const struct renesas_usb3_priv *priv)
2471 {
2472         struct renesas_usb3_ep *usb3_ep;
2473         int i;
2474         u32 ramif[2], basead[2];        /* index 0 = for IN pipes */
2475         u32 *cur_ramif, *cur_basead;
2476         u32 val;
2477
2478         memset(ramif, 0, sizeof(ramif));
2479         memset(basead, 0, sizeof(basead));
2480
2481         /*
2482          * This driver prepares pipes as follows:
2483          *  - all pipes = the same size as "ramsize_per_pipe"
2484          * Please refer to the "Method of Specifying RAM Mapping"
2485          */
2486         usb3_for_each_ep(usb3_ep, usb3, i) {
2487                 if (!i)
2488                         continue;       /* out of scope if ep num = 0 */
2489                 if (usb3_ep->ep.caps.dir_in) {
2490                         cur_ramif = &ramif[0];
2491                         cur_basead = &basead[0];
2492                 } else {
2493                         cur_ramif = &ramif[1];
2494                         cur_basead = &basead[1];
2495                 }
2496
2497                 if (*cur_basead > priv->ramsize_per_ramif)
2498                         continue;       /* out of memory for IN or OUT pipe */
2499
2500                 /* calculate rammap_val */
2501                 val = PN_RAMMAP_RAMIF(*cur_ramif);
2502                 val |= usb3_calc_ramarea(priv->ramsize_per_pipe);
2503                 val |= PN_RAMMAP_BASEAD(*cur_basead);
2504                 usb3_ep->rammap_val = val;
2505
2506                 dev_dbg(dev, "ep%2d: val = %08x, ramif = %d, base = %x\n",
2507                         i, val, *cur_ramif, *cur_basead);
2508
2509                 /* update current ramif */
2510                 if (*cur_ramif + 1 == priv->num_ramif) {
2511                         *cur_ramif = 0;
2512                         *cur_basead += priv->ramsize_per_pipe;
2513                 } else {
2514                         (*cur_ramif)++;
2515                 }
2516         }
2517 }
2518
2519 static const struct renesas_usb3_priv renesas_usb3_priv_r8a7795_es1 = {
2520         .ramsize_per_ramif = SZ_16K,
2521         .num_ramif = 2,
2522         .ramsize_per_pipe = SZ_4K,
2523         .workaround_for_vbus = true,
2524 };
2525
2526 static const struct renesas_usb3_priv renesas_usb3_priv_gen3 = {
2527         .ramsize_per_ramif = SZ_16K,
2528         .num_ramif = 4,
2529         .ramsize_per_pipe = SZ_4K,
2530 };
2531
2532 static const struct of_device_id usb3_of_match[] = {
2533         {
2534                 .compatible = "renesas,r8a7795-usb3-peri",
2535                 .data = &renesas_usb3_priv_gen3,
2536         },
2537         {
2538                 .compatible = "renesas,rcar-gen3-usb3-peri",
2539                 .data = &renesas_usb3_priv_gen3,
2540         },
2541         { },
2542 };
2543 MODULE_DEVICE_TABLE(of, usb3_of_match);
2544
2545 static const struct soc_device_attribute renesas_usb3_quirks_match[] = {
2546         {
2547                 .soc_id = "r8a7795", .revision = "ES1.*",
2548                 .data = &renesas_usb3_priv_r8a7795_es1,
2549         },
2550         { /* sentinel */ },
2551 };
2552
2553 static const unsigned int renesas_usb3_cable[] = {
2554         EXTCON_USB,
2555         EXTCON_USB_HOST,
2556         EXTCON_NONE,
2557 };
2558
2559 static int renesas_usb3_probe(struct platform_device *pdev)
2560 {
2561         struct renesas_usb3 *usb3;
2562         struct resource *res;
2563         const struct of_device_id *match;
2564         int irq, ret;
2565         const struct renesas_usb3_priv *priv;
2566         const struct soc_device_attribute *attr;
2567
2568         match = of_match_node(usb3_of_match, pdev->dev.of_node);
2569         if (!match)
2570                 return -ENODEV;
2571
2572         attr = soc_device_match(renesas_usb3_quirks_match);
2573         if (attr)
2574                 priv = attr->data;
2575         else
2576                 priv = match->data;
2577
2578         irq = platform_get_irq(pdev, 0);
2579         if (irq < 0) {
2580                 dev_err(&pdev->dev, "Failed to get IRQ: %d\n", irq);
2581                 return irq;
2582         }
2583
2584         usb3 = devm_kzalloc(&pdev->dev, sizeof(*usb3), GFP_KERNEL);
2585         if (!usb3)
2586                 return -ENOMEM;
2587
2588         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2589         usb3->reg = devm_ioremap_resource(&pdev->dev, res);
2590         if (IS_ERR(usb3->reg))
2591                 return PTR_ERR(usb3->reg);
2592
2593         platform_set_drvdata(pdev, usb3);
2594         spin_lock_init(&usb3->lock);
2595
2596         usb3->gadget.ops = &renesas_usb3_gadget_ops;
2597         usb3->gadget.name = udc_name;
2598         usb3->gadget.max_speed = USB_SPEED_SUPER;
2599         INIT_LIST_HEAD(&usb3->gadget.ep_list);
2600         ret = renesas_usb3_init_ep(usb3, &pdev->dev, priv);
2601         if (ret < 0)
2602                 return ret;
2603         renesas_usb3_init_ram(usb3, &pdev->dev, priv);
2604
2605         ret = devm_request_irq(&pdev->dev, irq, renesas_usb3_irq, 0,
2606                                dev_name(&pdev->dev), usb3);
2607         if (ret < 0)
2608                 return ret;
2609
2610         INIT_WORK(&usb3->extcon_work, renesas_usb3_extcon_work);
2611         usb3->extcon = devm_extcon_dev_allocate(&pdev->dev, renesas_usb3_cable);
2612         if (IS_ERR(usb3->extcon))
2613                 return PTR_ERR(usb3->extcon);
2614
2615         ret = devm_extcon_dev_register(&pdev->dev, usb3->extcon);
2616         if (ret < 0) {
2617                 dev_err(&pdev->dev, "Failed to register extcon\n");
2618                 return ret;
2619         }
2620
2621         /* for ep0 handling */
2622         usb3->ep0_req = __renesas_usb3_ep_alloc_request(GFP_KERNEL);
2623         if (!usb3->ep0_req)
2624                 return -ENOMEM;
2625
2626         ret = renesas_usb3_dma_alloc_prd(usb3, &pdev->dev);
2627         if (ret < 0)
2628                 goto err_alloc_prd;
2629
2630         ret = usb_add_gadget_udc(&pdev->dev, &usb3->gadget);
2631         if (ret < 0)
2632                 goto err_add_udc;
2633
2634         ret = device_create_file(&pdev->dev, &dev_attr_role);
2635         if (ret < 0)
2636                 goto err_dev_create;
2637
2638         usb3->workaround_for_vbus = priv->workaround_for_vbus;
2639
2640         renesas_usb3_debugfs_init(usb3, &pdev->dev);
2641
2642         dev_info(&pdev->dev, "probed\n");
2643
2644         return 0;
2645
2646 err_dev_create:
2647         usb_del_gadget_udc(&usb3->gadget);
2648
2649 err_add_udc:
2650         renesas_usb3_dma_free_prd(usb3, &pdev->dev);
2651
2652 err_alloc_prd:
2653         __renesas_usb3_ep_free_request(usb3->ep0_req);
2654
2655         return ret;
2656 }
2657
2658 static struct platform_driver renesas_usb3_driver = {
2659         .probe          = renesas_usb3_probe,
2660         .remove         = renesas_usb3_remove,
2661         .driver         = {
2662                 .name = (char *)udc_name,
2663                 .of_match_table = of_match_ptr(usb3_of_match),
2664         },
2665 };
2666 module_platform_driver(renesas_usb3_driver);
2667
2668 MODULE_DESCRIPTION("Renesas USB3.0 Peripheral driver");
2669 MODULE_LICENSE("GPL v2");
2670 MODULE_AUTHOR("Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>");
2671 MODULE_ALIAS("platform:renesas_usb3");