1 // SPDX-License-Identifier: GPL-2.0
3 * Renesas USB3.0 Peripheral driver (USB gadget)
5 * Copyright (C) 2015-2017 Renesas Electronics Corporation
8 #include <linux/debugfs.h>
9 #include <linux/delay.h>
10 #include <linux/dma-mapping.h>
11 #include <linux/err.h>
12 #include <linux/extcon-provider.h>
13 #include <linux/interrupt.h>
15 #include <linux/module.h>
16 #include <linux/of_device.h>
17 #include <linux/phy/phy.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/sys_soc.h>
23 #include <linux/uaccess.h>
24 #include <linux/usb/ch9.h>
25 #include <linux/usb/gadget.h>
27 /* register definitions */
28 #define USB3_AXI_INT_STA 0x008
29 #define USB3_AXI_INT_ENA 0x00c
30 #define USB3_DMA_INT_STA 0x010
31 #define USB3_DMA_INT_ENA 0x014
32 #define USB3_DMA_CH0_CON(n) (0x030 + ((n) - 1) * 0x10) /* n = 1 to 4 */
33 #define USB3_DMA_CH0_PRD_ADR(n) (0x034 + ((n) - 1) * 0x10) /* n = 1 to 4 */
34 #define USB3_USB_COM_CON 0x200
35 #define USB3_USB20_CON 0x204
36 #define USB3_USB30_CON 0x208
37 #define USB3_USB_STA 0x210
38 #define USB3_DRD_CON 0x218
39 #define USB3_USB_INT_STA_1 0x220
40 #define USB3_USB_INT_STA_2 0x224
41 #define USB3_USB_INT_ENA_1 0x228
42 #define USB3_USB_INT_ENA_2 0x22c
43 #define USB3_STUP_DAT_0 0x230
44 #define USB3_STUP_DAT_1 0x234
45 #define USB3_USB_OTG_STA 0x268
46 #define USB3_USB_OTG_INT_STA 0x26c
47 #define USB3_USB_OTG_INT_ENA 0x270
48 #define USB3_P0_MOD 0x280
49 #define USB3_P0_CON 0x288
50 #define USB3_P0_STA 0x28c
51 #define USB3_P0_INT_STA 0x290
52 #define USB3_P0_INT_ENA 0x294
53 #define USB3_P0_LNG 0x2a0
54 #define USB3_P0_READ 0x2a4
55 #define USB3_P0_WRITE 0x2a8
56 #define USB3_PIPE_COM 0x2b0
57 #define USB3_PN_MOD 0x2c0
58 #define USB3_PN_RAMMAP 0x2c4
59 #define USB3_PN_CON 0x2c8
60 #define USB3_PN_STA 0x2cc
61 #define USB3_PN_INT_STA 0x2d0
62 #define USB3_PN_INT_ENA 0x2d4
63 #define USB3_PN_LNG 0x2e0
64 #define USB3_PN_READ 0x2e4
65 #define USB3_PN_WRITE 0x2e8
66 #define USB3_SSIFCMD 0x340
68 /* AXI_INT_ENA and AXI_INT_STA */
69 #define AXI_INT_DMAINT BIT(31)
70 #define AXI_INT_EPCINT BIT(30)
71 /* PRD's n = from 1 to 4 */
72 #define AXI_INT_PRDEN_CLR_STA_SHIFT(n) (16 + (n) - 1)
73 #define AXI_INT_PRDERR_STA_SHIFT(n) (0 + (n) - 1)
74 #define AXI_INT_PRDEN_CLR_STA(n) (1 << AXI_INT_PRDEN_CLR_STA_SHIFT(n))
75 #define AXI_INT_PRDERR_STA(n) (1 << AXI_INT_PRDERR_STA_SHIFT(n))
77 /* DMA_INT_ENA and DMA_INT_STA */
78 #define DMA_INT(n) BIT(n)
81 #define DMA_CON_PIPE_DIR BIT(15) /* 1: In Transfer */
82 #define DMA_CON_PIPE_NO_SHIFT 8
83 #define DMA_CON_PIPE_NO_MASK GENMASK(12, DMA_CON_PIPE_NO_SHIFT)
84 #define DMA_COM_PIPE_NO(n) (((n) << DMA_CON_PIPE_NO_SHIFT) & \
86 #define DMA_CON_PRD_EN BIT(0)
89 #define LCLKSEL_LSEL BIT(18)
92 #define USB_COM_CON_CONF BIT(24)
93 #define USB_COM_CON_PN_WDATAIF_NL BIT(23)
94 #define USB_COM_CON_PN_RDATAIF_NL BIT(22)
95 #define USB_COM_CON_PN_LSTTR_PP BIT(21)
96 #define USB_COM_CON_SPD_MODE BIT(17)
97 #define USB_COM_CON_EP0_EN BIT(16)
98 #define USB_COM_CON_DEV_ADDR_SHIFT 8
99 #define USB_COM_CON_DEV_ADDR_MASK GENMASK(14, USB_COM_CON_DEV_ADDR_SHIFT)
100 #define USB_COM_CON_DEV_ADDR(n) (((n) << USB_COM_CON_DEV_ADDR_SHIFT) & \
101 USB_COM_CON_DEV_ADDR_MASK)
102 #define USB_COM_CON_RX_DETECTION BIT(1)
103 #define USB_COM_CON_PIPE_CLR BIT(0)
106 #define USB20_CON_B2_PUE BIT(31)
107 #define USB20_CON_B2_SUSPEND BIT(24)
108 #define USB20_CON_B2_CONNECT BIT(17)
109 #define USB20_CON_B2_TSTMOD_SHIFT 8
110 #define USB20_CON_B2_TSTMOD_MASK GENMASK(10, USB20_CON_B2_TSTMOD_SHIFT)
111 #define USB20_CON_B2_TSTMOD(n) (((n) << USB20_CON_B2_TSTMOD_SHIFT) & \
112 USB20_CON_B2_TSTMOD_MASK)
113 #define USB20_CON_B2_TSTMOD_EN BIT(0)
116 #define USB30_CON_POW_SEL_SHIFT 24
117 #define USB30_CON_POW_SEL_MASK GENMASK(26, USB30_CON_POW_SEL_SHIFT)
118 #define USB30_CON_POW_SEL_IN_U3 BIT(26)
119 #define USB30_CON_POW_SEL_IN_DISCON 0
120 #define USB30_CON_POW_SEL_P2_TO_P0 BIT(25)
121 #define USB30_CON_POW_SEL_P0_TO_P3 BIT(24)
122 #define USB30_CON_POW_SEL_P0_TO_P2 0
123 #define USB30_CON_B3_PLLWAKE BIT(23)
124 #define USB30_CON_B3_CONNECT BIT(17)
125 #define USB30_CON_B3_HOTRST_CMP BIT(1)
128 #define USB_STA_SPEED_MASK (BIT(2) | BIT(1))
129 #define USB_STA_SPEED_HS BIT(2)
130 #define USB_STA_SPEED_FS BIT(1)
131 #define USB_STA_SPEED_SS 0
132 #define USB_STA_VBUS_STA BIT(0)
135 #define DRD_CON_PERI_CON BIT(24)
136 #define DRD_CON_VBOUT BIT(0)
138 /* USB_INT_ENA_1 and USB_INT_STA_1 */
139 #define USB_INT_1_B3_PLLWKUP BIT(31)
140 #define USB_INT_1_B3_LUPSUCS BIT(30)
141 #define USB_INT_1_B3_DISABLE BIT(27)
142 #define USB_INT_1_B3_WRMRST BIT(21)
143 #define USB_INT_1_B3_HOTRST BIT(20)
144 #define USB_INT_1_B2_USBRST BIT(12)
145 #define USB_INT_1_B2_L1SPND BIT(11)
146 #define USB_INT_1_B2_SPND BIT(9)
147 #define USB_INT_1_B2_RSUM BIT(8)
148 #define USB_INT_1_SPEED BIT(1)
149 #define USB_INT_1_VBUS_CNG BIT(0)
151 /* USB_INT_ENA_2 and USB_INT_STA_2 */
152 #define USB_INT_2_PIPE(n) BIT(n)
154 /* USB_OTG_STA, USB_OTG_INT_STA and USB_OTG_INT_ENA */
155 #define USB_OTG_IDMON BIT(4)
158 #define P0_MOD_DIR BIT(6)
160 /* P0_CON and PN_CON */
161 #define PX_CON_BYTE_EN_MASK (BIT(10) | BIT(9))
162 #define PX_CON_BYTE_EN_SHIFT 9
163 #define PX_CON_BYTE_EN_BYTES(n) (((n) << PX_CON_BYTE_EN_SHIFT) & \
165 #define PX_CON_SEND BIT(8)
168 #define P0_CON_ST_RES_MASK (BIT(27) | BIT(26))
169 #define P0_CON_ST_RES_FORCE_STALL BIT(27)
170 #define P0_CON_ST_RES_NORMAL BIT(26)
171 #define P0_CON_ST_RES_FORCE_NRDY 0
172 #define P0_CON_OT_RES_MASK (BIT(25) | BIT(24))
173 #define P0_CON_OT_RES_FORCE_STALL BIT(25)
174 #define P0_CON_OT_RES_NORMAL BIT(24)
175 #define P0_CON_OT_RES_FORCE_NRDY 0
176 #define P0_CON_IN_RES_MASK (BIT(17) | BIT(16))
177 #define P0_CON_IN_RES_FORCE_STALL BIT(17)
178 #define P0_CON_IN_RES_NORMAL BIT(16)
179 #define P0_CON_IN_RES_FORCE_NRDY 0
180 #define P0_CON_RES_WEN BIT(7)
181 #define P0_CON_BCLR BIT(1)
183 /* P0_STA and PN_STA */
184 #define PX_STA_BUFSTS BIT(0)
186 /* P0_INT_ENA and P0_INT_STA */
187 #define P0_INT_STSED BIT(18)
188 #define P0_INT_STSST BIT(17)
189 #define P0_INT_SETUP BIT(16)
190 #define P0_INT_RCVNL BIT(8)
191 #define P0_INT_ERDY BIT(7)
192 #define P0_INT_FLOW BIT(6)
193 #define P0_INT_STALL BIT(2)
194 #define P0_INT_NRDY BIT(1)
195 #define P0_INT_BFRDY BIT(0)
196 #define P0_INT_ALL_BITS (P0_INT_STSED | P0_INT_SETUP | P0_INT_BFRDY)
199 #define PN_MOD_DIR BIT(6)
200 #define PN_MOD_TYPE_SHIFT 4
201 #define PN_MOD_TYPE_MASK GENMASK(5, PN_MOD_TYPE_SHIFT)
202 #define PN_MOD_TYPE(n) (((n) << PN_MOD_TYPE_SHIFT) & \
204 #define PN_MOD_EPNUM_MASK GENMASK(3, 0)
205 #define PN_MOD_EPNUM(n) ((n) & PN_MOD_EPNUM_MASK)
208 #define PN_RAMMAP_RAMAREA_SHIFT 29
209 #define PN_RAMMAP_RAMAREA_MASK GENMASK(31, PN_RAMMAP_RAMAREA_SHIFT)
210 #define PN_RAMMAP_RAMAREA_16KB BIT(31)
211 #define PN_RAMMAP_RAMAREA_8KB (BIT(30) | BIT(29))
212 #define PN_RAMMAP_RAMAREA_4KB BIT(30)
213 #define PN_RAMMAP_RAMAREA_2KB BIT(29)
214 #define PN_RAMMAP_RAMAREA_1KB 0
215 #define PN_RAMMAP_MPKT_SHIFT 16
216 #define PN_RAMMAP_MPKT_MASK GENMASK(26, PN_RAMMAP_MPKT_SHIFT)
217 #define PN_RAMMAP_MPKT(n) (((n) << PN_RAMMAP_MPKT_SHIFT) & \
219 #define PN_RAMMAP_RAMIF_SHIFT 14
220 #define PN_RAMMAP_RAMIF_MASK GENMASK(15, PN_RAMMAP_RAMIF_SHIFT)
221 #define PN_RAMMAP_RAMIF(n) (((n) << PN_RAMMAP_RAMIF_SHIFT) & \
222 PN_RAMMAP_RAMIF_MASK)
223 #define PN_RAMMAP_BASEAD_MASK GENMASK(13, 0)
224 #define PN_RAMMAP_BASEAD(offs) (((offs) >> 3) & PN_RAMMAP_BASEAD_MASK)
225 #define PN_RAMMAP_DATA(area, ramif, basead) ((PN_RAMMAP_##area) | \
226 (PN_RAMMAP_RAMIF(ramif)) | \
227 (PN_RAMMAP_BASEAD(basead)))
230 #define PN_CON_EN BIT(31)
231 #define PN_CON_DATAIF_EN BIT(30)
232 #define PN_CON_RES_MASK (BIT(17) | BIT(16))
233 #define PN_CON_RES_FORCE_STALL BIT(17)
234 #define PN_CON_RES_NORMAL BIT(16)
235 #define PN_CON_RES_FORCE_NRDY 0
236 #define PN_CON_LAST BIT(11)
237 #define PN_CON_RES_WEN BIT(7)
238 #define PN_CON_CLR BIT(0)
240 /* PN_INT_STA and PN_INT_ENA */
241 #define PN_INT_LSTTR BIT(4)
242 #define PN_INT_BFRDY BIT(0)
245 #define SSIFCMD_URES_U2 BIT(9)
246 #define SSIFCMD_URES_U1 BIT(8)
247 #define SSIFCMD_UDIR_U2 BIT(7)
248 #define SSIFCMD_UDIR_U1 BIT(6)
249 #define SSIFCMD_UREQ_U2 BIT(5)
250 #define SSIFCMD_UREQ_U1 BIT(4)
252 #define USB3_EP0_SS_MAX_PACKET_SIZE 512
253 #define USB3_EP0_HSFS_MAX_PACKET_SIZE 64
254 #define USB3_EP0_BUF_SIZE 8
255 #define USB3_MAX_NUM_PIPES 6 /* This includes PIPE 0 */
256 #define USB3_WAIT_US 3
257 #define USB3_DMA_NUM_SETTING_AREA 4
259 * To avoid double-meaning of "0" (xferred 65536 bytes or received zlp if
260 * buffer size is 65536), this driver uses the maximum size per a entry is
263 #define USB3_DMA_MAX_XFER_SIZE 32768
264 #define USB3_DMA_PRD_SIZE 4096
268 /* Physical Region Descriptor Table */
269 struct renesas_usb3_prd
{
271 #define USB3_PRD1_E BIT(30) /* the end of chain */
272 #define USB3_PRD1_U BIT(29) /* completion of transfer */
273 #define USB3_PRD1_D BIT(28) /* Error occurred */
274 #define USB3_PRD1_INT BIT(27) /* Interrupt occurred */
275 #define USB3_PRD1_LST BIT(26) /* Last Packet */
276 #define USB3_PRD1_B_INC BIT(24)
277 #define USB3_PRD1_MPS_8 0
278 #define USB3_PRD1_MPS_16 BIT(21)
279 #define USB3_PRD1_MPS_32 BIT(22)
280 #define USB3_PRD1_MPS_64 (BIT(22) | BIT(21))
281 #define USB3_PRD1_MPS_512 BIT(23)
282 #define USB3_PRD1_MPS_1024 (BIT(23) | BIT(21))
283 #define USB3_PRD1_MPS_RESERVED (BIT(23) | BIT(22) | BIT(21))
284 #define USB3_PRD1_SIZE_MASK GENMASK(15, 0)
288 #define USB3_DMA_NUM_PRD_ENTRIES (USB3_DMA_PRD_SIZE / \
289 sizeof(struct renesas_usb3_prd))
290 #define USB3_DMA_MAX_XFER_SIZE_ALL_PRDS (USB3_DMA_PRD_SIZE / \
291 sizeof(struct renesas_usb3_prd) * \
292 USB3_DMA_MAX_XFER_SIZE)
294 struct renesas_usb3_dma
{
295 struct renesas_usb3_prd
*prd
;
297 int num
; /* Setting area number (from 1 to 4) */
301 struct renesas_usb3_request
{
302 struct usb_request req
;
303 struct list_head queue
;
306 #define USB3_EP_NAME_SIZE 8
307 struct renesas_usb3_ep
{
309 struct renesas_usb3
*usb3
;
310 struct renesas_usb3_dma
*dma
;
312 char ep_name
[USB3_EP_NAME_SIZE
];
313 struct list_head queue
;
321 struct renesas_usb3_priv
{
322 int ramsize_per_ramif
; /* unit = bytes */
324 int ramsize_per_pipe
; /* unit = bytes */
325 bool workaround_for_vbus
; /* if true, don't check vbus signal */
328 struct renesas_usb3
{
331 struct usb_gadget gadget
;
332 struct usb_gadget_driver
*driver
;
333 struct extcon_dev
*extcon
;
334 struct work_struct extcon_work
;
336 struct dentry
*dentry
;
338 struct renesas_usb3_ep
*usb3_ep
;
341 struct renesas_usb3_dma dma
[USB3_DMA_NUM_SETTING_AREA
];
346 struct usb_request
*ep0_req
;
348 u8 ep0_buf
[USB3_EP0_BUF_SIZE
];
350 bool workaround_for_vbus
;
351 bool extcon_host
; /* check id and set EXTCON_USB_HOST */
352 bool extcon_usb
; /* check vbus and set EXTCON_USB */
353 bool forced_b_device
;
356 #define gadget_to_renesas_usb3(_gadget) \
357 container_of(_gadget, struct renesas_usb3, gadget)
358 #define renesas_usb3_to_gadget(renesas_usb3) (&renesas_usb3->gadget)
359 #define usb3_to_dev(_usb3) (_usb3->gadget.dev.parent)
361 #define usb_ep_to_usb3_ep(_ep) container_of(_ep, struct renesas_usb3_ep, ep)
362 #define usb3_ep_to_usb3(_usb3_ep) (_usb3_ep->usb3)
363 #define usb_req_to_usb3_req(_req) container_of(_req, \
364 struct renesas_usb3_request, req)
366 #define usb3_get_ep(usb3, n) ((usb3)->usb3_ep + (n))
367 #define usb3_for_each_ep(usb3_ep, usb3, i) \
368 for ((i) = 0, usb3_ep = usb3_get_ep(usb3, (i)); \
369 (i) < (usb3)->num_usb3_eps; \
370 (i)++, usb3_ep = usb3_get_ep(usb3, (i)))
372 #define usb3_get_dma(usb3, i) (&(usb3)->dma[i])
373 #define usb3_for_each_dma(usb3, dma, i) \
374 for ((i) = 0, dma = usb3_get_dma((usb3), (i)); \
375 (i) < USB3_DMA_NUM_SETTING_AREA; \
376 (i)++, dma = usb3_get_dma((usb3), (i)))
378 static const char udc_name
[] = "renesas_usb3";
380 static bool use_dma
= 1;
381 module_param(use_dma
, bool, 0644);
382 MODULE_PARM_DESC(use_dma
, "use dedicated DMAC");
384 static void usb3_write(struct renesas_usb3
*usb3
, u32 data
, u32 offs
)
386 iowrite32(data
, usb3
->reg
+ offs
);
389 static u32
usb3_read(struct renesas_usb3
*usb3
, u32 offs
)
391 return ioread32(usb3
->reg
+ offs
);
394 static void usb3_set_bit(struct renesas_usb3
*usb3
, u32 bits
, u32 offs
)
396 u32 val
= usb3_read(usb3
, offs
);
399 usb3_write(usb3
, val
, offs
);
402 static void usb3_clear_bit(struct renesas_usb3
*usb3
, u32 bits
, u32 offs
)
404 u32 val
= usb3_read(usb3
, offs
);
407 usb3_write(usb3
, val
, offs
);
410 static int usb3_wait(struct renesas_usb3
*usb3
, u32 reg
, u32 mask
,
415 for (i
= 0; i
< USB3_WAIT_US
; i
++) {
416 if ((usb3_read(usb3
, reg
) & mask
) == expected
)
421 dev_dbg(usb3_to_dev(usb3
), "%s: timed out (%8x, %08x, %08x)\n",
422 __func__
, reg
, mask
, expected
);
427 static void renesas_usb3_extcon_work(struct work_struct
*work
)
429 struct renesas_usb3
*usb3
= container_of(work
, struct renesas_usb3
,
432 extcon_set_state_sync(usb3
->extcon
, EXTCON_USB_HOST
, usb3
->extcon_host
);
433 extcon_set_state_sync(usb3
->extcon
, EXTCON_USB
, usb3
->extcon_usb
);
436 static void usb3_enable_irq_1(struct renesas_usb3
*usb3
, u32 bits
)
438 usb3_set_bit(usb3
, bits
, USB3_USB_INT_ENA_1
);
441 static void usb3_disable_irq_1(struct renesas_usb3
*usb3
, u32 bits
)
443 usb3_clear_bit(usb3
, bits
, USB3_USB_INT_ENA_1
);
446 static void usb3_enable_pipe_irq(struct renesas_usb3
*usb3
, int num
)
448 usb3_set_bit(usb3
, USB_INT_2_PIPE(num
), USB3_USB_INT_ENA_2
);
451 static void usb3_disable_pipe_irq(struct renesas_usb3
*usb3
, int num
)
453 usb3_clear_bit(usb3
, USB_INT_2_PIPE(num
), USB3_USB_INT_ENA_2
);
456 static bool usb3_is_host(struct renesas_usb3
*usb3
)
458 return !(usb3_read(usb3
, USB3_DRD_CON
) & DRD_CON_PERI_CON
);
461 static void usb3_init_axi_bridge(struct renesas_usb3
*usb3
)
464 usb3_write(usb3
, ~0, USB3_DMA_INT_STA
);
465 usb3_write(usb3
, 0, USB3_DMA_INT_ENA
);
466 usb3_set_bit(usb3
, AXI_INT_DMAINT
| AXI_INT_EPCINT
, USB3_AXI_INT_ENA
);
469 static void usb3_init_epc_registers(struct renesas_usb3
*usb3
)
471 usb3_write(usb3
, ~0, USB3_USB_INT_STA_1
);
472 usb3_enable_irq_1(usb3
, USB_INT_1_VBUS_CNG
);
475 static bool usb3_wakeup_usb2_phy(struct renesas_usb3
*usb3
)
477 if (!(usb3_read(usb3
, USB3_USB20_CON
) & USB20_CON_B2_SUSPEND
))
478 return true; /* already waked it up */
480 usb3_clear_bit(usb3
, USB20_CON_B2_SUSPEND
, USB3_USB20_CON
);
481 usb3_enable_irq_1(usb3
, USB_INT_1_B2_RSUM
);
486 static void usb3_usb2_pullup(struct renesas_usb3
*usb3
, int pullup
)
488 u32 bits
= USB20_CON_B2_PUE
| USB20_CON_B2_CONNECT
;
490 if (usb3
->softconnect
&& pullup
)
491 usb3_set_bit(usb3
, bits
, USB3_USB20_CON
);
493 usb3_clear_bit(usb3
, bits
, USB3_USB20_CON
);
496 static void usb3_set_test_mode(struct renesas_usb3
*usb3
)
498 u32 val
= usb3_read(usb3
, USB3_USB20_CON
);
500 val
&= ~USB20_CON_B2_TSTMOD_MASK
;
501 val
|= USB20_CON_B2_TSTMOD(usb3
->test_mode
);
502 usb3_write(usb3
, val
| USB20_CON_B2_TSTMOD_EN
, USB3_USB20_CON
);
503 if (!usb3
->test_mode
)
504 usb3_clear_bit(usb3
, USB20_CON_B2_TSTMOD_EN
, USB3_USB20_CON
);
507 static void usb3_start_usb2_connection(struct renesas_usb3
*usb3
)
509 usb3
->disabled_count
++;
510 usb3_set_bit(usb3
, USB_COM_CON_EP0_EN
, USB3_USB_COM_CON
);
511 usb3_set_bit(usb3
, USB_COM_CON_SPD_MODE
, USB3_USB_COM_CON
);
512 usb3_usb2_pullup(usb3
, 1);
515 static int usb3_is_usb3_phy_in_u3(struct renesas_usb3
*usb3
)
517 return usb3_read(usb3
, USB3_USB30_CON
) & USB30_CON_POW_SEL_IN_U3
;
520 static bool usb3_wakeup_usb3_phy(struct renesas_usb3
*usb3
)
522 if (!usb3_is_usb3_phy_in_u3(usb3
))
523 return true; /* already waked it up */
525 usb3_set_bit(usb3
, USB30_CON_B3_PLLWAKE
, USB3_USB30_CON
);
526 usb3_enable_irq_1(usb3
, USB_INT_1_B3_PLLWKUP
);
531 static u16
usb3_feature_get_un_enabled(struct renesas_usb3
*usb3
)
533 u32 mask_u2
= SSIFCMD_UDIR_U2
| SSIFCMD_UREQ_U2
;
534 u32 mask_u1
= SSIFCMD_UDIR_U1
| SSIFCMD_UREQ_U1
;
535 u32 val
= usb3_read(usb3
, USB3_SSIFCMD
);
538 /* Enables {U2,U1} if the bits of UDIR and UREQ are set to 0 */
539 if (!(val
& mask_u2
))
540 ret
|= 1 << USB_DEV_STAT_U2_ENABLED
;
541 if (!(val
& mask_u1
))
542 ret
|= 1 << USB_DEV_STAT_U1_ENABLED
;
547 static void usb3_feature_u2_enable(struct renesas_usb3
*usb3
, bool enable
)
549 u32 bits
= SSIFCMD_UDIR_U2
| SSIFCMD_UREQ_U2
;
551 /* Enables U2 if the bits of UDIR and UREQ are set to 0 */
553 usb3_clear_bit(usb3
, bits
, USB3_SSIFCMD
);
555 usb3_set_bit(usb3
, bits
, USB3_SSIFCMD
);
558 static void usb3_feature_u1_enable(struct renesas_usb3
*usb3
, bool enable
)
560 u32 bits
= SSIFCMD_UDIR_U1
| SSIFCMD_UREQ_U1
;
562 /* Enables U1 if the bits of UDIR and UREQ are set to 0 */
564 usb3_clear_bit(usb3
, bits
, USB3_SSIFCMD
);
566 usb3_set_bit(usb3
, bits
, USB3_SSIFCMD
);
569 static void usb3_start_operation_for_usb3(struct renesas_usb3
*usb3
)
571 usb3_set_bit(usb3
, USB_COM_CON_EP0_EN
, USB3_USB_COM_CON
);
572 usb3_clear_bit(usb3
, USB_COM_CON_SPD_MODE
, USB3_USB_COM_CON
);
573 usb3_set_bit(usb3
, USB30_CON_B3_CONNECT
, USB3_USB30_CON
);
576 static void usb3_start_usb3_connection(struct renesas_usb3
*usb3
)
578 usb3_start_operation_for_usb3(usb3
);
579 usb3_set_bit(usb3
, USB_COM_CON_RX_DETECTION
, USB3_USB_COM_CON
);
581 usb3_enable_irq_1(usb3
, USB_INT_1_B3_LUPSUCS
| USB_INT_1_B3_DISABLE
|
585 static void usb3_stop_usb3_connection(struct renesas_usb3
*usb3
)
587 usb3_clear_bit(usb3
, USB30_CON_B3_CONNECT
, USB3_USB30_CON
);
590 static void usb3_transition_to_default_state(struct renesas_usb3
*usb3
,
593 usb3_set_bit(usb3
, USB_INT_2_PIPE(0), USB3_USB_INT_ENA_2
);
594 usb3_write(usb3
, P0_INT_ALL_BITS
, USB3_P0_INT_STA
);
595 usb3_set_bit(usb3
, P0_INT_ALL_BITS
, USB3_P0_INT_ENA
);
598 usb3_enable_irq_1(usb3
, USB_INT_1_B3_WRMRST
|
599 USB_INT_1_B3_HOTRST
);
601 usb3_enable_irq_1(usb3
, USB_INT_1_B2_SPND
|
602 USB_INT_1_B2_L1SPND
| USB_INT_1_B2_USBRST
);
605 static void usb3_connect(struct renesas_usb3
*usb3
)
607 if (usb3_wakeup_usb3_phy(usb3
))
608 usb3_start_usb3_connection(usb3
);
611 static void usb3_reset_epc(struct renesas_usb3
*usb3
)
613 usb3_clear_bit(usb3
, USB_COM_CON_CONF
, USB3_USB_COM_CON
);
614 usb3_clear_bit(usb3
, USB_COM_CON_EP0_EN
, USB3_USB_COM_CON
);
615 usb3_set_bit(usb3
, USB_COM_CON_PIPE_CLR
, USB3_USB_COM_CON
);
617 usb3_set_test_mode(usb3
);
620 static void usb3_disconnect(struct renesas_usb3
*usb3
)
622 usb3
->disabled_count
= 0;
623 usb3_usb2_pullup(usb3
, 0);
624 usb3_clear_bit(usb3
, USB30_CON_B3_CONNECT
, USB3_USB30_CON
);
625 usb3_reset_epc(usb3
);
626 usb3_disable_irq_1(usb3
, USB_INT_1_B2_RSUM
| USB_INT_1_B3_PLLWKUP
|
627 USB_INT_1_B3_LUPSUCS
| USB_INT_1_B3_DISABLE
|
628 USB_INT_1_SPEED
| USB_INT_1_B3_WRMRST
|
629 USB_INT_1_B3_HOTRST
| USB_INT_1_B2_SPND
|
630 USB_INT_1_B2_L1SPND
| USB_INT_1_B2_USBRST
);
631 usb3_clear_bit(usb3
, USB_COM_CON_SPD_MODE
, USB3_USB_COM_CON
);
632 usb3_init_epc_registers(usb3
);
635 usb3
->driver
->disconnect(&usb3
->gadget
);
638 static void usb3_check_vbus(struct renesas_usb3
*usb3
)
640 if (usb3
->workaround_for_vbus
) {
643 usb3
->extcon_usb
= !!(usb3_read(usb3
, USB3_USB_STA
) &
645 if (usb3
->extcon_usb
)
648 usb3_disconnect(usb3
);
650 schedule_work(&usb3
->extcon_work
);
654 static void usb3_set_mode(struct renesas_usb3
*usb3
, bool host
)
657 usb3_clear_bit(usb3
, DRD_CON_PERI_CON
, USB3_DRD_CON
);
659 usb3_set_bit(usb3
, DRD_CON_PERI_CON
, USB3_DRD_CON
);
662 static void usb3_vbus_out(struct renesas_usb3
*usb3
, bool enable
)
665 usb3_set_bit(usb3
, DRD_CON_VBOUT
, USB3_DRD_CON
);
667 usb3_clear_bit(usb3
, DRD_CON_VBOUT
, USB3_DRD_CON
);
670 static void usb3_mode_config(struct renesas_usb3
*usb3
, bool host
, bool a_dev
)
674 spin_lock_irqsave(&usb3
->lock
, flags
);
675 usb3_set_mode(usb3
, host
);
676 usb3_vbus_out(usb3
, a_dev
);
677 /* for A-Peripheral or forced B-device mode */
678 if ((!host
&& a_dev
) ||
679 (usb3
->workaround_for_vbus
&& usb3
->forced_b_device
))
681 spin_unlock_irqrestore(&usb3
->lock
, flags
);
684 static bool usb3_is_a_device(struct renesas_usb3
*usb3
)
686 return !(usb3_read(usb3
, USB3_USB_OTG_STA
) & USB_OTG_IDMON
);
689 static void usb3_check_id(struct renesas_usb3
*usb3
)
691 usb3
->extcon_host
= usb3_is_a_device(usb3
);
693 if (usb3
->extcon_host
&& !usb3
->forced_b_device
)
694 usb3_mode_config(usb3
, true, true);
696 usb3_mode_config(usb3
, false, false);
698 schedule_work(&usb3
->extcon_work
);
701 static void renesas_usb3_init_controller(struct renesas_usb3
*usb3
)
703 usb3_init_axi_bridge(usb3
);
704 usb3_init_epc_registers(usb3
);
705 usb3_set_bit(usb3
, USB_COM_CON_PN_WDATAIF_NL
|
706 USB_COM_CON_PN_RDATAIF_NL
| USB_COM_CON_PN_LSTTR_PP
,
708 usb3_write(usb3
, USB_OTG_IDMON
, USB3_USB_OTG_INT_STA
);
709 usb3_write(usb3
, USB_OTG_IDMON
, USB3_USB_OTG_INT_ENA
);
712 usb3_check_vbus(usb3
);
715 static void renesas_usb3_stop_controller(struct renesas_usb3
*usb3
)
717 usb3_disconnect(usb3
);
718 usb3_write(usb3
, 0, USB3_P0_INT_ENA
);
719 usb3_write(usb3
, 0, USB3_USB_OTG_INT_ENA
);
720 usb3_write(usb3
, 0, USB3_USB_INT_ENA_1
);
721 usb3_write(usb3
, 0, USB3_USB_INT_ENA_2
);
722 usb3_write(usb3
, 0, USB3_AXI_INT_ENA
);
725 static void usb3_irq_epc_int_1_pll_wakeup(struct renesas_usb3
*usb3
)
727 usb3_disable_irq_1(usb3
, USB_INT_1_B3_PLLWKUP
);
728 usb3_clear_bit(usb3
, USB30_CON_B3_PLLWAKE
, USB3_USB30_CON
);
729 usb3_start_usb3_connection(usb3
);
732 static void usb3_irq_epc_int_1_linkup_success(struct renesas_usb3
*usb3
)
734 usb3_transition_to_default_state(usb3
, true);
737 static void usb3_irq_epc_int_1_resume(struct renesas_usb3
*usb3
)
739 usb3_disable_irq_1(usb3
, USB_INT_1_B2_RSUM
);
740 usb3_start_usb2_connection(usb3
);
741 usb3_transition_to_default_state(usb3
, false);
744 static void usb3_irq_epc_int_1_disable(struct renesas_usb3
*usb3
)
746 usb3_stop_usb3_connection(usb3
);
747 if (usb3_wakeup_usb2_phy(usb3
))
748 usb3_irq_epc_int_1_resume(usb3
);
751 static void usb3_irq_epc_int_1_bus_reset(struct renesas_usb3
*usb3
)
753 usb3_reset_epc(usb3
);
754 if (usb3
->disabled_count
< 3)
755 usb3_start_usb3_connection(usb3
);
757 usb3_start_usb2_connection(usb3
);
760 static void usb3_irq_epc_int_1_vbus_change(struct renesas_usb3
*usb3
)
762 usb3_check_vbus(usb3
);
765 static void usb3_irq_epc_int_1_hot_reset(struct renesas_usb3
*usb3
)
767 usb3_reset_epc(usb3
);
768 usb3_set_bit(usb3
, USB_COM_CON_EP0_EN
, USB3_USB_COM_CON
);
770 /* This bit shall be set within 12ms from the start of HotReset */
771 usb3_set_bit(usb3
, USB30_CON_B3_HOTRST_CMP
, USB3_USB30_CON
);
774 static void usb3_irq_epc_int_1_warm_reset(struct renesas_usb3
*usb3
)
776 usb3_reset_epc(usb3
);
777 usb3_set_bit(usb3
, USB_COM_CON_EP0_EN
, USB3_USB_COM_CON
);
779 usb3_start_operation_for_usb3(usb3
);
780 usb3_enable_irq_1(usb3
, USB_INT_1_SPEED
);
783 static void usb3_irq_epc_int_1_speed(struct renesas_usb3
*usb3
)
785 u32 speed
= usb3_read(usb3
, USB3_USB_STA
) & USB_STA_SPEED_MASK
;
788 case USB_STA_SPEED_SS
:
789 usb3
->gadget
.speed
= USB_SPEED_SUPER
;
791 case USB_STA_SPEED_HS
:
792 usb3
->gadget
.speed
= USB_SPEED_HIGH
;
794 case USB_STA_SPEED_FS
:
795 usb3
->gadget
.speed
= USB_SPEED_FULL
;
798 usb3
->gadget
.speed
= USB_SPEED_UNKNOWN
;
803 static void usb3_irq_epc_int_1(struct renesas_usb3
*usb3
, u32 int_sta_1
)
805 if (int_sta_1
& USB_INT_1_B3_PLLWKUP
)
806 usb3_irq_epc_int_1_pll_wakeup(usb3
);
808 if (int_sta_1
& USB_INT_1_B3_LUPSUCS
)
809 usb3_irq_epc_int_1_linkup_success(usb3
);
811 if (int_sta_1
& USB_INT_1_B3_HOTRST
)
812 usb3_irq_epc_int_1_hot_reset(usb3
);
814 if (int_sta_1
& USB_INT_1_B3_WRMRST
)
815 usb3_irq_epc_int_1_warm_reset(usb3
);
817 if (int_sta_1
& USB_INT_1_B3_DISABLE
)
818 usb3_irq_epc_int_1_disable(usb3
);
820 if (int_sta_1
& USB_INT_1_B2_USBRST
)
821 usb3_irq_epc_int_1_bus_reset(usb3
);
823 if (int_sta_1
& USB_INT_1_B2_RSUM
)
824 usb3_irq_epc_int_1_resume(usb3
);
826 if (int_sta_1
& USB_INT_1_SPEED
)
827 usb3_irq_epc_int_1_speed(usb3
);
829 if (int_sta_1
& USB_INT_1_VBUS_CNG
)
830 usb3_irq_epc_int_1_vbus_change(usb3
);
833 static struct renesas_usb3_request
*__usb3_get_request(struct renesas_usb3_ep
836 return list_first_entry_or_null(&usb3_ep
->queue
,
837 struct renesas_usb3_request
, queue
);
840 static struct renesas_usb3_request
*usb3_get_request(struct renesas_usb3_ep
843 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
844 struct renesas_usb3_request
*usb3_req
;
847 spin_lock_irqsave(&usb3
->lock
, flags
);
848 usb3_req
= __usb3_get_request(usb3_ep
);
849 spin_unlock_irqrestore(&usb3
->lock
, flags
);
854 static void __usb3_request_done(struct renesas_usb3_ep
*usb3_ep
,
855 struct renesas_usb3_request
*usb3_req
,
858 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
860 dev_dbg(usb3_to_dev(usb3
), "giveback: ep%2d, %u, %u, %d\n",
861 usb3_ep
->num
, usb3_req
->req
.length
, usb3_req
->req
.actual
,
863 usb3_req
->req
.status
= status
;
864 usb3_ep
->started
= false;
865 list_del_init(&usb3_req
->queue
);
866 spin_unlock(&usb3
->lock
);
867 usb_gadget_giveback_request(&usb3_ep
->ep
, &usb3_req
->req
);
868 spin_lock(&usb3
->lock
);
871 static void usb3_request_done(struct renesas_usb3_ep
*usb3_ep
,
872 struct renesas_usb3_request
*usb3_req
, int status
)
874 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
877 spin_lock_irqsave(&usb3
->lock
, flags
);
878 __usb3_request_done(usb3_ep
, usb3_req
, status
);
879 spin_unlock_irqrestore(&usb3
->lock
, flags
);
882 static void usb3_irq_epc_pipe0_status_end(struct renesas_usb3
*usb3
)
884 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, 0);
885 struct renesas_usb3_request
*usb3_req
= usb3_get_request(usb3_ep
);
888 usb3_request_done(usb3_ep
, usb3_req
, 0);
890 usb3_set_test_mode(usb3
);
893 static void usb3_get_setup_data(struct renesas_usb3
*usb3
,
894 struct usb_ctrlrequest
*ctrl
)
896 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, 0);
897 u32
*data
= (u32
*)ctrl
;
899 *data
++ = usb3_read(usb3
, USB3_STUP_DAT_0
);
900 *data
= usb3_read(usb3
, USB3_STUP_DAT_1
);
902 /* update this driver's flag */
903 usb3_ep
->dir_in
= !!(ctrl
->bRequestType
& USB_DIR_IN
);
906 static void usb3_set_p0_con_update_res(struct renesas_usb3
*usb3
, u32 res
)
908 u32 val
= usb3_read(usb3
, USB3_P0_CON
);
910 val
&= ~(P0_CON_ST_RES_MASK
| P0_CON_OT_RES_MASK
| P0_CON_IN_RES_MASK
);
911 val
|= res
| P0_CON_RES_WEN
;
912 usb3_write(usb3
, val
, USB3_P0_CON
);
915 static void usb3_set_p0_con_for_ctrl_read_data(struct renesas_usb3
*usb3
)
917 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_FORCE_NRDY
|
918 P0_CON_OT_RES_FORCE_STALL
|
919 P0_CON_IN_RES_NORMAL
);
922 static void usb3_set_p0_con_for_ctrl_read_status(struct renesas_usb3
*usb3
)
924 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_NORMAL
|
925 P0_CON_OT_RES_FORCE_STALL
|
926 P0_CON_IN_RES_NORMAL
);
929 static void usb3_set_p0_con_for_ctrl_write_data(struct renesas_usb3
*usb3
)
931 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_FORCE_NRDY
|
932 P0_CON_OT_RES_NORMAL
|
933 P0_CON_IN_RES_FORCE_STALL
);
936 static void usb3_set_p0_con_for_ctrl_write_status(struct renesas_usb3
*usb3
)
938 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_NORMAL
|
939 P0_CON_OT_RES_NORMAL
|
940 P0_CON_IN_RES_FORCE_STALL
);
943 static void usb3_set_p0_con_for_no_data(struct renesas_usb3
*usb3
)
945 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_NORMAL
|
946 P0_CON_OT_RES_FORCE_STALL
|
947 P0_CON_IN_RES_FORCE_STALL
);
950 static void usb3_set_p0_con_stall(struct renesas_usb3
*usb3
)
952 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_FORCE_STALL
|
953 P0_CON_OT_RES_FORCE_STALL
|
954 P0_CON_IN_RES_FORCE_STALL
);
957 static void usb3_set_p0_con_stop(struct renesas_usb3
*usb3
)
959 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_FORCE_NRDY
|
960 P0_CON_OT_RES_FORCE_NRDY
|
961 P0_CON_IN_RES_FORCE_NRDY
);
964 static int usb3_pn_change(struct renesas_usb3
*usb3
, int num
)
966 if (num
== 0 || num
> usb3
->num_usb3_eps
)
969 usb3_write(usb3
, num
, USB3_PIPE_COM
);
974 static void usb3_set_pn_con_update_res(struct renesas_usb3
*usb3
, u32 res
)
976 u32 val
= usb3_read(usb3
, USB3_PN_CON
);
978 val
&= ~PN_CON_RES_MASK
;
979 val
|= res
& PN_CON_RES_MASK
;
980 val
|= PN_CON_RES_WEN
;
981 usb3_write(usb3
, val
, USB3_PN_CON
);
984 static void usb3_pn_start(struct renesas_usb3
*usb3
)
986 usb3_set_pn_con_update_res(usb3
, PN_CON_RES_NORMAL
);
989 static void usb3_pn_stop(struct renesas_usb3
*usb3
)
991 usb3_set_pn_con_update_res(usb3
, PN_CON_RES_FORCE_NRDY
);
994 static void usb3_pn_stall(struct renesas_usb3
*usb3
)
996 usb3_set_pn_con_update_res(usb3
, PN_CON_RES_FORCE_STALL
);
999 static int usb3_pn_con_clear(struct renesas_usb3
*usb3
)
1001 usb3_set_bit(usb3
, PN_CON_CLR
, USB3_PN_CON
);
1003 return usb3_wait(usb3
, USB3_PN_CON
, PN_CON_CLR
, 0);
1006 static bool usb3_is_transfer_complete(struct renesas_usb3_ep
*usb3_ep
,
1007 struct renesas_usb3_request
*usb3_req
)
1009 struct usb_request
*req
= &usb3_req
->req
;
1011 if ((!req
->zero
&& req
->actual
== req
->length
) ||
1012 (req
->actual
% usb3_ep
->ep
.maxpacket
) || (req
->length
== 0))
1018 static int usb3_wait_pipe_status(struct renesas_usb3_ep
*usb3_ep
, u32 mask
)
1020 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1021 u32 sta_reg
= usb3_ep
->num
? USB3_PN_STA
: USB3_P0_STA
;
1023 return usb3_wait(usb3
, sta_reg
, mask
, mask
);
1026 static void usb3_set_px_con_send(struct renesas_usb3_ep
*usb3_ep
, int bytes
,
1029 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1030 u32 con_reg
= usb3_ep
->num
? USB3_PN_CON
: USB3_P0_CON
;
1031 u32 val
= usb3_read(usb3
, con_reg
);
1033 val
|= PX_CON_SEND
| PX_CON_BYTE_EN_BYTES(bytes
);
1034 val
|= (usb3_ep
->num
&& last
) ? PN_CON_LAST
: 0;
1035 usb3_write(usb3
, val
, con_reg
);
1038 static int usb3_write_pipe(struct renesas_usb3_ep
*usb3_ep
,
1039 struct renesas_usb3_request
*usb3_req
,
1042 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1044 int len
= min_t(unsigned, usb3_req
->req
.length
- usb3_req
->req
.actual
,
1045 usb3_ep
->ep
.maxpacket
);
1046 u8
*buf
= usb3_req
->req
.buf
+ usb3_req
->req
.actual
;
1048 bool is_last
= !len
? true : false;
1050 if (usb3_wait_pipe_status(usb3_ep
, PX_STA_BUFSTS
) < 0)
1053 /* Update gadget driver parameter */
1054 usb3_req
->req
.actual
+= len
;
1056 /* Write data to the register */
1058 iowrite32_rep(usb3
->reg
+ fifo_reg
, buf
, len
/ 4);
1059 buf
+= (len
/ 4) * 4;
1060 len
%= 4; /* update len to use usb3_set_pX_con_send() */
1064 for (i
= 0; i
< len
; i
++)
1065 tmp
|= buf
[i
] << (8 * i
);
1066 usb3_write(usb3
, tmp
, fifo_reg
);
1070 is_last
= usb3_is_transfer_complete(usb3_ep
, usb3_req
);
1072 usb3_set_px_con_send(usb3_ep
, len
, is_last
);
1074 return is_last
? 0 : -EAGAIN
;
1077 static u32
usb3_get_received_length(struct renesas_usb3_ep
*usb3_ep
)
1079 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1080 u32 lng_reg
= usb3_ep
->num
? USB3_PN_LNG
: USB3_P0_LNG
;
1082 return usb3_read(usb3
, lng_reg
);
1085 static int usb3_read_pipe(struct renesas_usb3_ep
*usb3_ep
,
1086 struct renesas_usb3_request
*usb3_req
, u32 fifo_reg
)
1088 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1090 int len
= min_t(unsigned, usb3_req
->req
.length
- usb3_req
->req
.actual
,
1091 usb3_get_received_length(usb3_ep
));
1092 u8
*buf
= usb3_req
->req
.buf
+ usb3_req
->req
.actual
;
1098 /* Update gadget driver parameter */
1099 usb3_req
->req
.actual
+= len
;
1101 /* Read data from the register */
1103 ioread32_rep(usb3
->reg
+ fifo_reg
, buf
, len
/ 4);
1104 buf
+= (len
/ 4) * 4;
1109 tmp
= usb3_read(usb3
, fifo_reg
);
1110 for (i
= 0; i
< len
; i
++)
1111 buf
[i
] = (tmp
>> (8 * i
)) & 0xff;
1114 return usb3_is_transfer_complete(usb3_ep
, usb3_req
) ? 0 : -EAGAIN
;
1117 static void usb3_set_status_stage(struct renesas_usb3_ep
*usb3_ep
,
1118 struct renesas_usb3_request
*usb3_req
)
1120 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1122 if (usb3_ep
->dir_in
) {
1123 usb3_set_p0_con_for_ctrl_read_status(usb3
);
1125 if (!usb3_req
->req
.length
)
1126 usb3_set_p0_con_for_no_data(usb3
);
1128 usb3_set_p0_con_for_ctrl_write_status(usb3
);
1132 static void usb3_p0_xfer(struct renesas_usb3_ep
*usb3_ep
,
1133 struct renesas_usb3_request
*usb3_req
)
1137 if (usb3_ep
->dir_in
)
1138 ret
= usb3_write_pipe(usb3_ep
, usb3_req
, USB3_P0_WRITE
);
1140 ret
= usb3_read_pipe(usb3_ep
, usb3_req
, USB3_P0_READ
);
1143 usb3_set_status_stage(usb3_ep
, usb3_req
);
1146 static void usb3_start_pipe0(struct renesas_usb3_ep
*usb3_ep
,
1147 struct renesas_usb3_request
*usb3_req
)
1149 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1151 if (usb3_ep
->started
)
1154 usb3_ep
->started
= true;
1156 if (usb3_ep
->dir_in
) {
1157 usb3_set_bit(usb3
, P0_MOD_DIR
, USB3_P0_MOD
);
1158 usb3_set_p0_con_for_ctrl_read_data(usb3
);
1160 usb3_clear_bit(usb3
, P0_MOD_DIR
, USB3_P0_MOD
);
1161 if (usb3_req
->req
.length
)
1162 usb3_set_p0_con_for_ctrl_write_data(usb3
);
1165 usb3_p0_xfer(usb3_ep
, usb3_req
);
1168 static void usb3_enable_dma_pipen(struct renesas_usb3
*usb3
)
1170 usb3_set_bit(usb3
, PN_CON_DATAIF_EN
, USB3_PN_CON
);
1173 static void usb3_disable_dma_pipen(struct renesas_usb3
*usb3
)
1175 usb3_clear_bit(usb3
, PN_CON_DATAIF_EN
, USB3_PN_CON
);
1178 static void usb3_enable_dma_irq(struct renesas_usb3
*usb3
, int num
)
1180 usb3_set_bit(usb3
, DMA_INT(num
), USB3_DMA_INT_ENA
);
1183 static void usb3_disable_dma_irq(struct renesas_usb3
*usb3
, int num
)
1185 usb3_clear_bit(usb3
, DMA_INT(num
), USB3_DMA_INT_ENA
);
1188 static u32
usb3_dma_mps_to_prd_word1(struct renesas_usb3_ep
*usb3_ep
)
1190 switch (usb3_ep
->ep
.maxpacket
) {
1192 return USB3_PRD1_MPS_8
;
1194 return USB3_PRD1_MPS_16
;
1196 return USB3_PRD1_MPS_32
;
1198 return USB3_PRD1_MPS_64
;
1200 return USB3_PRD1_MPS_512
;
1202 return USB3_PRD1_MPS_1024
;
1204 return USB3_PRD1_MPS_RESERVED
;
1208 static bool usb3_dma_get_setting_area(struct renesas_usb3_ep
*usb3_ep
,
1209 struct renesas_usb3_request
*usb3_req
)
1211 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1212 struct renesas_usb3_dma
*dma
;
1216 if (usb3_req
->req
.length
> USB3_DMA_MAX_XFER_SIZE_ALL_PRDS
) {
1217 dev_dbg(usb3_to_dev(usb3
), "%s: the length is too big (%d)\n",
1218 __func__
, usb3_req
->req
.length
);
1222 /* The driver doesn't handle zero-length packet via dmac */
1223 if (!usb3_req
->req
.length
)
1226 if (usb3_dma_mps_to_prd_word1(usb3_ep
) == USB3_PRD1_MPS_RESERVED
)
1229 usb3_for_each_dma(usb3
, dma
, i
) {
1233 if (usb_gadget_map_request(&usb3
->gadget
, &usb3_req
->req
,
1234 usb3_ep
->dir_in
) < 0)
1246 static void usb3_dma_put_setting_area(struct renesas_usb3_ep
*usb3_ep
,
1247 struct renesas_usb3_request
*usb3_req
)
1249 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1251 struct renesas_usb3_dma
*dma
;
1253 usb3_for_each_dma(usb3
, dma
, i
) {
1254 if (usb3_ep
->dma
== dma
) {
1255 usb_gadget_unmap_request(&usb3
->gadget
, &usb3_req
->req
,
1258 usb3_ep
->dma
= NULL
;
1264 static void usb3_dma_fill_prd(struct renesas_usb3_ep
*usb3_ep
,
1265 struct renesas_usb3_request
*usb3_req
)
1267 struct renesas_usb3_prd
*cur_prd
= usb3_ep
->dma
->prd
;
1268 u32 remain
= usb3_req
->req
.length
;
1269 u32 dma
= usb3_req
->req
.dma
;
1274 len
= min_t(u32
, remain
, USB3_DMA_MAX_XFER_SIZE
) &
1275 USB3_PRD1_SIZE_MASK
;
1276 cur_prd
->word1
= usb3_dma_mps_to_prd_word1(usb3_ep
) |
1277 USB3_PRD1_B_INC
| len
;
1281 if (!remain
|| (i
+ 1) < USB3_DMA_NUM_PRD_ENTRIES
)
1288 cur_prd
->word1
|= USB3_PRD1_E
| USB3_PRD1_INT
;
1289 if (usb3_ep
->dir_in
)
1290 cur_prd
->word1
|= USB3_PRD1_LST
;
1293 static void usb3_dma_kick_prd(struct renesas_usb3_ep
*usb3_ep
)
1295 struct renesas_usb3_dma
*dma
= usb3_ep
->dma
;
1296 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1297 u32 dma_con
= DMA_COM_PIPE_NO(usb3_ep
->num
) | DMA_CON_PRD_EN
;
1299 if (usb3_ep
->dir_in
)
1300 dma_con
|= DMA_CON_PIPE_DIR
;
1302 wmb(); /* prd entries should be in system memory here */
1304 usb3_write(usb3
, 1 << usb3_ep
->num
, USB3_DMA_INT_STA
);
1305 usb3_write(usb3
, AXI_INT_PRDEN_CLR_STA(dma
->num
) |
1306 AXI_INT_PRDERR_STA(dma
->num
), USB3_AXI_INT_STA
);
1308 usb3_write(usb3
, dma
->prd_dma
, USB3_DMA_CH0_PRD_ADR(dma
->num
));
1309 usb3_write(usb3
, dma_con
, USB3_DMA_CH0_CON(dma
->num
));
1310 usb3_enable_dma_irq(usb3
, usb3_ep
->num
);
1313 static void usb3_dma_stop_prd(struct renesas_usb3_ep
*usb3_ep
)
1315 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1316 struct renesas_usb3_dma
*dma
= usb3_ep
->dma
;
1318 usb3_disable_dma_irq(usb3
, usb3_ep
->num
);
1319 usb3_write(usb3
, 0, USB3_DMA_CH0_CON(dma
->num
));
1322 static int usb3_dma_update_status(struct renesas_usb3_ep
*usb3_ep
,
1323 struct renesas_usb3_request
*usb3_req
)
1325 struct renesas_usb3_prd
*cur_prd
= usb3_ep
->dma
->prd
;
1326 struct usb_request
*req
= &usb3_req
->req
;
1331 rmb(); /* The controller updated prd entries */
1334 if (cur_prd
->word1
& USB3_PRD1_D
)
1336 if (cur_prd
->word1
& USB3_PRD1_E
)
1337 len
= req
->length
% USB3_DMA_MAX_XFER_SIZE
;
1339 len
= USB3_DMA_MAX_XFER_SIZE
;
1340 remain
= cur_prd
->word1
& USB3_PRD1_SIZE_MASK
;
1341 req
->actual
+= len
- remain
;
1343 if (cur_prd
->word1
& USB3_PRD1_E
||
1344 (i
+ 1) < USB3_DMA_NUM_PRD_ENTRIES
)
1354 static bool usb3_dma_try_start(struct renesas_usb3_ep
*usb3_ep
,
1355 struct renesas_usb3_request
*usb3_req
)
1357 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1362 if (usb3_dma_get_setting_area(usb3_ep
, usb3_req
)) {
1364 usb3_enable_dma_pipen(usb3
);
1365 usb3_dma_fill_prd(usb3_ep
, usb3_req
);
1366 usb3_dma_kick_prd(usb3_ep
);
1367 usb3_pn_start(usb3
);
1374 static int usb3_dma_try_stop(struct renesas_usb3_ep
*usb3_ep
,
1375 struct renesas_usb3_request
*usb3_req
)
1377 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1378 unsigned long flags
;
1381 spin_lock_irqsave(&usb3
->lock
, flags
);
1385 if (!usb3_pn_change(usb3
, usb3_ep
->num
))
1386 usb3_disable_dma_pipen(usb3
);
1387 usb3_dma_stop_prd(usb3_ep
);
1388 status
= usb3_dma_update_status(usb3_ep
, usb3_req
);
1389 usb3_dma_put_setting_area(usb3_ep
, usb3_req
);
1392 spin_unlock_irqrestore(&usb3
->lock
, flags
);
1396 static int renesas_usb3_dma_free_prd(struct renesas_usb3
*usb3
,
1400 struct renesas_usb3_dma
*dma
;
1402 usb3_for_each_dma(usb3
, dma
, i
) {
1404 dma_free_coherent(dev
, USB3_DMA_PRD_SIZE
,
1405 dma
->prd
, dma
->prd_dma
);
1413 static int renesas_usb3_dma_alloc_prd(struct renesas_usb3
*usb3
,
1417 struct renesas_usb3_dma
*dma
;
1422 usb3_for_each_dma(usb3
, dma
, i
) {
1423 dma
->prd
= dma_alloc_coherent(dev
, USB3_DMA_PRD_SIZE
,
1424 &dma
->prd_dma
, GFP_KERNEL
);
1426 renesas_usb3_dma_free_prd(usb3
, dev
);
1435 static void usb3_start_pipen(struct renesas_usb3_ep
*usb3_ep
,
1436 struct renesas_usb3_request
*usb3_req
)
1438 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1439 struct renesas_usb3_request
*usb3_req_first
= usb3_get_request(usb3_ep
);
1440 unsigned long flags
;
1442 u32 enable_bits
= 0;
1444 spin_lock_irqsave(&usb3
->lock
, flags
);
1445 if (usb3_ep
->halt
|| usb3_ep
->started
)
1447 if (usb3_req
!= usb3_req_first
)
1450 if (usb3_pn_change(usb3
, usb3_ep
->num
) < 0)
1453 usb3_ep
->started
= true;
1455 if (usb3_dma_try_start(usb3_ep
, usb3_req
))
1458 usb3_pn_start(usb3
);
1460 if (usb3_ep
->dir_in
) {
1461 ret
= usb3_write_pipe(usb3_ep
, usb3_req
, USB3_PN_WRITE
);
1462 enable_bits
|= PN_INT_LSTTR
;
1466 enable_bits
|= PN_INT_BFRDY
;
1469 usb3_set_bit(usb3
, enable_bits
, USB3_PN_INT_ENA
);
1470 usb3_enable_pipe_irq(usb3
, usb3_ep
->num
);
1473 spin_unlock_irqrestore(&usb3
->lock
, flags
);
1476 static int renesas_usb3_ep_queue(struct usb_ep
*_ep
, struct usb_request
*_req
,
1479 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
1480 struct renesas_usb3_request
*usb3_req
= usb_req_to_usb3_req(_req
);
1481 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1482 unsigned long flags
;
1484 dev_dbg(usb3_to_dev(usb3
), "ep_queue: ep%2d, %u\n", usb3_ep
->num
,
1487 _req
->status
= -EINPROGRESS
;
1489 spin_lock_irqsave(&usb3
->lock
, flags
);
1490 list_add_tail(&usb3_req
->queue
, &usb3_ep
->queue
);
1491 spin_unlock_irqrestore(&usb3
->lock
, flags
);
1494 usb3_start_pipe0(usb3_ep
, usb3_req
);
1496 usb3_start_pipen(usb3_ep
, usb3_req
);
1501 static void usb3_set_device_address(struct renesas_usb3
*usb3
, u16 addr
)
1503 /* DEV_ADDR bit field is cleared by WarmReset, HotReset and BusReset */
1504 usb3_set_bit(usb3
, USB_COM_CON_DEV_ADDR(addr
), USB3_USB_COM_CON
);
1507 static bool usb3_std_req_set_address(struct renesas_usb3
*usb3
,
1508 struct usb_ctrlrequest
*ctrl
)
1510 if (ctrl
->wValue
>= 128)
1511 return true; /* stall */
1513 usb3_set_device_address(usb3
, ctrl
->wValue
);
1514 usb3_set_p0_con_for_no_data(usb3
);
1519 static void usb3_pipe0_internal_xfer(struct renesas_usb3
*usb3
,
1520 void *tx_data
, size_t len
,
1521 void (*complete
)(struct usb_ep
*ep
,
1522 struct usb_request
*req
))
1524 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, 0);
1527 memcpy(usb3
->ep0_buf
, tx_data
,
1528 min_t(size_t, len
, USB3_EP0_BUF_SIZE
));
1530 usb3
->ep0_req
->buf
= &usb3
->ep0_buf
;
1531 usb3
->ep0_req
->length
= len
;
1532 usb3
->ep0_req
->complete
= complete
;
1533 renesas_usb3_ep_queue(&usb3_ep
->ep
, usb3
->ep0_req
, GFP_ATOMIC
);
1536 static void usb3_pipe0_get_status_completion(struct usb_ep
*ep
,
1537 struct usb_request
*req
)
1541 static bool usb3_std_req_get_status(struct renesas_usb3
*usb3
,
1542 struct usb_ctrlrequest
*ctrl
)
1545 struct renesas_usb3_ep
*usb3_ep
;
1549 switch (ctrl
->bRequestType
& USB_RECIP_MASK
) {
1550 case USB_RECIP_DEVICE
:
1551 if (usb3
->gadget
.is_selfpowered
)
1552 status
|= 1 << USB_DEVICE_SELF_POWERED
;
1553 if (usb3
->gadget
.speed
== USB_SPEED_SUPER
)
1554 status
|= usb3_feature_get_un_enabled(usb3
);
1556 case USB_RECIP_INTERFACE
:
1558 case USB_RECIP_ENDPOINT
:
1559 num
= le16_to_cpu(ctrl
->wIndex
) & USB_ENDPOINT_NUMBER_MASK
;
1560 usb3_ep
= usb3_get_ep(usb3
, num
);
1562 status
|= 1 << USB_ENDPOINT_HALT
;
1570 status
= cpu_to_le16(status
);
1571 dev_dbg(usb3_to_dev(usb3
), "get_status: req = %p\n",
1572 usb_req_to_usb3_req(usb3
->ep0_req
));
1573 usb3_pipe0_internal_xfer(usb3
, &status
, sizeof(status
),
1574 usb3_pipe0_get_status_completion
);
1580 static bool usb3_std_req_feature_device(struct renesas_usb3
*usb3
,
1581 struct usb_ctrlrequest
*ctrl
, bool set
)
1584 u16 w_value
= le16_to_cpu(ctrl
->wValue
);
1587 case USB_DEVICE_TEST_MODE
:
1590 usb3
->test_mode
= le16_to_cpu(ctrl
->wIndex
) >> 8;
1593 case USB_DEVICE_U1_ENABLE
:
1594 case USB_DEVICE_U2_ENABLE
:
1595 if (usb3
->gadget
.speed
!= USB_SPEED_SUPER
)
1597 if (w_value
== USB_DEVICE_U1_ENABLE
)
1598 usb3_feature_u1_enable(usb3
, set
);
1599 if (w_value
== USB_DEVICE_U2_ENABLE
)
1600 usb3_feature_u2_enable(usb3
, set
);
1610 static int usb3_set_halt_p0(struct renesas_usb3_ep
*usb3_ep
, bool halt
)
1612 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1614 if (unlikely(usb3_ep
->num
))
1617 usb3_ep
->halt
= halt
;
1619 usb3_set_p0_con_stall(usb3
);
1621 usb3_set_p0_con_stop(usb3
);
1626 static int usb3_set_halt_pn(struct renesas_usb3_ep
*usb3_ep
, bool halt
,
1627 bool is_clear_feature
)
1629 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1630 unsigned long flags
;
1632 spin_lock_irqsave(&usb3
->lock
, flags
);
1633 if (!usb3_pn_change(usb3
, usb3_ep
->num
)) {
1634 usb3_ep
->halt
= halt
;
1636 usb3_pn_stall(usb3
);
1637 } else if (!is_clear_feature
|| !usb3_ep
->wedge
) {
1638 usb3_pn_con_clear(usb3
);
1639 usb3_set_bit(usb3
, PN_CON_EN
, USB3_PN_CON
);
1643 spin_unlock_irqrestore(&usb3
->lock
, flags
);
1648 static int usb3_set_halt(struct renesas_usb3_ep
*usb3_ep
, bool halt
,
1649 bool is_clear_feature
)
1653 if (halt
&& usb3_ep
->started
)
1657 ret
= usb3_set_halt_pn(usb3_ep
, halt
, is_clear_feature
);
1659 ret
= usb3_set_halt_p0(usb3_ep
, halt
);
1664 static bool usb3_std_req_feature_endpoint(struct renesas_usb3
*usb3
,
1665 struct usb_ctrlrequest
*ctrl
,
1668 int num
= le16_to_cpu(ctrl
->wIndex
) & USB_ENDPOINT_NUMBER_MASK
;
1669 struct renesas_usb3_ep
*usb3_ep
;
1670 struct renesas_usb3_request
*usb3_req
;
1672 if (le16_to_cpu(ctrl
->wValue
) != USB_ENDPOINT_HALT
)
1673 return true; /* stall */
1675 usb3_ep
= usb3_get_ep(usb3
, num
);
1676 usb3_set_halt(usb3_ep
, set
, true);
1678 /* Restarts a queue if clear feature */
1680 usb3_ep
->started
= false;
1681 usb3_req
= usb3_get_request(usb3_ep
);
1683 usb3_start_pipen(usb3_ep
, usb3_req
);
1689 static bool usb3_std_req_feature(struct renesas_usb3
*usb3
,
1690 struct usb_ctrlrequest
*ctrl
, bool set
)
1694 switch (ctrl
->bRequestType
& USB_RECIP_MASK
) {
1695 case USB_RECIP_DEVICE
:
1696 stall
= usb3_std_req_feature_device(usb3
, ctrl
, set
);
1698 case USB_RECIP_INTERFACE
:
1700 case USB_RECIP_ENDPOINT
:
1701 stall
= usb3_std_req_feature_endpoint(usb3
, ctrl
, set
);
1709 usb3_set_p0_con_for_no_data(usb3
);
1714 static void usb3_pipe0_set_sel_completion(struct usb_ep
*ep
,
1715 struct usb_request
*req
)
1720 static bool usb3_std_req_set_sel(struct renesas_usb3
*usb3
,
1721 struct usb_ctrlrequest
*ctrl
)
1723 u16 w_length
= le16_to_cpu(ctrl
->wLength
);
1726 return true; /* stall */
1728 dev_dbg(usb3_to_dev(usb3
), "set_sel: req = %p\n",
1729 usb_req_to_usb3_req(usb3
->ep0_req
));
1730 usb3_pipe0_internal_xfer(usb3
, NULL
, 6, usb3_pipe0_set_sel_completion
);
1735 static bool usb3_std_req_set_configuration(struct renesas_usb3
*usb3
,
1736 struct usb_ctrlrequest
*ctrl
)
1738 if (ctrl
->wValue
> 0)
1739 usb3_set_bit(usb3
, USB_COM_CON_CONF
, USB3_USB_COM_CON
);
1741 usb3_clear_bit(usb3
, USB_COM_CON_CONF
, USB3_USB_COM_CON
);
1747 * usb3_handle_standard_request - handle some standard requests
1748 * @usb3: the renesas_usb3 pointer
1749 * @ctrl: a pointer of setup data
1751 * Returns true if this function handled a standard request
1753 static bool usb3_handle_standard_request(struct renesas_usb3
*usb3
,
1754 struct usb_ctrlrequest
*ctrl
)
1759 if ((ctrl
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_STANDARD
) {
1760 switch (ctrl
->bRequest
) {
1761 case USB_REQ_SET_ADDRESS
:
1762 stall
= usb3_std_req_set_address(usb3
, ctrl
);
1765 case USB_REQ_GET_STATUS
:
1766 stall
= usb3_std_req_get_status(usb3
, ctrl
);
1769 case USB_REQ_CLEAR_FEATURE
:
1770 stall
= usb3_std_req_feature(usb3
, ctrl
, false);
1773 case USB_REQ_SET_FEATURE
:
1774 stall
= usb3_std_req_feature(usb3
, ctrl
, true);
1777 case USB_REQ_SET_SEL
:
1778 stall
= usb3_std_req_set_sel(usb3
, ctrl
);
1781 case USB_REQ_SET_ISOCH_DELAY
:
1782 /* This hardware doesn't support Isochronous xfer */
1786 case USB_REQ_SET_CONFIGURATION
:
1787 usb3_std_req_set_configuration(usb3
, ctrl
);
1795 usb3_set_p0_con_stall(usb3
);
1800 static int usb3_p0_con_clear_buffer(struct renesas_usb3
*usb3
)
1802 usb3_set_bit(usb3
, P0_CON_BCLR
, USB3_P0_CON
);
1804 return usb3_wait(usb3
, USB3_P0_CON
, P0_CON_BCLR
, 0);
1807 static void usb3_irq_epc_pipe0_setup(struct renesas_usb3
*usb3
)
1809 struct usb_ctrlrequest ctrl
;
1810 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, 0);
1812 /* Call giveback function if previous transfer is not completed */
1813 if (usb3_ep
->started
)
1814 usb3_request_done(usb3_ep
, usb3_get_request(usb3_ep
),
1817 usb3_p0_con_clear_buffer(usb3
);
1818 usb3_get_setup_data(usb3
, &ctrl
);
1819 if (!usb3_handle_standard_request(usb3
, &ctrl
))
1820 if (usb3
->driver
->setup(&usb3
->gadget
, &ctrl
) < 0)
1821 usb3_set_p0_con_stall(usb3
);
1824 static void usb3_irq_epc_pipe0_bfrdy(struct renesas_usb3
*usb3
)
1826 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, 0);
1827 struct renesas_usb3_request
*usb3_req
= usb3_get_request(usb3_ep
);
1832 usb3_p0_xfer(usb3_ep
, usb3_req
);
1835 static void usb3_irq_epc_pipe0(struct renesas_usb3
*usb3
)
1837 u32 p0_int_sta
= usb3_read(usb3
, USB3_P0_INT_STA
);
1839 p0_int_sta
&= usb3_read(usb3
, USB3_P0_INT_ENA
);
1840 usb3_write(usb3
, p0_int_sta
, USB3_P0_INT_STA
);
1841 if (p0_int_sta
& P0_INT_STSED
)
1842 usb3_irq_epc_pipe0_status_end(usb3
);
1843 if (p0_int_sta
& P0_INT_SETUP
)
1844 usb3_irq_epc_pipe0_setup(usb3
);
1845 if (p0_int_sta
& P0_INT_BFRDY
)
1846 usb3_irq_epc_pipe0_bfrdy(usb3
);
1849 static void usb3_request_done_pipen(struct renesas_usb3
*usb3
,
1850 struct renesas_usb3_ep
*usb3_ep
,
1851 struct renesas_usb3_request
*usb3_req
,
1854 unsigned long flags
;
1856 spin_lock_irqsave(&usb3
->lock
, flags
);
1857 if (usb3_pn_change(usb3
, usb3_ep
->num
))
1859 spin_unlock_irqrestore(&usb3
->lock
, flags
);
1861 usb3_disable_pipe_irq(usb3
, usb3_ep
->num
);
1862 usb3_request_done(usb3_ep
, usb3_req
, status
);
1864 /* get next usb3_req */
1865 usb3_req
= usb3_get_request(usb3_ep
);
1867 usb3_start_pipen(usb3_ep
, usb3_req
);
1870 static void usb3_irq_epc_pipen_lsttr(struct renesas_usb3
*usb3
, int num
)
1872 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, num
);
1873 struct renesas_usb3_request
*usb3_req
= usb3_get_request(usb3_ep
);
1878 if (usb3_ep
->dir_in
) {
1879 dev_dbg(usb3_to_dev(usb3
), "%s: len = %u, actual = %u\n",
1880 __func__
, usb3_req
->req
.length
, usb3_req
->req
.actual
);
1881 usb3_request_done_pipen(usb3
, usb3_ep
, usb3_req
, 0);
1885 static void usb3_irq_epc_pipen_bfrdy(struct renesas_usb3
*usb3
, int num
)
1887 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, num
);
1888 struct renesas_usb3_request
*usb3_req
= usb3_get_request(usb3_ep
);
1894 spin_lock(&usb3
->lock
);
1895 if (usb3_pn_change(usb3
, num
))
1898 if (usb3_ep
->dir_in
) {
1899 /* Do not stop the IN pipe here to detect LSTTR interrupt */
1900 if (!usb3_write_pipe(usb3_ep
, usb3_req
, USB3_PN_WRITE
))
1901 usb3_clear_bit(usb3
, PN_INT_BFRDY
, USB3_PN_INT_ENA
);
1903 if (!usb3_read_pipe(usb3_ep
, usb3_req
, USB3_PN_READ
))
1908 /* need to unlock because usb3_request_done_pipen() locks it */
1909 spin_unlock(&usb3
->lock
);
1912 usb3_request_done_pipen(usb3
, usb3_ep
, usb3_req
, 0);
1915 static void usb3_irq_epc_pipen(struct renesas_usb3
*usb3
, int num
)
1919 spin_lock(&usb3
->lock
);
1920 if (usb3_pn_change(usb3
, num
) < 0) {
1921 spin_unlock(&usb3
->lock
);
1925 pn_int_sta
= usb3_read(usb3
, USB3_PN_INT_STA
);
1926 pn_int_sta
&= usb3_read(usb3
, USB3_PN_INT_ENA
);
1927 usb3_write(usb3
, pn_int_sta
, USB3_PN_INT_STA
);
1928 spin_unlock(&usb3
->lock
);
1929 if (pn_int_sta
& PN_INT_LSTTR
)
1930 usb3_irq_epc_pipen_lsttr(usb3
, num
);
1931 if (pn_int_sta
& PN_INT_BFRDY
)
1932 usb3_irq_epc_pipen_bfrdy(usb3
, num
);
1935 static void usb3_irq_epc_int_2(struct renesas_usb3
*usb3
, u32 int_sta_2
)
1939 for (i
= 0; i
< usb3
->num_usb3_eps
; i
++) {
1940 if (int_sta_2
& USB_INT_2_PIPE(i
)) {
1942 usb3_irq_epc_pipe0(usb3
);
1944 usb3_irq_epc_pipen(usb3
, i
);
1949 static void usb3_irq_idmon_change(struct renesas_usb3
*usb3
)
1951 usb3_check_id(usb3
);
1954 static void usb3_irq_otg_int(struct renesas_usb3
*usb3
, u32 otg_int_sta
)
1956 if (otg_int_sta
& USB_OTG_IDMON
)
1957 usb3_irq_idmon_change(usb3
);
1960 static void usb3_irq_epc(struct renesas_usb3
*usb3
)
1962 u32 int_sta_1
= usb3_read(usb3
, USB3_USB_INT_STA_1
);
1963 u32 int_sta_2
= usb3_read(usb3
, USB3_USB_INT_STA_2
);
1964 u32 otg_int_sta
= usb3_read(usb3
, USB3_USB_OTG_INT_STA
);
1966 int_sta_1
&= usb3_read(usb3
, USB3_USB_INT_ENA_1
);
1968 usb3_write(usb3
, int_sta_1
, USB3_USB_INT_STA_1
);
1969 usb3_irq_epc_int_1(usb3
, int_sta_1
);
1972 int_sta_2
&= usb3_read(usb3
, USB3_USB_INT_ENA_2
);
1974 usb3_irq_epc_int_2(usb3
, int_sta_2
);
1976 otg_int_sta
&= usb3_read(usb3
, USB3_USB_OTG_INT_ENA
);
1978 usb3_write(usb3
, otg_int_sta
, USB3_USB_OTG_INT_STA
);
1979 usb3_irq_otg_int(usb3
, otg_int_sta
);
1983 static void usb3_irq_dma_int(struct renesas_usb3
*usb3
, u32 dma_sta
)
1985 struct renesas_usb3_ep
*usb3_ep
;
1986 struct renesas_usb3_request
*usb3_req
;
1989 for (i
= 0; i
< usb3
->num_usb3_eps
; i
++) {
1990 if (!(dma_sta
& DMA_INT(i
)))
1993 usb3_ep
= usb3_get_ep(usb3
, i
);
1994 if (!(usb3_read(usb3
, USB3_AXI_INT_STA
) &
1995 AXI_INT_PRDEN_CLR_STA(usb3_ep
->dma
->num
)))
1998 usb3_req
= usb3_get_request(usb3_ep
);
1999 status
= usb3_dma_try_stop(usb3_ep
, usb3_req
);
2000 usb3_request_done_pipen(usb3
, usb3_ep
, usb3_req
, status
);
2004 static void usb3_irq_dma(struct renesas_usb3
*usb3
)
2006 u32 dma_sta
= usb3_read(usb3
, USB3_DMA_INT_STA
);
2008 dma_sta
&= usb3_read(usb3
, USB3_DMA_INT_ENA
);
2010 usb3_write(usb3
, dma_sta
, USB3_DMA_INT_STA
);
2011 usb3_irq_dma_int(usb3
, dma_sta
);
2015 static irqreturn_t
renesas_usb3_irq(int irq
, void *_usb3
)
2017 struct renesas_usb3
*usb3
= _usb3
;
2018 irqreturn_t ret
= IRQ_NONE
;
2019 u32 axi_int_sta
= usb3_read(usb3
, USB3_AXI_INT_STA
);
2021 if (axi_int_sta
& AXI_INT_DMAINT
) {
2026 if (axi_int_sta
& AXI_INT_EPCINT
) {
2034 static void usb3_write_pn_mod(struct renesas_usb3_ep
*usb3_ep
,
2035 const struct usb_endpoint_descriptor
*desc
)
2037 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
2040 val
|= usb3_ep
->dir_in
? PN_MOD_DIR
: 0;
2041 val
|= PN_MOD_TYPE(usb_endpoint_type(desc
));
2042 val
|= PN_MOD_EPNUM(usb_endpoint_num(desc
));
2043 usb3_write(usb3
, val
, USB3_PN_MOD
);
2046 static u32
usb3_calc_ramarea(int ram_size
)
2048 WARN_ON(ram_size
> SZ_16K
);
2050 if (ram_size
<= SZ_1K
)
2051 return PN_RAMMAP_RAMAREA_1KB
;
2052 else if (ram_size
<= SZ_2K
)
2053 return PN_RAMMAP_RAMAREA_2KB
;
2054 else if (ram_size
<= SZ_4K
)
2055 return PN_RAMMAP_RAMAREA_4KB
;
2056 else if (ram_size
<= SZ_8K
)
2057 return PN_RAMMAP_RAMAREA_8KB
;
2059 return PN_RAMMAP_RAMAREA_16KB
;
2062 static u32
usb3_calc_rammap_val(struct renesas_usb3_ep
*usb3_ep
,
2063 const struct usb_endpoint_descriptor
*desc
)
2066 static const u32 max_packet_array
[] = {8, 16, 32, 64, 512};
2067 u32 mpkt
= PN_RAMMAP_MPKT(1024);
2069 for (i
= 0; i
< ARRAY_SIZE(max_packet_array
); i
++) {
2070 if (usb_endpoint_maxp(desc
) <= max_packet_array
[i
])
2071 mpkt
= PN_RAMMAP_MPKT(max_packet_array
[i
]);
2074 return usb3_ep
->rammap_val
| mpkt
;
2077 static int usb3_enable_pipe_n(struct renesas_usb3_ep
*usb3_ep
,
2078 const struct usb_endpoint_descriptor
*desc
)
2080 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
2081 unsigned long flags
;
2083 usb3_ep
->dir_in
= usb_endpoint_dir_in(desc
);
2085 spin_lock_irqsave(&usb3
->lock
, flags
);
2086 if (!usb3_pn_change(usb3
, usb3_ep
->num
)) {
2087 usb3_write_pn_mod(usb3_ep
, desc
);
2088 usb3_write(usb3
, usb3_calc_rammap_val(usb3_ep
, desc
),
2090 usb3_pn_con_clear(usb3
);
2091 usb3_set_bit(usb3
, PN_CON_EN
, USB3_PN_CON
);
2093 spin_unlock_irqrestore(&usb3
->lock
, flags
);
2098 static int usb3_disable_pipe_n(struct renesas_usb3_ep
*usb3_ep
)
2100 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
2101 unsigned long flags
;
2103 usb3_ep
->halt
= false;
2105 spin_lock_irqsave(&usb3
->lock
, flags
);
2106 if (!usb3_pn_change(usb3
, usb3_ep
->num
)) {
2107 usb3_write(usb3
, 0, USB3_PN_INT_ENA
);
2108 usb3_write(usb3
, 0, USB3_PN_RAMMAP
);
2109 usb3_clear_bit(usb3
, PN_CON_EN
, USB3_PN_CON
);
2111 spin_unlock_irqrestore(&usb3
->lock
, flags
);
2116 /*------- usb_ep_ops -----------------------------------------------------*/
2117 static int renesas_usb3_ep_enable(struct usb_ep
*_ep
,
2118 const struct usb_endpoint_descriptor
*desc
)
2120 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
2122 return usb3_enable_pipe_n(usb3_ep
, desc
);
2125 static int renesas_usb3_ep_disable(struct usb_ep
*_ep
)
2127 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
2128 struct renesas_usb3_request
*usb3_req
;
2131 usb3_req
= usb3_get_request(usb3_ep
);
2134 usb3_dma_try_stop(usb3_ep
, usb3_req
);
2135 usb3_request_done(usb3_ep
, usb3_req
, -ESHUTDOWN
);
2138 return usb3_disable_pipe_n(usb3_ep
);
2141 static struct usb_request
*__renesas_usb3_ep_alloc_request(gfp_t gfp_flags
)
2143 struct renesas_usb3_request
*usb3_req
;
2145 usb3_req
= kzalloc(sizeof(struct renesas_usb3_request
), gfp_flags
);
2149 INIT_LIST_HEAD(&usb3_req
->queue
);
2151 return &usb3_req
->req
;
2154 static void __renesas_usb3_ep_free_request(struct usb_request
*_req
)
2156 struct renesas_usb3_request
*usb3_req
= usb_req_to_usb3_req(_req
);
2161 static struct usb_request
*renesas_usb3_ep_alloc_request(struct usb_ep
*_ep
,
2164 return __renesas_usb3_ep_alloc_request(gfp_flags
);
2167 static void renesas_usb3_ep_free_request(struct usb_ep
*_ep
,
2168 struct usb_request
*_req
)
2170 __renesas_usb3_ep_free_request(_req
);
2173 static int renesas_usb3_ep_dequeue(struct usb_ep
*_ep
, struct usb_request
*_req
)
2175 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
2176 struct renesas_usb3_request
*usb3_req
= usb_req_to_usb3_req(_req
);
2177 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
2179 dev_dbg(usb3_to_dev(usb3
), "ep_dequeue: ep%2d, %u\n", usb3_ep
->num
,
2182 usb3_dma_try_stop(usb3_ep
, usb3_req
);
2183 usb3_request_done_pipen(usb3
, usb3_ep
, usb3_req
, -ECONNRESET
);
2188 static int renesas_usb3_ep_set_halt(struct usb_ep
*_ep
, int value
)
2190 return usb3_set_halt(usb_ep_to_usb3_ep(_ep
), !!value
, false);
2193 static int renesas_usb3_ep_set_wedge(struct usb_ep
*_ep
)
2195 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
2197 usb3_ep
->wedge
= true;
2198 return usb3_set_halt(usb3_ep
, true, false);
2201 static void renesas_usb3_ep_fifo_flush(struct usb_ep
*_ep
)
2203 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
2204 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
2205 unsigned long flags
;
2208 spin_lock_irqsave(&usb3
->lock
, flags
);
2209 if (!usb3_pn_change(usb3
, usb3_ep
->num
)) {
2210 usb3_pn_con_clear(usb3
);
2211 usb3_set_bit(usb3
, PN_CON_EN
, USB3_PN_CON
);
2213 spin_unlock_irqrestore(&usb3
->lock
, flags
);
2215 usb3_p0_con_clear_buffer(usb3
);
2219 static const struct usb_ep_ops renesas_usb3_ep_ops
= {
2220 .enable
= renesas_usb3_ep_enable
,
2221 .disable
= renesas_usb3_ep_disable
,
2223 .alloc_request
= renesas_usb3_ep_alloc_request
,
2224 .free_request
= renesas_usb3_ep_free_request
,
2226 .queue
= renesas_usb3_ep_queue
,
2227 .dequeue
= renesas_usb3_ep_dequeue
,
2229 .set_halt
= renesas_usb3_ep_set_halt
,
2230 .set_wedge
= renesas_usb3_ep_set_wedge
,
2231 .fifo_flush
= renesas_usb3_ep_fifo_flush
,
2234 /*------- usb_gadget_ops -------------------------------------------------*/
2235 static int renesas_usb3_start(struct usb_gadget
*gadget
,
2236 struct usb_gadget_driver
*driver
)
2238 struct renesas_usb3
*usb3
;
2240 if (!driver
|| driver
->max_speed
< USB_SPEED_FULL
||
2244 usb3
= gadget_to_renesas_usb3(gadget
);
2246 /* hook up the driver */
2247 usb3
->driver
= driver
;
2250 phy_init(usb3
->phy
);
2252 pm_runtime_get_sync(usb3_to_dev(usb3
));
2254 renesas_usb3_init_controller(usb3
);
2259 static int renesas_usb3_stop(struct usb_gadget
*gadget
)
2261 struct renesas_usb3
*usb3
= gadget_to_renesas_usb3(gadget
);
2263 usb3
->softconnect
= false;
2264 usb3
->gadget
.speed
= USB_SPEED_UNKNOWN
;
2265 usb3
->driver
= NULL
;
2266 renesas_usb3_stop_controller(usb3
);
2269 phy_exit(usb3
->phy
);
2271 pm_runtime_put(usb3_to_dev(usb3
));
2276 static int renesas_usb3_get_frame(struct usb_gadget
*_gadget
)
2281 static int renesas_usb3_pullup(struct usb_gadget
*gadget
, int is_on
)
2283 struct renesas_usb3
*usb3
= gadget_to_renesas_usb3(gadget
);
2285 usb3
->softconnect
= !!is_on
;
2290 static int renesas_usb3_set_selfpowered(struct usb_gadget
*gadget
, int is_self
)
2292 gadget
->is_selfpowered
= !!is_self
;
2297 static const struct usb_gadget_ops renesas_usb3_gadget_ops
= {
2298 .get_frame
= renesas_usb3_get_frame
,
2299 .udc_start
= renesas_usb3_start
,
2300 .udc_stop
= renesas_usb3_stop
,
2301 .pullup
= renesas_usb3_pullup
,
2302 .set_selfpowered
= renesas_usb3_set_selfpowered
,
2305 static ssize_t
role_store(struct device
*dev
, struct device_attribute
*attr
,
2306 const char *buf
, size_t count
)
2308 struct renesas_usb3
*usb3
= dev_get_drvdata(dev
);
2309 bool new_mode_is_host
;
2314 if (usb3
->forced_b_device
)
2317 if (!strncmp(buf
, "host", strlen("host")))
2318 new_mode_is_host
= true;
2319 else if (!strncmp(buf
, "peripheral", strlen("peripheral")))
2320 new_mode_is_host
= false;
2324 if (new_mode_is_host
== usb3_is_host(usb3
))
2327 usb3_mode_config(usb3
, new_mode_is_host
, usb3_is_a_device(usb3
));
2332 static ssize_t
role_show(struct device
*dev
, struct device_attribute
*attr
,
2335 struct renesas_usb3
*usb3
= dev_get_drvdata(dev
);
2340 return sprintf(buf
, "%s\n", usb3_is_host(usb3
) ? "host" : "peripheral");
2342 static DEVICE_ATTR_RW(role
);
2344 static int renesas_usb3_b_device_show(struct seq_file
*s
, void *unused
)
2346 struct renesas_usb3
*usb3
= s
->private;
2348 seq_printf(s
, "%d\n", usb3
->forced_b_device
);
2353 static int renesas_usb3_b_device_open(struct inode
*inode
, struct file
*file
)
2355 return single_open(file
, renesas_usb3_b_device_show
, inode
->i_private
);
2358 static ssize_t
renesas_usb3_b_device_write(struct file
*file
,
2359 const char __user
*ubuf
,
2360 size_t count
, loff_t
*ppos
)
2362 struct seq_file
*s
= file
->private_data
;
2363 struct renesas_usb3
*usb3
= s
->private;
2369 if (copy_from_user(&buf
, ubuf
, min_t(size_t, sizeof(buf
) - 1, count
)))
2372 if (!strncmp(buf
, "1", 1))
2373 usb3
->forced_b_device
= true;
2375 usb3
->forced_b_device
= false;
2377 /* Let this driver call usb3_connect() anyway */
2378 usb3_check_id(usb3
);
2383 static const struct file_operations renesas_usb3_b_device_fops
= {
2384 .open
= renesas_usb3_b_device_open
,
2385 .write
= renesas_usb3_b_device_write
,
2387 .llseek
= seq_lseek
,
2388 .release
= single_release
,
2391 static void renesas_usb3_debugfs_init(struct renesas_usb3
*usb3
,
2394 struct dentry
*root
, *file
;
2396 root
= debugfs_create_dir(dev_name(dev
), NULL
);
2397 if (IS_ERR_OR_NULL(root
)) {
2398 dev_info(dev
, "%s: Can't create the root\n", __func__
);
2402 file
= debugfs_create_file("b_device", 0644, root
, usb3
,
2403 &renesas_usb3_b_device_fops
);
2405 dev_info(dev
, "%s: Can't create debugfs mode\n", __func__
);
2406 debugfs_remove_recursive(root
);
2408 usb3
->dentry
= root
;
2412 /*------- platform_driver ------------------------------------------------*/
2413 static int renesas_usb3_remove(struct platform_device
*pdev
)
2415 struct renesas_usb3
*usb3
= platform_get_drvdata(pdev
);
2417 debugfs_remove_recursive(usb3
->dentry
);
2418 device_remove_file(&pdev
->dev
, &dev_attr_role
);
2420 usb_del_gadget_udc(&usb3
->gadget
);
2421 renesas_usb3_dma_free_prd(usb3
, &pdev
->dev
);
2423 __renesas_usb3_ep_free_request(usb3
->ep0_req
);
2424 pm_runtime_disable(&pdev
->dev
);
2429 static int renesas_usb3_init_ep(struct renesas_usb3
*usb3
, struct device
*dev
,
2430 const struct renesas_usb3_priv
*priv
)
2432 struct renesas_usb3_ep
*usb3_ep
;
2435 /* calculate num_usb3_eps from renesas_usb3_priv */
2436 usb3
->num_usb3_eps
= priv
->ramsize_per_ramif
* priv
->num_ramif
* 2 /
2437 priv
->ramsize_per_pipe
+ 1;
2439 if (usb3
->num_usb3_eps
> USB3_MAX_NUM_PIPES
)
2440 usb3
->num_usb3_eps
= USB3_MAX_NUM_PIPES
;
2442 usb3
->usb3_ep
= devm_kzalloc(dev
, sizeof(*usb3_ep
) * usb3
->num_usb3_eps
,
2447 dev_dbg(dev
, "%s: num_usb3_eps = %d\n", __func__
, usb3
->num_usb3_eps
);
2449 * This driver prepares pipes as follows:
2450 * - odd pipes = IN pipe
2451 * - even pipes = OUT pipe (except pipe 0)
2453 usb3_for_each_ep(usb3_ep
, usb3
, i
) {
2454 snprintf(usb3_ep
->ep_name
, sizeof(usb3_ep
->ep_name
), "ep%d", i
);
2455 usb3_ep
->usb3
= usb3
;
2457 usb3_ep
->ep
.name
= usb3_ep
->ep_name
;
2458 usb3_ep
->ep
.ops
= &renesas_usb3_ep_ops
;
2459 INIT_LIST_HEAD(&usb3_ep
->queue
);
2460 INIT_LIST_HEAD(&usb3_ep
->ep
.ep_list
);
2462 /* for control pipe */
2463 usb3
->gadget
.ep0
= &usb3_ep
->ep
;
2464 usb_ep_set_maxpacket_limit(&usb3_ep
->ep
,
2465 USB3_EP0_HSFS_MAX_PACKET_SIZE
);
2466 usb3_ep
->ep
.caps
.type_control
= true;
2467 usb3_ep
->ep
.caps
.dir_in
= true;
2468 usb3_ep
->ep
.caps
.dir_out
= true;
2472 /* for bulk or interrupt pipe */
2473 usb_ep_set_maxpacket_limit(&usb3_ep
->ep
, ~0);
2474 list_add_tail(&usb3_ep
->ep
.ep_list
, &usb3
->gadget
.ep_list
);
2475 usb3_ep
->ep
.caps
.type_bulk
= true;
2476 usb3_ep
->ep
.caps
.type_int
= true;
2478 usb3_ep
->ep
.caps
.dir_in
= true;
2480 usb3_ep
->ep
.caps
.dir_out
= true;
2486 static void renesas_usb3_init_ram(struct renesas_usb3
*usb3
, struct device
*dev
,
2487 const struct renesas_usb3_priv
*priv
)
2489 struct renesas_usb3_ep
*usb3_ep
;
2491 u32 ramif
[2], basead
[2]; /* index 0 = for IN pipes */
2492 u32
*cur_ramif
, *cur_basead
;
2495 memset(ramif
, 0, sizeof(ramif
));
2496 memset(basead
, 0, sizeof(basead
));
2499 * This driver prepares pipes as follows:
2500 * - all pipes = the same size as "ramsize_per_pipe"
2501 * Please refer to the "Method of Specifying RAM Mapping"
2503 usb3_for_each_ep(usb3_ep
, usb3
, i
) {
2505 continue; /* out of scope if ep num = 0 */
2506 if (usb3_ep
->ep
.caps
.dir_in
) {
2507 cur_ramif
= &ramif
[0];
2508 cur_basead
= &basead
[0];
2510 cur_ramif
= &ramif
[1];
2511 cur_basead
= &basead
[1];
2514 if (*cur_basead
> priv
->ramsize_per_ramif
)
2515 continue; /* out of memory for IN or OUT pipe */
2517 /* calculate rammap_val */
2518 val
= PN_RAMMAP_RAMIF(*cur_ramif
);
2519 val
|= usb3_calc_ramarea(priv
->ramsize_per_pipe
);
2520 val
|= PN_RAMMAP_BASEAD(*cur_basead
);
2521 usb3_ep
->rammap_val
= val
;
2523 dev_dbg(dev
, "ep%2d: val = %08x, ramif = %d, base = %x\n",
2524 i
, val
, *cur_ramif
, *cur_basead
);
2526 /* update current ramif */
2527 if (*cur_ramif
+ 1 == priv
->num_ramif
) {
2529 *cur_basead
+= priv
->ramsize_per_pipe
;
2536 static const struct renesas_usb3_priv renesas_usb3_priv_r8a7795_es1
= {
2537 .ramsize_per_ramif
= SZ_16K
,
2539 .ramsize_per_pipe
= SZ_4K
,
2540 .workaround_for_vbus
= true,
2543 static const struct renesas_usb3_priv renesas_usb3_priv_gen3
= {
2544 .ramsize_per_ramif
= SZ_16K
,
2546 .ramsize_per_pipe
= SZ_4K
,
2549 static const struct of_device_id usb3_of_match
[] = {
2551 .compatible
= "renesas,r8a7795-usb3-peri",
2552 .data
= &renesas_usb3_priv_gen3
,
2555 .compatible
= "renesas,rcar-gen3-usb3-peri",
2556 .data
= &renesas_usb3_priv_gen3
,
2560 MODULE_DEVICE_TABLE(of
, usb3_of_match
);
2562 static const struct soc_device_attribute renesas_usb3_quirks_match
[] = {
2564 .soc_id
= "r8a7795", .revision
= "ES1.*",
2565 .data
= &renesas_usb3_priv_r8a7795_es1
,
2570 static const unsigned int renesas_usb3_cable
[] = {
2576 static int renesas_usb3_probe(struct platform_device
*pdev
)
2578 struct renesas_usb3
*usb3
;
2579 struct resource
*res
;
2581 const struct renesas_usb3_priv
*priv
;
2582 const struct soc_device_attribute
*attr
;
2584 attr
= soc_device_match(renesas_usb3_quirks_match
);
2588 priv
= of_device_get_match_data(&pdev
->dev
);
2590 irq
= platform_get_irq(pdev
, 0);
2592 dev_err(&pdev
->dev
, "Failed to get IRQ: %d\n", irq
);
2596 usb3
= devm_kzalloc(&pdev
->dev
, sizeof(*usb3
), GFP_KERNEL
);
2600 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
2601 usb3
->reg
= devm_ioremap_resource(&pdev
->dev
, res
);
2602 if (IS_ERR(usb3
->reg
))
2603 return PTR_ERR(usb3
->reg
);
2605 platform_set_drvdata(pdev
, usb3
);
2606 spin_lock_init(&usb3
->lock
);
2608 usb3
->gadget
.ops
= &renesas_usb3_gadget_ops
;
2609 usb3
->gadget
.name
= udc_name
;
2610 usb3
->gadget
.max_speed
= USB_SPEED_SUPER
;
2611 INIT_LIST_HEAD(&usb3
->gadget
.ep_list
);
2612 ret
= renesas_usb3_init_ep(usb3
, &pdev
->dev
, priv
);
2615 renesas_usb3_init_ram(usb3
, &pdev
->dev
, priv
);
2617 ret
= devm_request_irq(&pdev
->dev
, irq
, renesas_usb3_irq
, 0,
2618 dev_name(&pdev
->dev
), usb3
);
2622 INIT_WORK(&usb3
->extcon_work
, renesas_usb3_extcon_work
);
2623 usb3
->extcon
= devm_extcon_dev_allocate(&pdev
->dev
, renesas_usb3_cable
);
2624 if (IS_ERR(usb3
->extcon
))
2625 return PTR_ERR(usb3
->extcon
);
2627 ret
= devm_extcon_dev_register(&pdev
->dev
, usb3
->extcon
);
2629 dev_err(&pdev
->dev
, "Failed to register extcon\n");
2633 /* for ep0 handling */
2634 usb3
->ep0_req
= __renesas_usb3_ep_alloc_request(GFP_KERNEL
);
2638 ret
= renesas_usb3_dma_alloc_prd(usb3
, &pdev
->dev
);
2642 ret
= usb_add_gadget_udc(&pdev
->dev
, &usb3
->gadget
);
2646 ret
= device_create_file(&pdev
->dev
, &dev_attr_role
);
2648 goto err_dev_create
;
2651 * This is an optional. So, if this driver cannot get a phy,
2652 * this driver will not handle a phy anymore.
2654 usb3
->phy
= devm_phy_get(&pdev
->dev
, "usb");
2655 if (IS_ERR(usb3
->phy
))
2658 usb3
->workaround_for_vbus
= priv
->workaround_for_vbus
;
2660 renesas_usb3_debugfs_init(usb3
, &pdev
->dev
);
2662 dev_info(&pdev
->dev
, "probed%s\n", usb3
->phy
? " with phy" : "");
2663 pm_runtime_enable(usb3_to_dev(usb3
));
2668 usb_del_gadget_udc(&usb3
->gadget
);
2671 renesas_usb3_dma_free_prd(usb3
, &pdev
->dev
);
2674 __renesas_usb3_ep_free_request(usb3
->ep0_req
);
2679 #ifdef CONFIG_PM_SLEEP
2680 static int renesas_usb3_suspend(struct device
*dev
)
2682 struct renesas_usb3
*usb3
= dev_get_drvdata(dev
);
2688 renesas_usb3_stop_controller(usb3
);
2690 phy_exit(usb3
->phy
);
2691 pm_runtime_put(dev
);
2696 static int renesas_usb3_resume(struct device
*dev
)
2698 struct renesas_usb3
*usb3
= dev_get_drvdata(dev
);
2705 phy_init(usb3
->phy
);
2706 pm_runtime_get_sync(dev
);
2707 renesas_usb3_init_controller(usb3
);
2713 static SIMPLE_DEV_PM_OPS(renesas_usb3_pm_ops
, renesas_usb3_suspend
,
2714 renesas_usb3_resume
);
2716 static struct platform_driver renesas_usb3_driver
= {
2717 .probe
= renesas_usb3_probe
,
2718 .remove
= renesas_usb3_remove
,
2720 .name
= (char *)udc_name
,
2721 .pm
= &renesas_usb3_pm_ops
,
2722 .of_match_table
= of_match_ptr(usb3_of_match
),
2725 module_platform_driver(renesas_usb3_driver
);
2727 MODULE_DESCRIPTION("Renesas USB3.0 Peripheral driver");
2728 MODULE_LICENSE("GPL v2");
2729 MODULE_AUTHOR("Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>");
2730 MODULE_ALIAS("platform:renesas_usb3");