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