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/delay.h>
  12 #include <linux/err.h>
  13 #include <linux/extcon.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/io.h>
  16 #include <linux/module.h>
  17 #include <linux/of_device.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/pm_runtime.h>
  20 #include <linux/sizes.h>
  21 #include <linux/slab.h>
  22 #include <linux/usb/ch9.h>
  23 #include <linux/usb/gadget.h>
  24
  25 /* register definitions */
  26 #define USB3_AXI_INT_STA        0x008
  27 #define USB3_AXI_INT_ENA        0x00c
  28 #define USB3_DMA_INT_STA        0x010
  29 #define USB3_DMA_INT_ENA        0x014
  30 #define USB3_USB_COM_CON        0x200
  31 #define USB3_USB20_CON          0x204
  32 #define USB3_USB30_CON          0x208
  33 #define USB3_USB_STA            0x210
  34 #define USB3_DRD_CON            0x218
  35 #define USB3_USB_INT_STA_1      0x220
  36 #define USB3_USB_INT_STA_2      0x224
  37 #define USB3_USB_INT_ENA_1      0x228
  38 #define USB3_USB_INT_ENA_2      0x22c
  39 #define USB3_STUP_DAT_0         0x230
  40 #define USB3_STUP_DAT_1         0x234
  41 #define USB3_USB_OTG_STA        0x268
  42 #define USB3_USB_OTG_INT_STA    0x26c
  43 #define USB3_USB_OTG_INT_ENA    0x270
  44 #define USB3_P0_MOD             0x280
  45 #define USB3_P0_CON             0x288
  46 #define USB3_P0_STA             0x28c
  47 #define USB3_P0_INT_STA         0x290
  48 #define USB3_P0_INT_ENA         0x294
  49 #define USB3_P0_LNG             0x2a0
  50 #define USB3_P0_READ            0x2a4
  51 #define USB3_P0_WRITE           0x2a8
  52 #define USB3_PIPE_COM           0x2b0
  53 #define USB3_PN_MOD             0x2c0
  54 #define USB3_PN_RAMMAP          0x2c4
  55 #define USB3_PN_CON             0x2c8
  56 #define USB3_PN_STA             0x2cc
  57 #define USB3_PN_INT_STA         0x2d0
  58 #define USB3_PN_INT_ENA         0x2d4
  59 #define USB3_PN_LNG             0x2e0
  60 #define USB3_PN_READ            0x2e4
  61 #define USB3_PN_WRITE           0x2e8
  62 #define USB3_SSIFCMD            0x340
  63
  64 /* AXI_INT_ENA and AXI_INT_STA */
  65 #define AXI_INT_DMAINT          BIT(31)
  66 #define AXI_INT_EPCINT          BIT(30)
  67
  68 /* LCLKSEL */
  69 #define LCLKSEL_LSEL            BIT(18)
  70
  71 /* USB_COM_CON */
  72 #define USB_COM_CON_CONF                BIT(24)
  73 #define USB_COM_CON_SPD_MODE            BIT(17)
  74 #define USB_COM_CON_EP0_EN              BIT(16)
  75 #define USB_COM_CON_DEV_ADDR_SHIFT      8
  76 #define USB_COM_CON_DEV_ADDR_MASK       GENMASK(14, USB_COM_CON_DEV_ADDR_SHIFT)
  77 #define USB_COM_CON_DEV_ADDR(n)         (((n) << USB_COM_CON_DEV_ADDR_SHIFT) & \
  78                                          USB_COM_CON_DEV_ADDR_MASK)
  79 #define USB_COM_CON_RX_DETECTION        BIT(1)
  80 #define USB_COM_CON_PIPE_CLR            BIT(0)
  81
  82 /* USB20_CON */
  83 #define USB20_CON_B2_PUE                BIT(31)
  84 #define USB20_CON_B2_SUSPEND            BIT(24)
  85 #define USB20_CON_B2_CONNECT            BIT(17)
  86 #define USB20_CON_B2_TSTMOD_SHIFT       8
  87 #define USB20_CON_B2_TSTMOD_MASK        GENMASK(10, USB20_CON_B2_TSTMOD_SHIFT)
  88 #define USB20_CON_B2_TSTMOD(n)          (((n) << USB20_CON_B2_TSTMOD_SHIFT) & \
  89                                          USB20_CON_B2_TSTMOD_MASK)
  90 #define USB20_CON_B2_TSTMOD_EN          BIT(0)
  91
  92 /* USB30_CON */
  93 #define USB30_CON_POW_SEL_SHIFT         24
  94 #define USB30_CON_POW_SEL_MASK          GENMASK(26, USB30_CON_POW_SEL_SHIFT)
  95 #define USB30_CON_POW_SEL_IN_U3         BIT(26)
  96 #define USB30_CON_POW_SEL_IN_DISCON     0
  97 #define USB30_CON_POW_SEL_P2_TO_P0      BIT(25)
  98 #define USB30_CON_POW_SEL_P0_TO_P3      BIT(24)
  99 #define USB30_CON_POW_SEL_P0_TO_P2      0
 100 #define USB30_CON_B3_PLLWAKE            BIT(23)
 101 #define USB30_CON_B3_CONNECT            BIT(17)
 102 #define USB30_CON_B3_HOTRST_CMP         BIT(1)
 103
 104 /* USB_STA */
 105 #define USB_STA_SPEED_MASK      (BIT(2) | BIT(1))
 106 #define USB_STA_SPEED_HS        BIT(2)
 107 #define USB_STA_SPEED_FS        BIT(1)
 108 #define USB_STA_SPEED_SS        0
 109 #define USB_STA_VBUS_STA        BIT(0)
 110
 111 /* DRD_CON */
 112 #define DRD_CON_PERI_CON        BIT(24)
 113 #define DRD_CON_VBOUT           BIT(0)
 114
 115 /* USB_INT_ENA_1 and USB_INT_STA_1 */
 116 #define USB_INT_1_B3_PLLWKUP    BIT(31)
 117 #define USB_INT_1_B3_LUPSUCS    BIT(30)
 118 #define USB_INT_1_B3_DISABLE    BIT(27)
 119 #define USB_INT_1_B3_WRMRST     BIT(21)
 120 #define USB_INT_1_B3_HOTRST     BIT(20)
 121 #define USB_INT_1_B2_USBRST     BIT(12)
 122 #define USB_INT_1_B2_L1SPND     BIT(11)
 123 #define USB_INT_1_B2_SPND       BIT(9)
 124 #define USB_INT_1_B2_RSUM       BIT(8)
 125 #define USB_INT_1_SPEED         BIT(1)
 126 #define USB_INT_1_VBUS_CNG      BIT(0)
 127
 128 /* USB_INT_ENA_2 and USB_INT_STA_2 */
 129 #define USB_INT_2_PIPE(n)       BIT(n)
 130
 131 /* USB_OTG_STA, USB_OTG_INT_STA and USB_OTG_INT_ENA */
 132 #define USB_OTG_IDMON           BIT(4)
 133
 134 /* P0_MOD */
 135 #define P0_MOD_DIR              BIT(6)
 136
 137 /* P0_CON and PN_CON */
 138 #define PX_CON_BYTE_EN_MASK             (BIT(10) | BIT(9))
 139 #define PX_CON_BYTE_EN_SHIFT            9
 140 #define PX_CON_BYTE_EN_BYTES(n)         (((n) << PX_CON_BYTE_EN_SHIFT) & \
 141                                          PX_CON_BYTE_EN_MASK)
 142 #define PX_CON_SEND                     BIT(8)
 143
 144 /* P0_CON */
 145 #define P0_CON_ST_RES_MASK              (BIT(27) | BIT(26))
 146 #define P0_CON_ST_RES_FORCE_STALL       BIT(27)
 147 #define P0_CON_ST_RES_NORMAL            BIT(26)
 148 #define P0_CON_ST_RES_FORCE_NRDY        0
 149 #define P0_CON_OT_RES_MASK              (BIT(25) | BIT(24))
 150 #define P0_CON_OT_RES_FORCE_STALL       BIT(25)
 151 #define P0_CON_OT_RES_NORMAL            BIT(24)
 152 #define P0_CON_OT_RES_FORCE_NRDY        0
 153 #define P0_CON_IN_RES_MASK              (BIT(17) | BIT(16))
 154 #define P0_CON_IN_RES_FORCE_STALL       BIT(17)
 155 #define P0_CON_IN_RES_NORMAL            BIT(16)
 156 #define P0_CON_IN_RES_FORCE_NRDY        0
 157 #define P0_CON_RES_WEN                  BIT(7)
 158 #define P0_CON_BCLR                     BIT(1)
 159
 160 /* P0_STA and PN_STA */
 161 #define PX_STA_BUFSTS           BIT(0)
 162
 163 /* P0_INT_ENA and P0_INT_STA */
 164 #define P0_INT_STSED            BIT(18)
 165 #define P0_INT_STSST            BIT(17)
 166 #define P0_INT_SETUP            BIT(16)
 167 #define P0_INT_RCVNL            BIT(8)
 168 #define P0_INT_ERDY             BIT(7)
 169 #define P0_INT_FLOW             BIT(6)
 170 #define P0_INT_STALL            BIT(2)
 171 #define P0_INT_NRDY             BIT(1)
 172 #define P0_INT_BFRDY            BIT(0)
 173 #define P0_INT_ALL_BITS         (P0_INT_STSED | P0_INT_SETUP | P0_INT_BFRDY)
 174
 175 /* PN_MOD */
 176 #define PN_MOD_DIR              BIT(6)
 177 #define PN_MOD_TYPE_SHIFT       4
 178 #define PN_MOD_TYPE_MASK        GENMASK(5, PN_MOD_TYPE_SHIFT)
 179 #define PN_MOD_TYPE(n)          (((n) << PN_MOD_TYPE_SHIFT) & \
 180                                  PN_MOD_TYPE_MASK)
 181 #define PN_MOD_EPNUM_MASK       GENMASK(3, 0)
 182 #define PN_MOD_EPNUM(n)         ((n) & PN_MOD_EPNUM_MASK)
 183
 184 /* PN_RAMMAP */
 185 #define PN_RAMMAP_RAMAREA_SHIFT 29
 186 #define PN_RAMMAP_RAMAREA_MASK  GENMASK(31, PN_RAMMAP_RAMAREA_SHIFT)
 187 #define PN_RAMMAP_RAMAREA_16KB  BIT(31)
 188 #define PN_RAMMAP_RAMAREA_8KB   (BIT(30) | BIT(29))
 189 #define PN_RAMMAP_RAMAREA_4KB   BIT(30)
 190 #define PN_RAMMAP_RAMAREA_2KB   BIT(29)
 191 #define PN_RAMMAP_RAMAREA_1KB   0
 192 #define PN_RAMMAP_MPKT_SHIFT    16
 193 #define PN_RAMMAP_MPKT_MASK     GENMASK(26, PN_RAMMAP_MPKT_SHIFT)
 194 #define PN_RAMMAP_MPKT(n)       (((n) << PN_RAMMAP_MPKT_SHIFT) & \
 195                                  PN_RAMMAP_MPKT_MASK)
 196 #define PN_RAMMAP_RAMIF_SHIFT   14
 197 #define PN_RAMMAP_RAMIF_MASK    GENMASK(15, PN_RAMMAP_RAMIF_SHIFT)
 198 #define PN_RAMMAP_RAMIF(n)      (((n) << PN_RAMMAP_RAMIF_SHIFT) & \
 199                                  PN_RAMMAP_RAMIF_MASK)
 200 #define PN_RAMMAP_BASEAD_MASK   GENMASK(13, 0)
 201 #define PN_RAMMAP_BASEAD(offs)  (((offs) >> 3) & PN_RAMMAP_BASEAD_MASK)
 202 #define PN_RAMMAP_DATA(area, ramif, basead)     ((PN_RAMMAP_##area) | \
 203                                                  (PN_RAMMAP_RAMIF(ramif)) | \
 204                                                  (PN_RAMMAP_BASEAD(basead)))
 205
 206 /* PN_CON */
 207 #define PN_CON_EN               BIT(31)
 208 #define PN_CON_DATAIF_EN        BIT(30)
 209 #define PN_CON_RES_MASK         (BIT(17) | BIT(16))
 210 #define PN_CON_RES_FORCE_STALL  BIT(17)
 211 #define PN_CON_RES_NORMAL       BIT(16)
 212 #define PN_CON_RES_FORCE_NRDY   0
 213 #define PN_CON_LAST             BIT(11)
 214 #define PN_CON_RES_WEN          BIT(7)
 215 #define PN_CON_CLR              BIT(0)
 216
 217 /* PN_INT_STA and PN_INT_ENA */
 218 #define PN_INT_LSTTR    BIT(4)
 219 #define PN_INT_BFRDY    BIT(0)
 220
 221 /* USB3_SSIFCMD */
 222 #define SSIFCMD_URES_U2         BIT(9)
 223 #define SSIFCMD_URES_U1         BIT(8)
 224 #define SSIFCMD_UDIR_U2         BIT(7)
 225 #define SSIFCMD_UDIR_U1         BIT(6)
 226 #define SSIFCMD_UREQ_U2         BIT(5)
 227 #define SSIFCMD_UREQ_U1         BIT(4)
 228
 229 #define USB3_EP0_SS_MAX_PACKET_SIZE     512
 230 #define USB3_EP0_HSFS_MAX_PACKET_SIZE   64
 231 #define USB3_EP0_BUF_SIZE               8
 232 #define USB3_MAX_NUM_PIPES              30
 233 #define USB3_WAIT_US                    3
 234
 235 struct renesas_usb3;
 236 struct renesas_usb3_request {
 237         struct usb_request      req;
 238         struct list_head        queue;
 239 };
 240
 241 #define USB3_EP_NAME_SIZE       8
 242 struct renesas_usb3_ep {
 243         struct usb_ep ep;
 244         struct renesas_usb3 *usb3;
 245         int num;
 246         char ep_name[USB3_EP_NAME_SIZE];
 247         struct list_head queue;
 248         u32 rammap_val;
 249         bool dir_in;
 250         bool halt;
 251         bool wedge;
 252         bool started;
 253 };
 254
 255 struct renesas_usb3_priv {
 256         int ramsize_per_ramif;          /* unit = bytes */
 257         int num_ramif;
 258         int ramsize_per_pipe;           /* unit = bytes */
 259         bool workaround_for_vbus;       /* if true, don't check vbus signal */
 260 };
 261
 262 struct renesas_usb3 {
 263         void __iomem *reg;
 264
 265         struct usb_gadget gadget;
 266         struct usb_gadget_driver *driver;
 267         struct extcon_dev *extcon;
 268         struct work_struct extcon_work;
 269
 270         struct renesas_usb3_ep *usb3_ep;
 271         int num_usb3_eps;
 272
 273         spinlock_t lock;
 274         int disabled_count;
 275
 276         struct usb_request *ep0_req;
 277         u16 test_mode;
 278         u8 ep0_buf[USB3_EP0_BUF_SIZE];
 279         bool softconnect;
 280         bool workaround_for_vbus;
 281         bool extcon_host;               /* check id and set EXTCON_USB_HOST */
 282         bool extcon_usb;                /* check vbus and set EXTCON_USB */
 283 };
 284
 285 #define gadget_to_renesas_usb3(_gadget) \
 286                 container_of(_gadget, struct renesas_usb3, gadget)
 287 #define renesas_usb3_to_gadget(renesas_usb3) (&renesas_usb3->gadget)
 288 #define usb3_to_dev(_usb3)      (_usb3->gadget.dev.parent)
 289
 290 #define usb_ep_to_usb3_ep(_ep) container_of(_ep, struct renesas_usb3_ep, ep)
 291 #define usb3_ep_to_usb3(_usb3_ep) (_usb3_ep->usb3)
 292 #define usb_req_to_usb3_req(_req) container_of(_req, \
 293                                             struct renesas_usb3_request, req)
 294
 295 #define usb3_get_ep(usb3, n) ((usb3)->usb3_ep + (n))
 296 #define usb3_for_each_ep(usb3_ep, usb3, i)                      \
 297                 for ((i) = 0, usb3_ep = usb3_get_ep(usb3, (i)); \
 298                      (i) < (usb3)->num_usb3_eps;                \
 299                      (i)++, usb3_ep = usb3_get_ep(usb3, (i)))
 300
 301 static const char udc_name[] = "renesas_usb3";
 302
 303 static void usb3_write(struct renesas_usb3 *usb3, u32 data, u32 offs)
 304 {
 305         iowrite32(data, usb3->reg + offs);
 306 }
 307
 308 static u32 usb3_read(struct renesas_usb3 *usb3, u32 offs)
 309 {
 310         return ioread32(usb3->reg + offs);
 311 }
 312
 313 static void usb3_set_bit(struct renesas_usb3 *usb3, u32 bits, u32 offs)
 314 {
 315         u32 val = usb3_read(usb3, offs);
 316
 317         val |= bits;
 318         usb3_write(usb3, val, offs);
 319 }
 320
 321 static void usb3_clear_bit(struct renesas_usb3 *usb3, u32 bits, u32 offs)
 322 {
 323         u32 val = usb3_read(usb3, offs);
 324
 325         val &= ~bits;
 326         usb3_write(usb3, val, offs);
 327 }
 328
 329 static int usb3_wait(struct renesas_usb3 *usb3, u32 reg, u32 mask,
 330                      u32 expected)
 331 {
 332         int i;
 333
 334         for (i = 0; i < USB3_WAIT_US; i++) {
 335                 if ((usb3_read(usb3, reg) & mask) == expected)
 336                         return 0;
 337                 udelay(1);
 338         }
 339
 340         dev_dbg(usb3_to_dev(usb3), "%s: timed out (%8x, %08x, %08x)\n",
 341                 __func__, reg, mask, expected);
 342
 343         return -EBUSY;
 344 }
 345
 346 static void renesas_usb3_extcon_work(struct work_struct *work)
 347 {
 348         struct renesas_usb3 *usb3 = container_of(work, struct renesas_usb3,
 349                                                  extcon_work);
 350
 351         extcon_set_state_sync(usb3->extcon, EXTCON_USB_HOST, usb3->extcon_host);
 352         extcon_set_state_sync(usb3->extcon, EXTCON_USB, usb3->extcon_usb);
 353 }
 354
 355 static void usb3_enable_irq_1(struct renesas_usb3 *usb3, u32 bits)
 356 {
 357         usb3_set_bit(usb3, bits, USB3_USB_INT_ENA_1);
 358 }
 359
 360 static void usb3_disable_irq_1(struct renesas_usb3 *usb3, u32 bits)
 361 {
 362         usb3_clear_bit(usb3, bits, USB3_USB_INT_ENA_1);
 363 }
 364
 365 static void usb3_enable_pipe_irq(struct renesas_usb3 *usb3, int num)
 366 {
 367         usb3_set_bit(usb3, USB_INT_2_PIPE(num), USB3_USB_INT_ENA_2);
 368 }
 369
 370 static void usb3_disable_pipe_irq(struct renesas_usb3 *usb3, int num)
 371 {
 372         usb3_clear_bit(usb3, USB_INT_2_PIPE(num), USB3_USB_INT_ENA_2);
 373 }
 374
 375 static bool usb3_is_host(struct renesas_usb3 *usb3)
 376 {
 377         return !(usb3_read(usb3, USB3_DRD_CON) & DRD_CON_PERI_CON);
 378 }
 379
 380 static void usb3_init_axi_bridge(struct renesas_usb3 *usb3)
 381 {
 382         /* Set AXI_INT */
 383         usb3_write(usb3, ~0, USB3_DMA_INT_STA);
 384         usb3_write(usb3, 0, USB3_DMA_INT_ENA);
 385         usb3_set_bit(usb3, AXI_INT_DMAINT | AXI_INT_EPCINT, USB3_AXI_INT_ENA);
 386 }
 387
 388 static void usb3_init_epc_registers(struct renesas_usb3 *usb3)
 389 {
 390         usb3_write(usb3, ~0, USB3_USB_INT_STA_1);
 391         usb3_enable_irq_1(usb3, USB_INT_1_VBUS_CNG);
 392 }
 393
 394 static bool usb3_wakeup_usb2_phy(struct renesas_usb3 *usb3)
 395 {
 396         if (!(usb3_read(usb3, USB3_USB20_CON) & USB20_CON_B2_SUSPEND))
 397                 return true;    /* already waked it up */
 398
 399         usb3_clear_bit(usb3, USB20_CON_B2_SUSPEND, USB3_USB20_CON);
 400         usb3_enable_irq_1(usb3, USB_INT_1_B2_RSUM);
 401
 402         return false;
 403 }
 404
 405 static void usb3_usb2_pullup(struct renesas_usb3 *usb3, int pullup)
 406 {
 407         u32 bits = USB20_CON_B2_PUE | USB20_CON_B2_CONNECT;
 408
 409         if (usb3->softconnect && pullup)
 410                 usb3_set_bit(usb3, bits, USB3_USB20_CON);
 411         else
 412                 usb3_clear_bit(usb3, bits, USB3_USB20_CON);
 413 }
 414
 415 static void usb3_set_test_mode(struct renesas_usb3 *usb3)
 416 {
 417         u32 val = usb3_read(usb3, USB3_USB20_CON);
 418
 419         val &= ~USB20_CON_B2_TSTMOD_MASK;
 420         val |= USB20_CON_B2_TSTMOD(usb3->test_mode);
 421         usb3_write(usb3, val | USB20_CON_B2_TSTMOD_EN, USB3_USB20_CON);
 422         if (!usb3->test_mode)
 423                 usb3_clear_bit(usb3, USB20_CON_B2_TSTMOD_EN, USB3_USB20_CON);
 424 }
 425
 426 static void usb3_start_usb2_connection(struct renesas_usb3 *usb3)
 427 {
 428         usb3->disabled_count++;
 429         usb3_set_bit(usb3, USB_COM_CON_EP0_EN, USB3_USB_COM_CON);
 430         usb3_set_bit(usb3, USB_COM_CON_SPD_MODE, USB3_USB_COM_CON);
 431         usb3_usb2_pullup(usb3, 1);
 432 }
 433
 434 static int usb3_is_usb3_phy_in_u3(struct renesas_usb3 *usb3)
 435 {
 436         return usb3_read(usb3, USB3_USB30_CON) & USB30_CON_POW_SEL_IN_U3;
 437 }
 438
 439 static bool usb3_wakeup_usb3_phy(struct renesas_usb3 *usb3)
 440 {
 441         if (!usb3_is_usb3_phy_in_u3(usb3))
 442                 return true;    /* already waked it up */
 443
 444         usb3_set_bit(usb3, USB30_CON_B3_PLLWAKE, USB3_USB30_CON);
 445         usb3_enable_irq_1(usb3, USB_INT_1_B3_PLLWKUP);
 446
 447         return false;
 448 }
 449
 450 static u16 usb3_feature_get_un_enabled(struct renesas_usb3 *usb3)
 451 {
 452         u32 mask_u2 = SSIFCMD_UDIR_U2 | SSIFCMD_UREQ_U2;
 453         u32 mask_u1 = SSIFCMD_UDIR_U1 | SSIFCMD_UREQ_U1;
 454         u32 val = usb3_read(usb3, USB3_SSIFCMD);
 455         u16 ret = 0;
 456
 457         /* Enables {U2,U1} if the bits of UDIR and UREQ are set to 0 */
 458         if (!(val & mask_u2))
 459                 ret |= 1 << USB_DEV_STAT_U2_ENABLED;
 460         if (!(val & mask_u1))
 461                 ret |= 1 << USB_DEV_STAT_U1_ENABLED;
 462
 463         return ret;
 464 }
 465
 466 static void usb3_feature_u2_enable(struct renesas_usb3 *usb3, bool enable)
 467 {
 468         u32 bits = SSIFCMD_UDIR_U2 | SSIFCMD_UREQ_U2;
 469
 470         /* Enables U2 if the bits of UDIR and UREQ are set to 0 */
 471         if (enable)
 472                 usb3_clear_bit(usb3, bits, USB3_SSIFCMD);
 473         else
 474                 usb3_set_bit(usb3, bits, USB3_SSIFCMD);
 475 }
 476
 477 static void usb3_feature_u1_enable(struct renesas_usb3 *usb3, bool enable)
 478 {
 479         u32 bits = SSIFCMD_UDIR_U1 | SSIFCMD_UREQ_U1;
 480
 481         /* Enables U1 if the bits of UDIR and UREQ are set to 0 */
 482         if (enable)
 483                 usb3_clear_bit(usb3, bits, USB3_SSIFCMD);
 484         else
 485                 usb3_set_bit(usb3, bits, USB3_SSIFCMD);
 486 }
 487
 488 static void usb3_start_operation_for_usb3(struct renesas_usb3 *usb3)
 489 {
 490         usb3_set_bit(usb3, USB_COM_CON_EP0_EN, USB3_USB_COM_CON);
 491         usb3_clear_bit(usb3, USB_COM_CON_SPD_MODE, USB3_USB_COM_CON);
 492         usb3_set_bit(usb3, USB30_CON_B3_CONNECT, USB3_USB30_CON);
 493 }
 494
 495 static void usb3_start_usb3_connection(struct renesas_usb3 *usb3)
 496 {
 497         usb3_start_operation_for_usb3(usb3);
 498         usb3_set_bit(usb3, USB_COM_CON_RX_DETECTION, USB3_USB_COM_CON);
 499
 500         usb3_enable_irq_1(usb3, USB_INT_1_B3_LUPSUCS | USB_INT_1_B3_DISABLE |
 501                           USB_INT_1_SPEED);
 502 }
 503
 504 static void usb3_stop_usb3_connection(struct renesas_usb3 *usb3)
 505 {
 506         usb3_clear_bit(usb3, USB30_CON_B3_CONNECT, USB3_USB30_CON);
 507 }
 508
 509 static void usb3_transition_to_default_state(struct renesas_usb3 *usb3,
 510                                              bool is_usb3)
 511 {
 512         usb3_set_bit(usb3, USB_INT_2_PIPE(0), USB3_USB_INT_ENA_2);
 513         usb3_write(usb3, P0_INT_ALL_BITS, USB3_P0_INT_STA);
 514         usb3_set_bit(usb3, P0_INT_ALL_BITS, USB3_P0_INT_ENA);
 515
 516         if (is_usb3)
 517                 usb3_enable_irq_1(usb3, USB_INT_1_B3_WRMRST |
 518                                   USB_INT_1_B3_HOTRST);
 519         else
 520                 usb3_enable_irq_1(usb3, USB_INT_1_B2_SPND |
 521                                   USB_INT_1_B2_L1SPND | USB_INT_1_B2_USBRST);
 522 }
 523
 524 static void usb3_connect(struct renesas_usb3 *usb3)
 525 {
 526         if (usb3_wakeup_usb3_phy(usb3))
 527                 usb3_start_usb3_connection(usb3);
 528 }
 529
 530 static void usb3_reset_epc(struct renesas_usb3 *usb3)
 531 {
 532         usb3_clear_bit(usb3, USB_COM_CON_CONF, USB3_USB_COM_CON);
 533         usb3_clear_bit(usb3, USB_COM_CON_EP0_EN, USB3_USB_COM_CON);
 534         usb3_set_bit(usb3, USB_COM_CON_PIPE_CLR, USB3_USB_COM_CON);
 535         usb3->test_mode = 0;
 536         usb3_set_test_mode(usb3);
 537 }
 538
 539 static void usb3_disconnect(struct renesas_usb3 *usb3)
 540 {
 541         usb3->disabled_count = 0;
 542         usb3_usb2_pullup(usb3, 0);
 543         usb3_clear_bit(usb3, USB30_CON_B3_CONNECT, USB3_USB30_CON);
 544         usb3_reset_epc(usb3);
 545
 546         if (usb3->driver)
 547                 usb3->driver->disconnect(&usb3->gadget);
 548 }
 549
 550 static void usb3_check_vbus(struct renesas_usb3 *usb3)
 551 {
 552         if (usb3->workaround_for_vbus) {
 553                 usb3_connect(usb3);
 554         } else {
 555                 usb3->extcon_usb = !!(usb3_read(usb3, USB3_USB_STA) &
 556                                                         USB_STA_VBUS_STA);
 557                 if (usb3->extcon_usb)
 558                         usb3_connect(usb3);
 559                 else
 560                         usb3_disconnect(usb3);
 561
 562                 schedule_work(&usb3->extcon_work);
 563         }
 564 }
 565
 566 static void usb3_set_mode(struct renesas_usb3 *usb3, bool host)
 567 {
 568         if (host)
 569                 usb3_clear_bit(usb3, DRD_CON_PERI_CON, USB3_DRD_CON);
 570         else
 571                 usb3_set_bit(usb3, DRD_CON_PERI_CON, USB3_DRD_CON);
 572 }
 573
 574 static void usb3_vbus_out(struct renesas_usb3 *usb3, bool enable)
 575 {
 576         if (enable)
 577                 usb3_set_bit(usb3, DRD_CON_VBOUT, USB3_DRD_CON);
 578         else
 579                 usb3_clear_bit(usb3, DRD_CON_VBOUT, USB3_DRD_CON);
 580 }
 581
 582 static void usb3_mode_config(struct renesas_usb3 *usb3, bool host, bool a_dev)
 583 {
 584         unsigned long flags;
 585
 586         spin_lock_irqsave(&usb3->lock, flags);
 587         usb3_set_mode(usb3, host);
 588         usb3_vbus_out(usb3, a_dev);
 589         if (!host && a_dev)             /* for A-Peripheral */
 590                 usb3_connect(usb3);
 591         spin_unlock_irqrestore(&usb3->lock, flags);
 592 }
 593
 594 static bool usb3_is_a_device(struct renesas_usb3 *usb3)
 595 {
 596         return !(usb3_read(usb3, USB3_USB_OTG_STA) & USB_OTG_IDMON);
 597 }
 598
 599 static void usb3_check_id(struct renesas_usb3 *usb3)
 600 {
 601         usb3->extcon_host = usb3_is_a_device(usb3);
 602
 603         if (usb3->extcon_host)
 604                 usb3_mode_config(usb3, true, true);
 605         else
 606                 usb3_mode_config(usb3, false, false);
 607
 608         schedule_work(&usb3->extcon_work);
 609 }
 610
 611 static void renesas_usb3_init_controller(struct renesas_usb3 *usb3)
 612 {
 613         usb3_init_axi_bridge(usb3);
 614         usb3_init_epc_registers(usb3);
 615         usb3_write(usb3, USB_OTG_IDMON, USB3_USB_OTG_INT_STA);
 616         usb3_write(usb3, USB_OTG_IDMON, USB3_USB_OTG_INT_ENA);
 617
 618         usb3_check_id(usb3);
 619         usb3_check_vbus(usb3);
 620 }
 621
 622 static void renesas_usb3_stop_controller(struct renesas_usb3 *usb3)
 623 {
 624         usb3_disconnect(usb3);
 625         usb3_write(usb3, 0, USB3_P0_INT_ENA);
 626         usb3_write(usb3, 0, USB3_PN_INT_ENA);
 627         usb3_write(usb3, 0, USB3_USB_OTG_INT_ENA);
 628         usb3_write(usb3, 0, USB3_USB_INT_ENA_1);
 629         usb3_write(usb3, 0, USB3_USB_INT_ENA_2);
 630         usb3_write(usb3, 0, USB3_AXI_INT_ENA);
 631 }
 632
 633 static void usb3_irq_epc_int_1_pll_wakeup(struct renesas_usb3 *usb3)
 634 {
 635         usb3_disable_irq_1(usb3, USB_INT_1_B3_PLLWKUP);
 636         usb3_clear_bit(usb3, USB30_CON_B3_PLLWAKE, USB3_USB30_CON);
 637         usb3_start_usb3_connection(usb3);
 638 }
 639
 640 static void usb3_irq_epc_int_1_linkup_success(struct renesas_usb3 *usb3)
 641 {
 642         usb3_transition_to_default_state(usb3, true);
 643 }
 644
 645 static void usb3_irq_epc_int_1_resume(struct renesas_usb3 *usb3)
 646 {
 647         usb3_disable_irq_1(usb3, USB_INT_1_B2_RSUM);
 648         usb3_start_usb2_connection(usb3);
 649         usb3_transition_to_default_state(usb3, false);
 650 }
 651
 652 static void usb3_irq_epc_int_1_disable(struct renesas_usb3 *usb3)
 653 {
 654         usb3_stop_usb3_connection(usb3);
 655         if (usb3_wakeup_usb2_phy(usb3))
 656                 usb3_irq_epc_int_1_resume(usb3);
 657 }
 658
 659 static void usb3_irq_epc_int_1_bus_reset(struct renesas_usb3 *usb3)
 660 {
 661         usb3_reset_epc(usb3);
 662         if (usb3->disabled_count < 3)
 663                 usb3_start_usb3_connection(usb3);
 664         else
 665                 usb3_start_usb2_connection(usb3);
 666 }
 667
 668 static void usb3_irq_epc_int_1_vbus_change(struct renesas_usb3 *usb3)
 669 {
 670         usb3_check_vbus(usb3);
 671 }
 672
 673 static void usb3_irq_epc_int_1_hot_reset(struct renesas_usb3 *usb3)
 674 {
 675         usb3_reset_epc(usb3);
 676         usb3_set_bit(usb3, USB_COM_CON_EP0_EN, USB3_USB_COM_CON);
 677
 678         /* This bit shall be set within 12ms from the start of HotReset */
 679         usb3_set_bit(usb3, USB30_CON_B3_HOTRST_CMP, USB3_USB30_CON);
 680 }
 681
 682 static void usb3_irq_epc_int_1_warm_reset(struct renesas_usb3 *usb3)
 683 {
 684         usb3_reset_epc(usb3);
 685         usb3_set_bit(usb3, USB_COM_CON_EP0_EN, USB3_USB_COM_CON);
 686
 687         usb3_start_operation_for_usb3(usb3);
 688         usb3_enable_irq_1(usb3, USB_INT_1_SPEED);
 689 }
 690
 691 static void usb3_irq_epc_int_1_speed(struct renesas_usb3 *usb3)
 692 {
 693         u32 speed = usb3_read(usb3, USB3_USB_STA) & USB_STA_SPEED_MASK;
 694
 695         switch (speed) {
 696         case USB_STA_SPEED_SS:
 697                 usb3->gadget.speed = USB_SPEED_SUPER;
 698                 break;
 699         case USB_STA_SPEED_HS:
 700                 usb3->gadget.speed = USB_SPEED_HIGH;
 701                 break;
 702         case USB_STA_SPEED_FS:
 703                 usb3->gadget.speed = USB_SPEED_FULL;
 704                 break;
 705         default:
 706                 usb3->gadget.speed = USB_SPEED_UNKNOWN;
 707                 break;
 708         }
 709 }
 710
 711 static void usb3_irq_epc_int_1(struct renesas_usb3 *usb3, u32 int_sta_1)
 712 {
 713         if (int_sta_1 & USB_INT_1_B3_PLLWKUP)
 714                 usb3_irq_epc_int_1_pll_wakeup(usb3);
 715
 716         if (int_sta_1 & USB_INT_1_B3_LUPSUCS)
 717                 usb3_irq_epc_int_1_linkup_success(usb3);
 718
 719         if (int_sta_1 & USB_INT_1_B3_HOTRST)
 720                 usb3_irq_epc_int_1_hot_reset(usb3);
 721
 722         if (int_sta_1 & USB_INT_1_B3_WRMRST)
 723                 usb3_irq_epc_int_1_warm_reset(usb3);
 724
 725         if (int_sta_1 & USB_INT_1_B3_DISABLE)
 726                 usb3_irq_epc_int_1_disable(usb3);
 727
 728         if (int_sta_1 & USB_INT_1_B2_USBRST)
 729                 usb3_irq_epc_int_1_bus_reset(usb3);
 730
 731         if (int_sta_1 & USB_INT_1_B2_RSUM)
 732                 usb3_irq_epc_int_1_resume(usb3);
 733
 734         if (int_sta_1 & USB_INT_1_SPEED)
 735                 usb3_irq_epc_int_1_speed(usb3);
 736
 737         if (int_sta_1 & USB_INT_1_VBUS_CNG)
 738                 usb3_irq_epc_int_1_vbus_change(usb3);
 739 }
 740
 741 static struct renesas_usb3_request *__usb3_get_request(struct renesas_usb3_ep
 742                                                        *usb3_ep)
 743 {
 744         return list_first_entry_or_null(&usb3_ep->queue,
 745                                         struct renesas_usb3_request, queue);
 746 }
 747
 748 static struct renesas_usb3_request *usb3_get_request(struct renesas_usb3_ep
 749                                                      *usb3_ep)
 750 {
 751         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
 752         struct renesas_usb3_request *usb3_req;
 753         unsigned long flags;
 754
 755         spin_lock_irqsave(&usb3->lock, flags);
 756         usb3_req = __usb3_get_request(usb3_ep);
 757         spin_unlock_irqrestore(&usb3->lock, flags);
 758
 759         return usb3_req;
 760 }
 761
 762 static void usb3_request_done(struct renesas_usb3_ep *usb3_ep,
 763                               struct renesas_usb3_request *usb3_req, int status)
 764 {
 765         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
 766         unsigned long flags;
 767
 768         dev_dbg(usb3_to_dev(usb3), "giveback: ep%2d, %u, %u, %d\n",
 769                 usb3_ep->num, usb3_req->req.length, usb3_req->req.actual,
 770                 status);
 771         usb3_req->req.status = status;
 772         spin_lock_irqsave(&usb3->lock, flags);
 773         usb3_ep->started = false;
 774         list_del_init(&usb3_req->queue);
 775         spin_unlock_irqrestore(&usb3->lock, flags);
 776         usb_gadget_giveback_request(&usb3_ep->ep, &usb3_req->req);
 777 }
 778
 779 static void usb3_irq_epc_pipe0_status_end(struct renesas_usb3 *usb3)
 780 {
 781         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, 0);
 782         struct renesas_usb3_request *usb3_req = usb3_get_request(usb3_ep);
 783
 784         if (usb3_req)
 785                 usb3_request_done(usb3_ep, usb3_req, 0);
 786         if (usb3->test_mode)
 787                 usb3_set_test_mode(usb3);
 788 }
 789
 790 static void usb3_get_setup_data(struct renesas_usb3 *usb3,
 791                                 struct usb_ctrlrequest *ctrl)
 792 {
 793         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, 0);
 794         u32 *data = (u32 *)ctrl;
 795
 796         *data++ = usb3_read(usb3, USB3_STUP_DAT_0);
 797         *data = usb3_read(usb3, USB3_STUP_DAT_1);
 798
 799         /* update this driver's flag */
 800         usb3_ep->dir_in = !!(ctrl->bRequestType & USB_DIR_IN);
 801 }
 802
 803 static void usb3_set_p0_con_update_res(struct renesas_usb3 *usb3, u32 res)
 804 {
 805         u32 val = usb3_read(usb3, USB3_P0_CON);
 806
 807         val &= ~(P0_CON_ST_RES_MASK | P0_CON_OT_RES_MASK | P0_CON_IN_RES_MASK);
 808         val |= res | P0_CON_RES_WEN;
 809         usb3_write(usb3, val, USB3_P0_CON);
 810 }
 811
 812 static void usb3_set_p0_con_for_ctrl_read_data(struct renesas_usb3 *usb3)
 813 {
 814         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_FORCE_NRDY |
 815                                    P0_CON_OT_RES_FORCE_STALL |
 816                                    P0_CON_IN_RES_NORMAL);
 817 }
 818
 819 static void usb3_set_p0_con_for_ctrl_read_status(struct renesas_usb3 *usb3)
 820 {
 821         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_NORMAL |
 822                                    P0_CON_OT_RES_FORCE_STALL |
 823                                    P0_CON_IN_RES_NORMAL);
 824 }
 825
 826 static void usb3_set_p0_con_for_ctrl_write_data(struct renesas_usb3 *usb3)
 827 {
 828         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_FORCE_NRDY |
 829                                    P0_CON_OT_RES_NORMAL |
 830                                    P0_CON_IN_RES_FORCE_STALL);
 831 }
 832
 833 static void usb3_set_p0_con_for_ctrl_write_status(struct renesas_usb3 *usb3)
 834 {
 835         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_NORMAL |
 836                                    P0_CON_OT_RES_NORMAL |
 837                                    P0_CON_IN_RES_FORCE_STALL);
 838 }
 839
 840 static void usb3_set_p0_con_for_no_data(struct renesas_usb3 *usb3)
 841 {
 842         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_NORMAL |
 843                                    P0_CON_OT_RES_FORCE_STALL |
 844                                    P0_CON_IN_RES_FORCE_STALL);
 845 }
 846
 847 static void usb3_set_p0_con_stall(struct renesas_usb3 *usb3)
 848 {
 849         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_FORCE_STALL |
 850                                    P0_CON_OT_RES_FORCE_STALL |
 851                                    P0_CON_IN_RES_FORCE_STALL);
 852 }
 853
 854 static void usb3_set_p0_con_stop(struct renesas_usb3 *usb3)
 855 {
 856         usb3_set_p0_con_update_res(usb3, P0_CON_ST_RES_FORCE_NRDY |
 857                                    P0_CON_OT_RES_FORCE_NRDY |
 858                                    P0_CON_IN_RES_FORCE_NRDY);
 859 }
 860
 861 static int usb3_pn_change(struct renesas_usb3 *usb3, int num)
 862 {
 863         if (num == 0 || num > usb3->num_usb3_eps)
 864                 return -ENXIO;
 865
 866         usb3_write(usb3, num, USB3_PIPE_COM);
 867
 868         return 0;
 869 }
 870
 871 static void usb3_set_pn_con_update_res(struct renesas_usb3 *usb3, u32 res)
 872 {
 873         u32 val = usb3_read(usb3, USB3_PN_CON);
 874
 875         val &= ~PN_CON_RES_MASK;
 876         val |= res & PN_CON_RES_MASK;
 877         val |= PN_CON_RES_WEN;
 878         usb3_write(usb3, val, USB3_PN_CON);
 879 }
 880
 881 static void usb3_pn_start(struct renesas_usb3 *usb3)
 882 {
 883         usb3_set_pn_con_update_res(usb3, PN_CON_RES_NORMAL);
 884 }
 885
 886 static void usb3_pn_stop(struct renesas_usb3 *usb3)
 887 {
 888         usb3_set_pn_con_update_res(usb3, PN_CON_RES_FORCE_NRDY);
 889 }
 890
 891 static void usb3_pn_stall(struct renesas_usb3 *usb3)
 892 {
 893         usb3_set_pn_con_update_res(usb3, PN_CON_RES_FORCE_STALL);
 894 }
 895
 896 static int usb3_pn_con_clear(struct renesas_usb3 *usb3)
 897 {
 898         usb3_set_bit(usb3, PN_CON_CLR, USB3_PN_CON);
 899
 900         return usb3_wait(usb3, USB3_PN_CON, PN_CON_CLR, 0);
 901 }
 902
 903 static bool usb3_is_transfer_complete(struct renesas_usb3_ep *usb3_ep,
 904                                       struct renesas_usb3_request *usb3_req)
 905 {
 906         struct usb_request *req = &usb3_req->req;
 907
 908         if ((!req->zero && req->actual == req->length) ||
 909             (req->actual % usb3_ep->ep.maxpacket) || (req->length == 0))
 910                 return true;
 911         else
 912                 return false;
 913 }
 914
 915 static int usb3_wait_pipe_status(struct renesas_usb3_ep *usb3_ep, u32 mask)
 916 {
 917         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
 918         u32 sta_reg = usb3_ep->num ? USB3_PN_STA : USB3_P0_STA;
 919
 920         return usb3_wait(usb3, sta_reg, mask, mask);
 921 }
 922
 923 static void usb3_set_px_con_send(struct renesas_usb3_ep *usb3_ep, int bytes,
 924                                  bool last)
 925 {
 926         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
 927         u32 con_reg = usb3_ep->num ? USB3_PN_CON : USB3_P0_CON;
 928         u32 val = usb3_read(usb3, con_reg);
 929
 930         val |= PX_CON_SEND | PX_CON_BYTE_EN_BYTES(bytes);
 931         val |= (usb3_ep->num && last) ? PN_CON_LAST : 0;
 932         usb3_write(usb3, val, con_reg);
 933 }
 934
 935 static int usb3_write_pipe(struct renesas_usb3_ep *usb3_ep,
 936                            struct renesas_usb3_request *usb3_req,
 937                            u32 fifo_reg)
 938 {
 939         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
 940         int i;
 941         int len = min_t(unsigned, usb3_req->req.length - usb3_req->req.actual,
 942                         usb3_ep->ep.maxpacket);
 943         u8 *buf = usb3_req->req.buf + usb3_req->req.actual;
 944         u32 tmp = 0;
 945         bool is_last;
 946
 947         if (usb3_wait_pipe_status(usb3_ep, PX_STA_BUFSTS) < 0)
 948                 return -EBUSY;
 949
 950         /* Update gadget driver parameter */
 951         usb3_req->req.actual += len;
 952
 953         /* Write data to the register */
 954         if (len >= 4) {
 955                 iowrite32_rep(usb3->reg + fifo_reg, buf, len / 4);
 956                 buf += (len / 4) * 4;
 957                 len %= 4;       /* update len to use usb3_set_pX_con_send() */
 958         }
 959
 960         if (len) {
 961                 for (i = 0; i < len; i++)
 962                         tmp |= buf[i] << (8 * i);
 963                 usb3_write(usb3, tmp, fifo_reg);
 964         }
 965
 966         is_last = usb3_is_transfer_complete(usb3_ep, usb3_req);
 967         /* Send the data */
 968         usb3_set_px_con_send(usb3_ep, len, is_last);
 969
 970         return is_last ? 0 : -EAGAIN;
 971 }
 972
 973 static u32 usb3_get_received_length(struct renesas_usb3_ep *usb3_ep)
 974 {
 975         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
 976         u32 lng_reg = usb3_ep->num ? USB3_PN_LNG : USB3_P0_LNG;
 977
 978         return usb3_read(usb3, lng_reg);
 979 }
 980
 981 static int usb3_read_pipe(struct renesas_usb3_ep *usb3_ep,
 982                           struct renesas_usb3_request *usb3_req, u32 fifo_reg)
 983 {
 984         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
 985         int i;
 986         int len = min_t(unsigned, usb3_req->req.length - usb3_req->req.actual,
 987                         usb3_get_received_length(usb3_ep));
 988         u8 *buf = usb3_req->req.buf + usb3_req->req.actual;
 989         u32 tmp = 0;
 990
 991         if (!len)
 992                 return 0;
 993
 994         /* Update gadget driver parameter */
 995         usb3_req->req.actual += len;
 996
 997         /* Read data from the register */
 998         if (len >= 4) {
 999                 ioread32_rep(usb3->reg + fifo_reg, buf, len / 4);
1000                 buf += (len / 4) * 4;
1001                 len %= 4;
1002         }
1003
1004         if (len) {
1005                 tmp = usb3_read(usb3, fifo_reg);
1006                 for (i = 0; i < len; i++)
1007                         buf[i] = (tmp >> (8 * i)) & 0xff;
1008         }
1009
1010         return usb3_is_transfer_complete(usb3_ep, usb3_req) ? 0 : -EAGAIN;
1011 }
1012
1013 static void usb3_set_status_stage(struct renesas_usb3_ep *usb3_ep,
1014                                   struct renesas_usb3_request *usb3_req)
1015 {
1016         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1017
1018         if (usb3_ep->dir_in) {
1019                 usb3_set_p0_con_for_ctrl_read_status(usb3);
1020         } else {
1021                 if (!usb3_req->req.length)
1022                         usb3_set_p0_con_for_no_data(usb3);
1023                 else
1024                         usb3_set_p0_con_for_ctrl_write_status(usb3);
1025         }
1026 }
1027
1028 static void usb3_p0_xfer(struct renesas_usb3_ep *usb3_ep,
1029                          struct renesas_usb3_request *usb3_req)
1030 {
1031         int ret = -EAGAIN;
1032
1033         if (usb3_ep->dir_in)
1034                 ret = usb3_write_pipe(usb3_ep, usb3_req, USB3_P0_WRITE);
1035         else
1036                 ret = usb3_read_pipe(usb3_ep, usb3_req, USB3_P0_READ);
1037
1038         if (!ret)
1039                 usb3_set_status_stage(usb3_ep, usb3_req);
1040 }
1041
1042 static void usb3_start_pipe0(struct renesas_usb3_ep *usb3_ep,
1043                              struct renesas_usb3_request *usb3_req)
1044 {
1045         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1046
1047         if (usb3_ep->started)
1048                 return;
1049
1050         usb3_ep->started = true;
1051
1052         if (usb3_ep->dir_in) {
1053                 usb3_set_bit(usb3, P0_MOD_DIR, USB3_P0_MOD);
1054                 usb3_set_p0_con_for_ctrl_read_data(usb3);
1055         } else {
1056                 usb3_clear_bit(usb3, P0_MOD_DIR, USB3_P0_MOD);
1057                 usb3_set_p0_con_for_ctrl_write_data(usb3);
1058         }
1059
1060         usb3_p0_xfer(usb3_ep, usb3_req);
1061 }
1062
1063 static void usb3_start_pipen(struct renesas_usb3_ep *usb3_ep,
1064                              struct renesas_usb3_request *usb3_req)
1065 {
1066         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1067         struct renesas_usb3_request *usb3_req_first = usb3_get_request(usb3_ep);
1068         unsigned long flags;
1069         int ret = -EAGAIN;
1070         u32 enable_bits = 0;
1071
1072         if (usb3_ep->halt || usb3_ep->started)
1073                 return;
1074         if (usb3_req != usb3_req_first)
1075                 return;
1076
1077         spin_lock_irqsave(&usb3->lock, flags);
1078         if (usb3_pn_change(usb3, usb3_ep->num) < 0)
1079                 goto out;
1080
1081         usb3_ep->started = true;
1082         usb3_pn_start(usb3);
1083
1084         if (usb3_ep->dir_in) {
1085                 ret = usb3_write_pipe(usb3_ep, usb3_req, USB3_PN_WRITE);
1086                 enable_bits |= PN_INT_LSTTR;
1087         }
1088
1089         if (ret < 0)
1090                 enable_bits |= PN_INT_BFRDY;
1091
1092         if (enable_bits) {
1093                 usb3_set_bit(usb3, enable_bits, USB3_PN_INT_ENA);
1094                 usb3_enable_pipe_irq(usb3, usb3_ep->num);
1095         }
1096 out:
1097         spin_unlock_irqrestore(&usb3->lock, flags);
1098 }
1099
1100 static int renesas_usb3_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
1101                                  gfp_t gfp_flags)
1102 {
1103         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
1104         struct renesas_usb3_request *usb3_req = usb_req_to_usb3_req(_req);
1105         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1106         unsigned long flags;
1107
1108         dev_dbg(usb3_to_dev(usb3), "ep_queue: ep%2d, %u\n", usb3_ep->num,
1109                 _req->length);
1110
1111         _req->status = -EINPROGRESS;
1112         _req->actual = 0;
1113         spin_lock_irqsave(&usb3->lock, flags);
1114         list_add_tail(&usb3_req->queue, &usb3_ep->queue);
1115         spin_unlock_irqrestore(&usb3->lock, flags);
1116
1117         if (!usb3_ep->num)
1118                 usb3_start_pipe0(usb3_ep, usb3_req);
1119         else
1120                 usb3_start_pipen(usb3_ep, usb3_req);
1121
1122         return 0;
1123 }
1124
1125 static void usb3_set_device_address(struct renesas_usb3 *usb3, u16 addr)
1126 {
1127         /* DEV_ADDR bit field is cleared by WarmReset, HotReset and BusReset */
1128         usb3_set_bit(usb3, USB_COM_CON_DEV_ADDR(addr), USB3_USB_COM_CON);
1129 }
1130
1131 static bool usb3_std_req_set_address(struct renesas_usb3 *usb3,
1132                                      struct usb_ctrlrequest *ctrl)
1133 {
1134         if (ctrl->wValue >= 128)
1135                 return true;    /* stall */
1136
1137         usb3_set_device_address(usb3, ctrl->wValue);
1138         usb3_set_p0_con_for_no_data(usb3);
1139
1140         return false;
1141 }
1142
1143 static void usb3_pipe0_internal_xfer(struct renesas_usb3 *usb3,
1144                                      void *tx_data, size_t len,
1145                                      void (*complete)(struct usb_ep *ep,
1146                                                       struct usb_request *req))
1147 {
1148         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, 0);
1149
1150         if (tx_data)
1151                 memcpy(usb3->ep0_buf, tx_data,
1152                        min_t(size_t, len, USB3_EP0_BUF_SIZE));
1153
1154         usb3->ep0_req->buf = &usb3->ep0_buf;
1155         usb3->ep0_req->length = len;
1156         usb3->ep0_req->complete = complete;
1157         renesas_usb3_ep_queue(&usb3_ep->ep, usb3->ep0_req, GFP_ATOMIC);
1158 }
1159
1160 static void usb3_pipe0_get_status_completion(struct usb_ep *ep,
1161                                              struct usb_request *req)
1162 {
1163 }
1164
1165 static bool usb3_std_req_get_status(struct renesas_usb3 *usb3,
1166                                     struct usb_ctrlrequest *ctrl)
1167 {
1168         bool stall = false;
1169         struct renesas_usb3_ep *usb3_ep;
1170         int num;
1171         u16 status = 0;
1172
1173         switch (ctrl->bRequestType & USB_RECIP_MASK) {
1174         case USB_RECIP_DEVICE:
1175                 if (usb3->gadget.is_selfpowered)
1176                         status |= 1 << USB_DEVICE_SELF_POWERED;
1177                 if (usb3->gadget.speed == USB_SPEED_SUPER)
1178                         status |= usb3_feature_get_un_enabled(usb3);
1179                 break;
1180         case USB_RECIP_INTERFACE:
1181                 break;
1182         case USB_RECIP_ENDPOINT:
1183                 num = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK;
1184                 usb3_ep = usb3_get_ep(usb3, num);
1185                 if (usb3_ep->halt)
1186                         status |= 1 << USB_ENDPOINT_HALT;
1187                 break;
1188         default:
1189                 stall = true;
1190                 break;
1191         }
1192
1193         if (!stall) {
1194                 status = cpu_to_le16(status);
1195                 dev_dbg(usb3_to_dev(usb3), "get_status: req = %p\n",
1196                         usb_req_to_usb3_req(usb3->ep0_req));
1197                 usb3_pipe0_internal_xfer(usb3, &status, sizeof(status),
1198                                          usb3_pipe0_get_status_completion);
1199         }
1200
1201         return stall;
1202 }
1203
1204 static bool usb3_std_req_feature_device(struct renesas_usb3 *usb3,
1205                                         struct usb_ctrlrequest *ctrl, bool set)
1206 {
1207         bool stall = true;
1208         u16 w_value = le16_to_cpu(ctrl->wValue);
1209
1210         switch (w_value) {
1211         case USB_DEVICE_TEST_MODE:
1212                 if (!set)
1213                         break;
1214                 usb3->test_mode = le16_to_cpu(ctrl->wIndex) >> 8;
1215                 stall = false;
1216                 break;
1217         case USB_DEVICE_U1_ENABLE:
1218         case USB_DEVICE_U2_ENABLE:
1219                 if (usb3->gadget.speed != USB_SPEED_SUPER)
1220                         break;
1221                 if (w_value == USB_DEVICE_U1_ENABLE)
1222                         usb3_feature_u1_enable(usb3, set);
1223                 if (w_value == USB_DEVICE_U2_ENABLE)
1224                         usb3_feature_u2_enable(usb3, set);
1225                 stall = false;
1226                 break;
1227         default:
1228                 break;
1229         }
1230
1231         return stall;
1232 }
1233
1234 static int usb3_set_halt_p0(struct renesas_usb3_ep *usb3_ep, bool halt)
1235 {
1236         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1237
1238         if (unlikely(usb3_ep->num))
1239                 return -EINVAL;
1240
1241         usb3_ep->halt = halt;
1242         if (halt)
1243                 usb3_set_p0_con_stall(usb3);
1244         else
1245                 usb3_set_p0_con_stop(usb3);
1246
1247         return 0;
1248 }
1249
1250 static int usb3_set_halt_pn(struct renesas_usb3_ep *usb3_ep, bool halt,
1251                             bool is_clear_feature)
1252 {
1253         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1254         unsigned long flags;
1255
1256         spin_lock_irqsave(&usb3->lock, flags);
1257         if (!usb3_pn_change(usb3, usb3_ep->num)) {
1258                 usb3_ep->halt = halt;
1259                 if (halt) {
1260                         usb3_pn_stall(usb3);
1261                 } else if (!is_clear_feature || !usb3_ep->wedge) {
1262                         usb3_pn_con_clear(usb3);
1263                         usb3_set_bit(usb3, PN_CON_EN, USB3_PN_CON);
1264                         usb3_pn_stop(usb3);
1265                 }
1266         }
1267         spin_unlock_irqrestore(&usb3->lock, flags);
1268
1269         return 0;
1270 }
1271
1272 static int usb3_set_halt(struct renesas_usb3_ep *usb3_ep, bool halt,
1273                          bool is_clear_feature)
1274 {
1275         int ret = 0;
1276
1277         if (halt && usb3_ep->started)
1278                 return -EAGAIN;
1279
1280         if (usb3_ep->num)
1281                 ret = usb3_set_halt_pn(usb3_ep, halt, is_clear_feature);
1282         else
1283                 ret = usb3_set_halt_p0(usb3_ep, halt);
1284
1285         return ret;
1286 }
1287
1288 static bool usb3_std_req_feature_endpoint(struct renesas_usb3 *usb3,
1289                                           struct usb_ctrlrequest *ctrl,
1290                                           bool set)
1291 {
1292         int num = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK;
1293         struct renesas_usb3_ep *usb3_ep;
1294         struct renesas_usb3_request *usb3_req;
1295
1296         if (le16_to_cpu(ctrl->wValue) != USB_ENDPOINT_HALT)
1297                 return true;    /* stall */
1298
1299         usb3_ep = usb3_get_ep(usb3, num);
1300         usb3_set_halt(usb3_ep, set, true);
1301
1302         /* Restarts a queue if clear feature */
1303         if (!set) {
1304                 usb3_ep->started = false;
1305                 usb3_req = usb3_get_request(usb3_ep);
1306                 if (usb3_req)
1307                         usb3_start_pipen(usb3_ep, usb3_req);
1308         }
1309
1310         return false;
1311 }
1312
1313 static bool usb3_std_req_feature(struct renesas_usb3 *usb3,
1314                                  struct usb_ctrlrequest *ctrl, bool set)
1315 {
1316         bool stall = false;
1317
1318         switch (ctrl->bRequestType & USB_RECIP_MASK) {
1319         case USB_RECIP_DEVICE:
1320                 stall = usb3_std_req_feature_device(usb3, ctrl, set);
1321                 break;
1322         case USB_RECIP_INTERFACE:
1323                 break;
1324         case USB_RECIP_ENDPOINT:
1325                 stall = usb3_std_req_feature_endpoint(usb3, ctrl, set);
1326                 break;
1327         default:
1328                 stall = true;
1329                 break;
1330         }
1331
1332         if (!stall)
1333                 usb3_set_p0_con_for_no_data(usb3);
1334
1335         return stall;
1336 }
1337
1338 static void usb3_pipe0_set_sel_completion(struct usb_ep *ep,
1339                                           struct usb_request *req)
1340 {
1341         /* TODO */
1342 }
1343
1344 static bool usb3_std_req_set_sel(struct renesas_usb3 *usb3,
1345                                  struct usb_ctrlrequest *ctrl)
1346 {
1347         u16 w_length = le16_to_cpu(ctrl->wLength);
1348
1349         if (w_length != 6)
1350                 return true;    /* stall */
1351
1352         dev_dbg(usb3_to_dev(usb3), "set_sel: req = %p\n",
1353                 usb_req_to_usb3_req(usb3->ep0_req));
1354         usb3_pipe0_internal_xfer(usb3, NULL, 6, usb3_pipe0_set_sel_completion);
1355
1356         return false;
1357 }
1358
1359 static bool usb3_std_req_set_configuration(struct renesas_usb3 *usb3,
1360                                            struct usb_ctrlrequest *ctrl)
1361 {
1362         if (ctrl->wValue > 0)
1363                 usb3_set_bit(usb3, USB_COM_CON_CONF, USB3_USB_COM_CON);
1364         else
1365                 usb3_clear_bit(usb3, USB_COM_CON_CONF, USB3_USB_COM_CON);
1366
1367         return false;
1368 }
1369
1370 /**
1371  * usb3_handle_standard_request - handle some standard requests
1372  * @usb3: the renesas_usb3 pointer
1373  * @ctrl: a pointer of setup data
1374  *
1375  * Returns true if this function handled a standard request
1376  */
1377 static bool usb3_handle_standard_request(struct renesas_usb3 *usb3,
1378                                          struct usb_ctrlrequest *ctrl)
1379 {
1380         bool ret = false;
1381         bool stall = false;
1382
1383         if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
1384                 switch (ctrl->bRequest) {
1385                 case USB_REQ_SET_ADDRESS:
1386                         stall = usb3_std_req_set_address(usb3, ctrl);
1387                         ret = true;
1388                         break;
1389                 case USB_REQ_GET_STATUS:
1390                         stall = usb3_std_req_get_status(usb3, ctrl);
1391                         ret = true;
1392                         break;
1393                 case USB_REQ_CLEAR_FEATURE:
1394                         stall = usb3_std_req_feature(usb3, ctrl, false);
1395                         ret = true;
1396                         break;
1397                 case USB_REQ_SET_FEATURE:
1398                         stall = usb3_std_req_feature(usb3, ctrl, true);
1399                         ret = true;
1400                         break;
1401                 case USB_REQ_SET_SEL:
1402                         stall = usb3_std_req_set_sel(usb3, ctrl);
1403                         ret = true;
1404                         break;
1405                 case USB_REQ_SET_ISOCH_DELAY:
1406                         /* This hardware doesn't support Isochronous xfer */
1407                         stall = true;
1408                         ret = true;
1409                         break;
1410                 case USB_REQ_SET_CONFIGURATION:
1411                         usb3_std_req_set_configuration(usb3, ctrl);
1412                         break;
1413                 default:
1414                         break;
1415                 }
1416         }
1417
1418         if (stall)
1419                 usb3_set_p0_con_stall(usb3);
1420
1421         return ret;
1422 }
1423
1424 static int usb3_p0_con_clear_buffer(struct renesas_usb3 *usb3)
1425 {
1426         usb3_set_bit(usb3, P0_CON_BCLR, USB3_P0_CON);
1427
1428         return usb3_wait(usb3, USB3_P0_CON, P0_CON_BCLR, 0);
1429 }
1430
1431 static void usb3_irq_epc_pipe0_setup(struct renesas_usb3 *usb3)
1432 {
1433         struct usb_ctrlrequest ctrl;
1434         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, 0);
1435
1436         /* Call giveback function if previous transfer is not completed */
1437         if (usb3_ep->started)
1438                 usb3_request_done(usb3_ep, usb3_get_request(usb3_ep),
1439                                   -ECONNRESET);
1440
1441         usb3_p0_con_clear_buffer(usb3);
1442         usb3_get_setup_data(usb3, &ctrl);
1443         if (!usb3_handle_standard_request(usb3, &ctrl))
1444                 if (usb3->driver->setup(&usb3->gadget, &ctrl) < 0)
1445                         usb3_set_p0_con_stall(usb3);
1446 }
1447
1448 static void usb3_irq_epc_pipe0_bfrdy(struct renesas_usb3 *usb3)
1449 {
1450         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, 0);
1451         struct renesas_usb3_request *usb3_req = usb3_get_request(usb3_ep);
1452
1453         if (!usb3_req)
1454                 return;
1455
1456         usb3_p0_xfer(usb3_ep, usb3_req);
1457 }
1458
1459 static void usb3_irq_epc_pipe0(struct renesas_usb3 *usb3)
1460 {
1461         u32 p0_int_sta = usb3_read(usb3, USB3_P0_INT_STA);
1462
1463         p0_int_sta &= usb3_read(usb3, USB3_P0_INT_ENA);
1464         usb3_write(usb3, p0_int_sta, USB3_P0_INT_STA);
1465         if (p0_int_sta & P0_INT_STSED)
1466                 usb3_irq_epc_pipe0_status_end(usb3);
1467         if (p0_int_sta & P0_INT_SETUP)
1468                 usb3_irq_epc_pipe0_setup(usb3);
1469         if (p0_int_sta & P0_INT_BFRDY)
1470                 usb3_irq_epc_pipe0_bfrdy(usb3);
1471 }
1472
1473 static void usb3_request_done_pipen(struct renesas_usb3 *usb3,
1474                                     struct renesas_usb3_ep *usb3_ep,
1475                                     struct renesas_usb3_request *usb3_req,
1476                                     int status)
1477 {
1478         usb3_pn_stop(usb3);
1479         usb3_disable_pipe_irq(usb3, usb3_ep->num);
1480         usb3_request_done(usb3_ep, usb3_req, status);
1481
1482         /* get next usb3_req */
1483         usb3_req = usb3_get_request(usb3_ep);
1484         if (usb3_req)
1485                 usb3_start_pipen(usb3_ep, usb3_req);
1486 }
1487
1488 static void usb3_irq_epc_pipen_lsttr(struct renesas_usb3 *usb3, int num)
1489 {
1490         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, num);
1491         struct renesas_usb3_request *usb3_req = usb3_get_request(usb3_ep);
1492
1493         if (!usb3_req)
1494                 return;
1495
1496         if (usb3_ep->dir_in) {
1497                 dev_dbg(usb3_to_dev(usb3), "%s: len = %u, actual = %u\n",
1498                         __func__, usb3_req->req.length, usb3_req->req.actual);
1499                 usb3_request_done_pipen(usb3, usb3_ep, usb3_req, 0);
1500         }
1501 }
1502
1503 static void usb3_irq_epc_pipen_bfrdy(struct renesas_usb3 *usb3, int num)
1504 {
1505         struct renesas_usb3_ep *usb3_ep = usb3_get_ep(usb3, num);
1506         struct renesas_usb3_request *usb3_req = usb3_get_request(usb3_ep);
1507
1508         if (!usb3_req)
1509                 return;
1510
1511         if (usb3_ep->dir_in) {
1512                 /* Do not stop the IN pipe here to detect LSTTR interrupt */
1513                 if (!usb3_write_pipe(usb3_ep, usb3_req, USB3_PN_WRITE))
1514                         usb3_clear_bit(usb3, PN_INT_BFRDY, USB3_PN_INT_ENA);
1515         } else {
1516                 if (!usb3_read_pipe(usb3_ep, usb3_req, USB3_PN_READ))
1517                         usb3_request_done_pipen(usb3, usb3_ep, usb3_req, 0);
1518         }
1519 }
1520
1521 static void usb3_irq_epc_pipen(struct renesas_usb3 *usb3, int num)
1522 {
1523         u32 pn_int_sta;
1524
1525         if (usb3_pn_change(usb3, num) < 0)
1526                 return;
1527
1528         pn_int_sta = usb3_read(usb3, USB3_PN_INT_STA);
1529         pn_int_sta &= usb3_read(usb3, USB3_PN_INT_ENA);
1530         usb3_write(usb3, pn_int_sta, USB3_PN_INT_STA);
1531         if (pn_int_sta & PN_INT_LSTTR)
1532                 usb3_irq_epc_pipen_lsttr(usb3, num);
1533         if (pn_int_sta & PN_INT_BFRDY)
1534                 usb3_irq_epc_pipen_bfrdy(usb3, num);
1535 }
1536
1537 static void usb3_irq_epc_int_2(struct renesas_usb3 *usb3, u32 int_sta_2)
1538 {
1539         int i;
1540
1541         for (i = 0; i < usb3->num_usb3_eps; i++) {
1542                 if (int_sta_2 & USB_INT_2_PIPE(i)) {
1543                         if (!i)
1544                                 usb3_irq_epc_pipe0(usb3);
1545                         else
1546                                 usb3_irq_epc_pipen(usb3, i);
1547                 }
1548         }
1549 }
1550
1551 static void usb3_irq_idmon_change(struct renesas_usb3 *usb3)
1552 {
1553         usb3_check_id(usb3);
1554 }
1555
1556 static void usb3_irq_otg_int(struct renesas_usb3 *usb3, u32 otg_int_sta)
1557 {
1558         if (otg_int_sta & USB_OTG_IDMON)
1559                 usb3_irq_idmon_change(usb3);
1560 }
1561
1562 static void usb3_irq_epc(struct renesas_usb3 *usb3)
1563 {
1564         u32 int_sta_1 = usb3_read(usb3, USB3_USB_INT_STA_1);
1565         u32 int_sta_2 = usb3_read(usb3, USB3_USB_INT_STA_2);
1566         u32 otg_int_sta = usb3_read(usb3, USB3_USB_OTG_INT_STA);
1567
1568         int_sta_1 &= usb3_read(usb3, USB3_USB_INT_ENA_1);
1569         if (int_sta_1) {
1570                 usb3_write(usb3, int_sta_1, USB3_USB_INT_STA_1);
1571                 usb3_irq_epc_int_1(usb3, int_sta_1);
1572         }
1573
1574         int_sta_2 &= usb3_read(usb3, USB3_USB_INT_ENA_2);
1575         if (int_sta_2)
1576                 usb3_irq_epc_int_2(usb3, int_sta_2);
1577
1578         otg_int_sta &= usb3_read(usb3, USB3_USB_OTG_INT_ENA);
1579         if (otg_int_sta) {
1580                 usb3_write(usb3, otg_int_sta, USB3_USB_OTG_INT_STA);
1581                 usb3_irq_otg_int(usb3, otg_int_sta);
1582         }
1583 }
1584
1585 static irqreturn_t renesas_usb3_irq(int irq, void *_usb3)
1586 {
1587         struct renesas_usb3 *usb3 = _usb3;
1588         irqreturn_t ret = IRQ_NONE;
1589         u32 axi_int_sta = usb3_read(usb3, USB3_AXI_INT_STA);
1590
1591         if (axi_int_sta & AXI_INT_EPCINT) {
1592                 usb3_irq_epc(usb3);
1593                 ret = IRQ_HANDLED;
1594         }
1595
1596         return ret;
1597 }
1598
1599 static void usb3_write_pn_mod(struct renesas_usb3_ep *usb3_ep,
1600                               const struct usb_endpoint_descriptor *desc)
1601 {
1602         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1603         u32 val = 0;
1604
1605         val |= usb3_ep->dir_in ? PN_MOD_DIR : 0;
1606         val |= PN_MOD_TYPE(usb_endpoint_type(desc));
1607         val |= PN_MOD_EPNUM(usb_endpoint_num(desc));
1608         usb3_write(usb3, val, USB3_PN_MOD);
1609 }
1610
1611 static u32 usb3_calc_ramarea(int ram_size)
1612 {
1613         WARN_ON(ram_size > SZ_16K);
1614
1615         if (ram_size <= SZ_1K)
1616                 return PN_RAMMAP_RAMAREA_1KB;
1617         else if (ram_size <= SZ_2K)
1618                 return PN_RAMMAP_RAMAREA_2KB;
1619         else if (ram_size <= SZ_4K)
1620                 return PN_RAMMAP_RAMAREA_4KB;
1621         else if (ram_size <= SZ_8K)
1622                 return PN_RAMMAP_RAMAREA_8KB;
1623         else
1624                 return PN_RAMMAP_RAMAREA_16KB;
1625 }
1626
1627 static u32 usb3_calc_rammap_val(struct renesas_usb3_ep *usb3_ep,
1628                                 const struct usb_endpoint_descriptor *desc)
1629 {
1630         return usb3_ep->rammap_val | PN_RAMMAP_MPKT(usb_endpoint_maxp(desc));
1631 }
1632
1633 static int usb3_enable_pipe_n(struct renesas_usb3_ep *usb3_ep,
1634                               const struct usb_endpoint_descriptor *desc)
1635 {
1636         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1637         unsigned long flags;
1638
1639         usb3_ep->dir_in = usb_endpoint_dir_in(desc);
1640
1641         spin_lock_irqsave(&usb3->lock, flags);
1642         if (!usb3_pn_change(usb3, usb3_ep->num)) {
1643                 usb3_write_pn_mod(usb3_ep, desc);
1644                 usb3_write(usb3, usb3_calc_rammap_val(usb3_ep, desc),
1645                            USB3_PN_RAMMAP);
1646                 usb3_pn_con_clear(usb3);
1647                 usb3_set_bit(usb3, PN_CON_EN, USB3_PN_CON);
1648         }
1649         spin_unlock_irqrestore(&usb3->lock, flags);
1650
1651         return 0;
1652 }
1653
1654 static int usb3_disable_pipe_n(struct renesas_usb3_ep *usb3_ep)
1655 {
1656         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1657         unsigned long flags;
1658
1659         usb3_ep->halt = false;
1660
1661         spin_lock_irqsave(&usb3->lock, flags);
1662         if (!usb3_pn_change(usb3, usb3_ep->num)) {
1663                 usb3_write(usb3, 0, USB3_PN_RAMMAP);
1664                 usb3_clear_bit(usb3, PN_CON_EN, USB3_PN_CON);
1665         }
1666         spin_unlock_irqrestore(&usb3->lock, flags);
1667
1668         return 0;
1669 }
1670
1671 /*------- usb_ep_ops -----------------------------------------------------*/
1672 static int renesas_usb3_ep_enable(struct usb_ep *_ep,
1673                                   const struct usb_endpoint_descriptor *desc)
1674 {
1675         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
1676
1677         return usb3_enable_pipe_n(usb3_ep, desc);
1678 }
1679
1680 static int renesas_usb3_ep_disable(struct usb_ep *_ep)
1681 {
1682         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
1683         struct renesas_usb3_request *usb3_req;
1684
1685         do {
1686                 usb3_req = usb3_get_request(usb3_ep);
1687                 if (!usb3_req)
1688                         break;
1689                 usb3_request_done(usb3_ep, usb3_req, -ESHUTDOWN);
1690         } while (1);
1691
1692         return usb3_disable_pipe_n(usb3_ep);
1693 }
1694
1695 static struct usb_request *__renesas_usb3_ep_alloc_request(gfp_t gfp_flags)
1696 {
1697         struct renesas_usb3_request *usb3_req;
1698
1699         usb3_req = kzalloc(sizeof(struct renesas_usb3_request), gfp_flags);
1700         if (!usb3_req)
1701                 return NULL;
1702
1703         INIT_LIST_HEAD(&usb3_req->queue);
1704
1705         return &usb3_req->req;
1706 }
1707
1708 static void __renesas_usb3_ep_free_request(struct usb_request *_req)
1709 {
1710         struct renesas_usb3_request *usb3_req = usb_req_to_usb3_req(_req);
1711
1712         kfree(usb3_req);
1713 }
1714
1715 static struct usb_request *renesas_usb3_ep_alloc_request(struct usb_ep *_ep,
1716                                                          gfp_t gfp_flags)
1717 {
1718         return __renesas_usb3_ep_alloc_request(gfp_flags);
1719 }
1720
1721 static void renesas_usb3_ep_free_request(struct usb_ep *_ep,
1722                                          struct usb_request *_req)
1723 {
1724         __renesas_usb3_ep_free_request(_req);
1725 }
1726
1727 static int renesas_usb3_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
1728 {
1729         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
1730         struct renesas_usb3_request *usb3_req = usb_req_to_usb3_req(_req);
1731         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1732
1733         dev_dbg(usb3_to_dev(usb3), "ep_dequeue: ep%2d, %u\n", usb3_ep->num,
1734                 _req->length);
1735
1736         usb3_request_done_pipen(usb3, usb3_ep, usb3_req, -ECONNRESET);
1737
1738         return 0;
1739 }
1740
1741 static int renesas_usb3_ep_set_halt(struct usb_ep *_ep, int value)
1742 {
1743         return usb3_set_halt(usb_ep_to_usb3_ep(_ep), !!value, false);
1744 }
1745
1746 static int renesas_usb3_ep_set_wedge(struct usb_ep *_ep)
1747 {
1748         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
1749
1750         usb3_ep->wedge = true;
1751         return usb3_set_halt(usb3_ep, true, false);
1752 }
1753
1754 static void renesas_usb3_ep_fifo_flush(struct usb_ep *_ep)
1755 {
1756         struct renesas_usb3_ep *usb3_ep = usb_ep_to_usb3_ep(_ep);
1757         struct renesas_usb3 *usb3 = usb3_ep_to_usb3(usb3_ep);
1758         unsigned long flags;
1759
1760         if (usb3_ep->num) {
1761                 spin_lock_irqsave(&usb3->lock, flags);
1762                 if (!usb3_pn_change(usb3, usb3_ep->num)) {
1763                         usb3_pn_con_clear(usb3);
1764                         usb3_set_bit(usb3, PN_CON_EN, USB3_PN_CON);
1765                 }
1766                 spin_unlock_irqrestore(&usb3->lock, flags);
1767         } else {
1768                 usb3_p0_con_clear_buffer(usb3);
1769         }
1770 }
1771
1772 static struct usb_ep_ops renesas_usb3_ep_ops = {
1773         .enable         = renesas_usb3_ep_enable,
1774         .disable        = renesas_usb3_ep_disable,
1775
1776         .alloc_request  = renesas_usb3_ep_alloc_request,
1777         .free_request   = renesas_usb3_ep_free_request,
1778
1779         .queue          = renesas_usb3_ep_queue,
1780         .dequeue        = renesas_usb3_ep_dequeue,
1781
1782         .set_halt       = renesas_usb3_ep_set_halt,
1783         .set_wedge      = renesas_usb3_ep_set_wedge,
1784         .fifo_flush     = renesas_usb3_ep_fifo_flush,
1785 };
1786
1787 /*------- usb_gadget_ops -------------------------------------------------*/
1788 static int renesas_usb3_start(struct usb_gadget *gadget,
1789                               struct usb_gadget_driver *driver)
1790 {
1791         struct renesas_usb3 *usb3;
1792
1793         if (!driver || driver->max_speed < USB_SPEED_FULL ||
1794             !driver->setup)
1795                 return -EINVAL;
1796
1797         usb3 = gadget_to_renesas_usb3(gadget);
1798
1799         /* hook up the driver */
1800         usb3->driver = driver;
1801
1802         renesas_usb3_init_controller(usb3);
1803
1804         return 0;
1805 }
1806
1807 static int renesas_usb3_stop(struct usb_gadget *gadget)
1808 {
1809         struct renesas_usb3 *usb3 = gadget_to_renesas_usb3(gadget);
1810         unsigned long flags;
1811
1812         spin_lock_irqsave(&usb3->lock, flags);
1813         usb3->softconnect = false;
1814         usb3->gadget.speed = USB_SPEED_UNKNOWN;
1815         usb3->driver = NULL;
1816         renesas_usb3_stop_controller(usb3);
1817         spin_unlock_irqrestore(&usb3->lock, flags);
1818
1819         return 0;
1820 }
1821
1822 static int renesas_usb3_get_frame(struct usb_gadget *_gadget)
1823 {
1824         return -EOPNOTSUPP;
1825 }
1826
1827 static int renesas_usb3_pullup(struct usb_gadget *gadget, int is_on)
1828 {
1829         struct renesas_usb3 *usb3 = gadget_to_renesas_usb3(gadget);
1830
1831         usb3->softconnect = !!is_on;
1832
1833         return 0;
1834 }
1835
1836 static int renesas_usb3_set_selfpowered(struct usb_gadget *gadget, int is_self)
1837 {
1838         gadget->is_selfpowered = !!is_self;
1839
1840         return 0;
1841 }
1842
1843 static const struct usb_gadget_ops renesas_usb3_gadget_ops = {
1844         .get_frame              = renesas_usb3_get_frame,
1845         .udc_start              = renesas_usb3_start,
1846         .udc_stop               = renesas_usb3_stop,
1847         .pullup                 = renesas_usb3_pullup,
1848         .set_selfpowered        = renesas_usb3_set_selfpowered,
1849 };
1850
1851 static ssize_t role_store(struct device *dev, struct device_attribute *attr,
1852                           const char *buf, size_t count)
1853 {
1854         struct renesas_usb3 *usb3 = dev_get_drvdata(dev);
1855         bool new_mode_is_host;
1856
1857         if (!usb3->driver)
1858                 return -ENODEV;
1859
1860         if (!strncmp(buf, "host", strlen("host")))
1861                 new_mode_is_host = true;
1862         else if (!strncmp(buf, "peripheral", strlen("peripheral")))
1863                 new_mode_is_host = false;
1864         else
1865                 return -EINVAL;
1866
1867         if (new_mode_is_host == usb3_is_host(usb3))
1868                 return -EINVAL;
1869
1870         usb3_mode_config(usb3, new_mode_is_host, usb3_is_a_device(usb3));
1871
1872         return count;
1873 }
1874
1875 static ssize_t role_show(struct device *dev, struct device_attribute *attr,
1876                          char *buf)
1877 {
1878         struct renesas_usb3 *usb3 = dev_get_drvdata(dev);
1879
1880         if (!usb3->driver)
1881                 return -ENODEV;
1882
1883         return sprintf(buf, "%s\n", usb3_is_host(usb3) ? "host" : "peripheral");
1884 }
1885 static DEVICE_ATTR_RW(role);
1886
1887 /*------- platform_driver ------------------------------------------------*/
1888 static int renesas_usb3_remove(struct platform_device *pdev)
1889 {
1890         struct renesas_usb3 *usb3 = platform_get_drvdata(pdev);
1891
1892         device_remove_file(&pdev->dev, &dev_attr_role);
1893
1894         pm_runtime_put(&pdev->dev);
1895         pm_runtime_disable(&pdev->dev);
1896
1897         usb_del_gadget_udc(&usb3->gadget);
1898
1899         __renesas_usb3_ep_free_request(usb3->ep0_req);
1900
1901         return 0;
1902 }
1903
1904 static int renesas_usb3_init_ep(struct renesas_usb3 *usb3, struct device *dev,
1905                                 const struct renesas_usb3_priv *priv)
1906 {
1907         struct renesas_usb3_ep *usb3_ep;
1908         int i;
1909
1910         /* calculate num_usb3_eps from renesas_usb3_priv */
1911         usb3->num_usb3_eps = priv->ramsize_per_ramif * priv->num_ramif * 2 /
1912                              priv->ramsize_per_pipe + 1;
1913
1914         if (usb3->num_usb3_eps > USB3_MAX_NUM_PIPES)
1915                 usb3->num_usb3_eps = USB3_MAX_NUM_PIPES;
1916
1917         usb3->usb3_ep = devm_kzalloc(dev, sizeof(*usb3_ep) * usb3->num_usb3_eps,
1918                                      GFP_KERNEL);
1919         if (!usb3->usb3_ep)
1920                 return -ENOMEM;
1921
1922         dev_dbg(dev, "%s: num_usb3_eps = %d\n", __func__, usb3->num_usb3_eps);
1923         /*
1924          * This driver prepares pipes as follows:
1925          *  - odd pipes = IN pipe
1926          *  - even pipes = OUT pipe (except pipe 0)
1927          */
1928         usb3_for_each_ep(usb3_ep, usb3, i) {
1929                 snprintf(usb3_ep->ep_name, sizeof(usb3_ep->ep_name), "ep%d", i);
1930                 usb3_ep->usb3 = usb3;
1931                 usb3_ep->num = i;
1932                 usb3_ep->ep.name = usb3_ep->ep_name;
1933                 usb3_ep->ep.ops = &renesas_usb3_ep_ops;
1934                 INIT_LIST_HEAD(&usb3_ep->queue);
1935                 INIT_LIST_HEAD(&usb3_ep->ep.ep_list);
1936                 if (!i) {
1937                         /* for control pipe */
1938                         usb3->gadget.ep0 = &usb3_ep->ep;
1939                         usb_ep_set_maxpacket_limit(&usb3_ep->ep,
1940                                                 USB3_EP0_HSFS_MAX_PACKET_SIZE);
1941                         usb3_ep->ep.caps.type_control = true;
1942                         usb3_ep->ep.caps.dir_in = true;
1943                         usb3_ep->ep.caps.dir_out = true;
1944                         continue;
1945                 }
1946
1947                 /* for bulk or interrupt pipe */
1948                 usb_ep_set_maxpacket_limit(&usb3_ep->ep, ~0);
1949                 list_add_tail(&usb3_ep->ep.ep_list, &usb3->gadget.ep_list);
1950                 usb3_ep->ep.caps.type_bulk = true;
1951                 usb3_ep->ep.caps.type_int = true;
1952                 if (i & 1)
1953                         usb3_ep->ep.caps.dir_in = true;
1954                 else
1955                         usb3_ep->ep.caps.dir_out = true;
1956         }
1957
1958         return 0;
1959 }
1960
1961 static void renesas_usb3_init_ram(struct renesas_usb3 *usb3, struct device *dev,
1962                                   const struct renesas_usb3_priv *priv)
1963 {
1964         struct renesas_usb3_ep *usb3_ep;
1965         int i;
1966         u32 ramif[2], basead[2];        /* index 0 = for IN pipes */
1967         u32 *cur_ramif, *cur_basead;
1968         u32 val;
1969
1970         memset(ramif, 0, sizeof(ramif));
1971         memset(basead, 0, sizeof(basead));
1972
1973         /*
1974          * This driver prepares pipes as follows:
1975          *  - all pipes = the same size as "ramsize_per_pipe"
1976          * Please refer to the "Method of Specifying RAM Mapping"
1977          */
1978         usb3_for_each_ep(usb3_ep, usb3, i) {
1979                 if (!i)
1980                         continue;       /* out of scope if ep num = 0 */
1981                 if (usb3_ep->ep.caps.dir_in) {
1982                         cur_ramif = &ramif[0];
1983                         cur_basead = &basead[0];
1984                 } else {
1985                         cur_ramif = &ramif[1];
1986                         cur_basead = &basead[1];
1987                 }
1988
1989                 if (*cur_basead > priv->ramsize_per_ramif)
1990                         continue;       /* out of memory for IN or OUT pipe */
1991
1992                 /* calculate rammap_val */
1993                 val = PN_RAMMAP_RAMIF(*cur_ramif);
1994                 val |= usb3_calc_ramarea(priv->ramsize_per_pipe);
1995                 val |= PN_RAMMAP_BASEAD(*cur_basead);
1996                 usb3_ep->rammap_val = val;
1997
1998                 dev_dbg(dev, "ep%2d: val = %08x, ramif = %d, base = %x\n",
1999                         i, val, *cur_ramif, *cur_basead);
2000
2001                 /* update current ramif */
2002                 if (*cur_ramif + 1 == priv->num_ramif) {
2003                         *cur_ramif = 0;
2004                         *cur_basead += priv->ramsize_per_pipe;
2005                 } else {
2006                         (*cur_ramif)++;
2007                 }
2008         }
2009 }
2010
2011 static const struct renesas_usb3_priv renesas_usb3_priv_r8a7795 = {
2012         .ramsize_per_ramif = SZ_16K,
2013         .num_ramif = 2,
2014         .ramsize_per_pipe = SZ_4K,
2015         .workaround_for_vbus = true,
2016 };
2017
2018 static const struct of_device_id usb3_of_match[] = {
2019         {
2020                 .compatible = "renesas,r8a7795-usb3-peri",
2021                 .data = &renesas_usb3_priv_r8a7795,
2022         },
2023         { },
2024 };
2025 MODULE_DEVICE_TABLE(of, usb3_of_match);
2026
2027 static const unsigned int renesas_usb3_cable[] = {
2028         EXTCON_USB,
2029         EXTCON_USB_HOST,
2030         EXTCON_NONE,
2031 };
2032
2033 static int renesas_usb3_probe(struct platform_device *pdev)
2034 {
2035         struct renesas_usb3 *usb3;
2036         struct resource *res;
2037         const struct of_device_id *match;
2038         int irq, ret;
2039         const struct renesas_usb3_priv *priv;
2040
2041         match = of_match_node(usb3_of_match, pdev->dev.of_node);
2042         if (!match)
2043                 return -ENODEV;
2044         priv = match->data;
2045
2046         irq = platform_get_irq(pdev, 0);
2047         if (irq < 0)
2048                 return -ENODEV;
2049
2050         usb3 = devm_kzalloc(&pdev->dev, sizeof(*usb3), GFP_KERNEL);
2051         if (!usb3)
2052                 return -ENOMEM;
2053
2054         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2055         usb3->reg = devm_ioremap_resource(&pdev->dev, res);
2056         if (IS_ERR(usb3->reg))
2057                 return PTR_ERR(usb3->reg);
2058
2059         platform_set_drvdata(pdev, usb3);
2060         spin_lock_init(&usb3->lock);
2061
2062         usb3->gadget.ops = &renesas_usb3_gadget_ops;
2063         usb3->gadget.name = udc_name;
2064         usb3->gadget.max_speed = USB_SPEED_SUPER;
2065         INIT_LIST_HEAD(&usb3->gadget.ep_list);
2066         ret = renesas_usb3_init_ep(usb3, &pdev->dev, priv);
2067         if (ret < 0)
2068                 return ret;
2069         renesas_usb3_init_ram(usb3, &pdev->dev, priv);
2070
2071         ret = devm_request_irq(&pdev->dev, irq, renesas_usb3_irq, 0,
2072                                dev_name(&pdev->dev), usb3);
2073         if (ret < 0)
2074                 return ret;
2075
2076         INIT_WORK(&usb3->extcon_work, renesas_usb3_extcon_work);
2077         usb3->extcon = devm_extcon_dev_allocate(&pdev->dev, renesas_usb3_cable);
2078         if (IS_ERR(usb3->extcon))
2079                 return PTR_ERR(usb3->extcon);
2080
2081         ret = devm_extcon_dev_register(&pdev->dev, usb3->extcon);
2082         if (ret < 0) {
2083                 dev_err(&pdev->dev, "Failed to register extcon\n");
2084                 return ret;
2085         }
2086
2087         /* for ep0 handling */
2088         usb3->ep0_req = __renesas_usb3_ep_alloc_request(GFP_KERNEL);
2089         if (!usb3->ep0_req)
2090                 return -ENOMEM;
2091
2092         ret = usb_add_gadget_udc(&pdev->dev, &usb3->gadget);
2093         if (ret < 0)
2094                 goto err_add_udc;
2095
2096         ret = device_create_file(&pdev->dev, &dev_attr_role);
2097         if (ret < 0)
2098                 goto err_dev_create;
2099
2100         usb3->workaround_for_vbus = priv->workaround_for_vbus;
2101
2102         pm_runtime_enable(&pdev->dev);
2103         pm_runtime_get_sync(&pdev->dev);
2104
2105         dev_info(&pdev->dev, "probed\n");
2106
2107         return 0;
2108
2109 err_dev_create:
2110         usb_del_gadget_udc(&usb3->gadget);
2111
2112 err_add_udc:
2113         __renesas_usb3_ep_free_request(usb3->ep0_req);
2114
2115         return ret;
2116 }
2117
2118 static struct platform_driver renesas_usb3_driver = {
2119         .probe          = renesas_usb3_probe,
2120         .remove         = renesas_usb3_remove,
2121         .driver         = {
2122                 .name = (char *)udc_name,
2123                 .of_match_table = of_match_ptr(usb3_of_match),
2124         },
2125 };
2126 module_platform_driver(renesas_usb3_driver);
2127
2128 MODULE_DESCRIPTION("Renesas USB3.0 Peripheral driver");
2129 MODULE_LICENSE("GPL v2");
2130 MODULE_AUTHOR("Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>");
2131 MODULE_ALIAS("platform:renesas_usb3");