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
;
337 struct renesas_usb3_ep
*usb3_ep
;
340 struct renesas_usb3_dma dma
[USB3_DMA_NUM_SETTING_AREA
];
345 struct usb_request
*ep0_req
;
347 u8 ep0_buf
[USB3_EP0_BUF_SIZE
];
349 bool workaround_for_vbus
;
350 bool extcon_host
; /* check id and set EXTCON_USB_HOST */
351 bool extcon_usb
; /* check vbus and set EXTCON_USB */
352 bool forced_b_device
;
355 #define gadget_to_renesas_usb3(_gadget) \
356 container_of(_gadget, struct renesas_usb3, gadget)
357 #define renesas_usb3_to_gadget(renesas_usb3) (&renesas_usb3->gadget)
358 #define usb3_to_dev(_usb3) (_usb3->gadget.dev.parent)
360 #define usb_ep_to_usb3_ep(_ep) container_of(_ep, struct renesas_usb3_ep, ep)
361 #define usb3_ep_to_usb3(_usb3_ep) (_usb3_ep->usb3)
362 #define usb_req_to_usb3_req(_req) container_of(_req, \
363 struct renesas_usb3_request, req)
365 #define usb3_get_ep(usb3, n) ((usb3)->usb3_ep + (n))
366 #define usb3_for_each_ep(usb3_ep, usb3, i) \
367 for ((i) = 0, usb3_ep = usb3_get_ep(usb3, (i)); \
368 (i) < (usb3)->num_usb3_eps; \
369 (i)++, usb3_ep = usb3_get_ep(usb3, (i)))
371 #define usb3_get_dma(usb3, i) (&(usb3)->dma[i])
372 #define usb3_for_each_dma(usb3, dma, i) \
373 for ((i) = 0, dma = usb3_get_dma((usb3), (i)); \
374 (i) < USB3_DMA_NUM_SETTING_AREA; \
375 (i)++, dma = usb3_get_dma((usb3), (i)))
377 static const char udc_name
[] = "renesas_usb3";
379 static bool use_dma
= 1;
380 module_param(use_dma
, bool, 0644);
381 MODULE_PARM_DESC(use_dma
, "use dedicated DMAC");
383 static void usb3_write(struct renesas_usb3
*usb3
, u32 data
, u32 offs
)
385 iowrite32(data
, usb3
->reg
+ offs
);
388 static u32
usb3_read(struct renesas_usb3
*usb3
, u32 offs
)
390 return ioread32(usb3
->reg
+ offs
);
393 static void usb3_set_bit(struct renesas_usb3
*usb3
, u32 bits
, u32 offs
)
395 u32 val
= usb3_read(usb3
, offs
);
398 usb3_write(usb3
, val
, offs
);
401 static void usb3_clear_bit(struct renesas_usb3
*usb3
, u32 bits
, u32 offs
)
403 u32 val
= usb3_read(usb3
, offs
);
406 usb3_write(usb3
, val
, offs
);
409 static int usb3_wait(struct renesas_usb3
*usb3
, u32 reg
, u32 mask
,
414 for (i
= 0; i
< USB3_WAIT_US
; i
++) {
415 if ((usb3_read(usb3
, reg
) & mask
) == expected
)
420 dev_dbg(usb3_to_dev(usb3
), "%s: timed out (%8x, %08x, %08x)\n",
421 __func__
, reg
, mask
, expected
);
426 static void renesas_usb3_extcon_work(struct work_struct
*work
)
428 struct renesas_usb3
*usb3
= container_of(work
, struct renesas_usb3
,
431 extcon_set_state_sync(usb3
->extcon
, EXTCON_USB_HOST
, usb3
->extcon_host
);
432 extcon_set_state_sync(usb3
->extcon
, EXTCON_USB
, usb3
->extcon_usb
);
435 static void usb3_enable_irq_1(struct renesas_usb3
*usb3
, u32 bits
)
437 usb3_set_bit(usb3
, bits
, USB3_USB_INT_ENA_1
);
440 static void usb3_disable_irq_1(struct renesas_usb3
*usb3
, u32 bits
)
442 usb3_clear_bit(usb3
, bits
, USB3_USB_INT_ENA_1
);
445 static void usb3_enable_pipe_irq(struct renesas_usb3
*usb3
, int num
)
447 usb3_set_bit(usb3
, USB_INT_2_PIPE(num
), USB3_USB_INT_ENA_2
);
450 static void usb3_disable_pipe_irq(struct renesas_usb3
*usb3
, int num
)
452 usb3_clear_bit(usb3
, USB_INT_2_PIPE(num
), USB3_USB_INT_ENA_2
);
455 static bool usb3_is_host(struct renesas_usb3
*usb3
)
457 return !(usb3_read(usb3
, USB3_DRD_CON
) & DRD_CON_PERI_CON
);
460 static void usb3_init_axi_bridge(struct renesas_usb3
*usb3
)
463 usb3_write(usb3
, ~0, USB3_DMA_INT_STA
);
464 usb3_write(usb3
, 0, USB3_DMA_INT_ENA
);
465 usb3_set_bit(usb3
, AXI_INT_DMAINT
| AXI_INT_EPCINT
, USB3_AXI_INT_ENA
);
468 static void usb3_init_epc_registers(struct renesas_usb3
*usb3
)
470 usb3_write(usb3
, ~0, USB3_USB_INT_STA_1
);
471 usb3_enable_irq_1(usb3
, USB_INT_1_VBUS_CNG
);
474 static bool usb3_wakeup_usb2_phy(struct renesas_usb3
*usb3
)
476 if (!(usb3_read(usb3
, USB3_USB20_CON
) & USB20_CON_B2_SUSPEND
))
477 return true; /* already waked it up */
479 usb3_clear_bit(usb3
, USB20_CON_B2_SUSPEND
, USB3_USB20_CON
);
480 usb3_enable_irq_1(usb3
, USB_INT_1_B2_RSUM
);
485 static void usb3_usb2_pullup(struct renesas_usb3
*usb3
, int pullup
)
487 u32 bits
= USB20_CON_B2_PUE
| USB20_CON_B2_CONNECT
;
489 if (usb3
->softconnect
&& pullup
)
490 usb3_set_bit(usb3
, bits
, USB3_USB20_CON
);
492 usb3_clear_bit(usb3
, bits
, USB3_USB20_CON
);
495 static void usb3_set_test_mode(struct renesas_usb3
*usb3
)
497 u32 val
= usb3_read(usb3
, USB3_USB20_CON
);
499 val
&= ~USB20_CON_B2_TSTMOD_MASK
;
500 val
|= USB20_CON_B2_TSTMOD(usb3
->test_mode
);
501 usb3_write(usb3
, val
| USB20_CON_B2_TSTMOD_EN
, USB3_USB20_CON
);
502 if (!usb3
->test_mode
)
503 usb3_clear_bit(usb3
, USB20_CON_B2_TSTMOD_EN
, USB3_USB20_CON
);
506 static void usb3_start_usb2_connection(struct renesas_usb3
*usb3
)
508 usb3
->disabled_count
++;
509 usb3_set_bit(usb3
, USB_COM_CON_EP0_EN
, USB3_USB_COM_CON
);
510 usb3_set_bit(usb3
, USB_COM_CON_SPD_MODE
, USB3_USB_COM_CON
);
511 usb3_usb2_pullup(usb3
, 1);
514 static int usb3_is_usb3_phy_in_u3(struct renesas_usb3
*usb3
)
516 return usb3_read(usb3
, USB3_USB30_CON
) & USB30_CON_POW_SEL_IN_U3
;
519 static bool usb3_wakeup_usb3_phy(struct renesas_usb3
*usb3
)
521 if (!usb3_is_usb3_phy_in_u3(usb3
))
522 return true; /* already waked it up */
524 usb3_set_bit(usb3
, USB30_CON_B3_PLLWAKE
, USB3_USB30_CON
);
525 usb3_enable_irq_1(usb3
, USB_INT_1_B3_PLLWKUP
);
530 static u16
usb3_feature_get_un_enabled(struct renesas_usb3
*usb3
)
532 u32 mask_u2
= SSIFCMD_UDIR_U2
| SSIFCMD_UREQ_U2
;
533 u32 mask_u1
= SSIFCMD_UDIR_U1
| SSIFCMD_UREQ_U1
;
534 u32 val
= usb3_read(usb3
, USB3_SSIFCMD
);
537 /* Enables {U2,U1} if the bits of UDIR and UREQ are set to 0 */
538 if (!(val
& mask_u2
))
539 ret
|= 1 << USB_DEV_STAT_U2_ENABLED
;
540 if (!(val
& mask_u1
))
541 ret
|= 1 << USB_DEV_STAT_U1_ENABLED
;
546 static void usb3_feature_u2_enable(struct renesas_usb3
*usb3
, bool enable
)
548 u32 bits
= SSIFCMD_UDIR_U2
| SSIFCMD_UREQ_U2
;
550 /* Enables U2 if the bits of UDIR and UREQ are set to 0 */
552 usb3_clear_bit(usb3
, bits
, USB3_SSIFCMD
);
554 usb3_set_bit(usb3
, bits
, USB3_SSIFCMD
);
557 static void usb3_feature_u1_enable(struct renesas_usb3
*usb3
, bool enable
)
559 u32 bits
= SSIFCMD_UDIR_U1
| SSIFCMD_UREQ_U1
;
561 /* Enables U1 if the bits of UDIR and UREQ are set to 0 */
563 usb3_clear_bit(usb3
, bits
, USB3_SSIFCMD
);
565 usb3_set_bit(usb3
, bits
, USB3_SSIFCMD
);
568 static void usb3_start_operation_for_usb3(struct renesas_usb3
*usb3
)
570 usb3_set_bit(usb3
, USB_COM_CON_EP0_EN
, USB3_USB_COM_CON
);
571 usb3_clear_bit(usb3
, USB_COM_CON_SPD_MODE
, USB3_USB_COM_CON
);
572 usb3_set_bit(usb3
, USB30_CON_B3_CONNECT
, USB3_USB30_CON
);
575 static void usb3_start_usb3_connection(struct renesas_usb3
*usb3
)
577 usb3_start_operation_for_usb3(usb3
);
578 usb3_set_bit(usb3
, USB_COM_CON_RX_DETECTION
, USB3_USB_COM_CON
);
580 usb3_enable_irq_1(usb3
, USB_INT_1_B3_LUPSUCS
| USB_INT_1_B3_DISABLE
|
584 static void usb3_stop_usb3_connection(struct renesas_usb3
*usb3
)
586 usb3_clear_bit(usb3
, USB30_CON_B3_CONNECT
, USB3_USB30_CON
);
589 static void usb3_transition_to_default_state(struct renesas_usb3
*usb3
,
592 usb3_set_bit(usb3
, USB_INT_2_PIPE(0), USB3_USB_INT_ENA_2
);
593 usb3_write(usb3
, P0_INT_ALL_BITS
, USB3_P0_INT_STA
);
594 usb3_set_bit(usb3
, P0_INT_ALL_BITS
, USB3_P0_INT_ENA
);
597 usb3_enable_irq_1(usb3
, USB_INT_1_B3_WRMRST
|
598 USB_INT_1_B3_HOTRST
);
600 usb3_enable_irq_1(usb3
, USB_INT_1_B2_SPND
|
601 USB_INT_1_B2_L1SPND
| USB_INT_1_B2_USBRST
);
604 static void usb3_connect(struct renesas_usb3
*usb3
)
606 if (usb3_wakeup_usb3_phy(usb3
))
607 usb3_start_usb3_connection(usb3
);
610 static void usb3_reset_epc(struct renesas_usb3
*usb3
)
612 usb3_clear_bit(usb3
, USB_COM_CON_CONF
, USB3_USB_COM_CON
);
613 usb3_clear_bit(usb3
, USB_COM_CON_EP0_EN
, USB3_USB_COM_CON
);
614 usb3_set_bit(usb3
, USB_COM_CON_PIPE_CLR
, USB3_USB_COM_CON
);
616 usb3_set_test_mode(usb3
);
619 static void usb3_disconnect(struct renesas_usb3
*usb3
)
621 usb3
->disabled_count
= 0;
622 usb3_usb2_pullup(usb3
, 0);
623 usb3_clear_bit(usb3
, USB30_CON_B3_CONNECT
, USB3_USB30_CON
);
624 usb3_reset_epc(usb3
);
625 usb3_disable_irq_1(usb3
, USB_INT_1_B2_RSUM
| USB_INT_1_B3_PLLWKUP
|
626 USB_INT_1_B3_LUPSUCS
| USB_INT_1_B3_DISABLE
|
627 USB_INT_1_SPEED
| USB_INT_1_B3_WRMRST
|
628 USB_INT_1_B3_HOTRST
| USB_INT_1_B2_SPND
|
629 USB_INT_1_B2_L1SPND
| USB_INT_1_B2_USBRST
);
630 usb3_clear_bit(usb3
, USB_COM_CON_SPD_MODE
, USB3_USB_COM_CON
);
631 usb3_init_epc_registers(usb3
);
634 usb3
->driver
->disconnect(&usb3
->gadget
);
637 static void usb3_check_vbus(struct renesas_usb3
*usb3
)
639 if (usb3
->workaround_for_vbus
) {
642 usb3
->extcon_usb
= !!(usb3_read(usb3
, USB3_USB_STA
) &
644 if (usb3
->extcon_usb
)
647 usb3_disconnect(usb3
);
649 schedule_work(&usb3
->extcon_work
);
653 static void usb3_set_mode(struct renesas_usb3
*usb3
, bool host
)
656 usb3_clear_bit(usb3
, DRD_CON_PERI_CON
, USB3_DRD_CON
);
658 usb3_set_bit(usb3
, DRD_CON_PERI_CON
, USB3_DRD_CON
);
661 static void usb3_vbus_out(struct renesas_usb3
*usb3
, bool enable
)
664 usb3_set_bit(usb3
, DRD_CON_VBOUT
, USB3_DRD_CON
);
666 usb3_clear_bit(usb3
, DRD_CON_VBOUT
, USB3_DRD_CON
);
669 static void usb3_mode_config(struct renesas_usb3
*usb3
, bool host
, bool a_dev
)
673 spin_lock_irqsave(&usb3
->lock
, flags
);
674 usb3_set_mode(usb3
, host
);
675 usb3_vbus_out(usb3
, a_dev
);
676 /* for A-Peripheral or forced B-device mode */
677 if ((!host
&& a_dev
) ||
678 (usb3
->workaround_for_vbus
&& usb3
->forced_b_device
))
680 spin_unlock_irqrestore(&usb3
->lock
, flags
);
683 static bool usb3_is_a_device(struct renesas_usb3
*usb3
)
685 return !(usb3_read(usb3
, USB3_USB_OTG_STA
) & USB_OTG_IDMON
);
688 static void usb3_check_id(struct renesas_usb3
*usb3
)
690 usb3
->extcon_host
= usb3_is_a_device(usb3
);
692 if (usb3
->extcon_host
&& !usb3
->forced_b_device
)
693 usb3_mode_config(usb3
, true, true);
695 usb3_mode_config(usb3
, false, false);
697 schedule_work(&usb3
->extcon_work
);
700 static void renesas_usb3_init_controller(struct renesas_usb3
*usb3
)
702 usb3_init_axi_bridge(usb3
);
703 usb3_init_epc_registers(usb3
);
704 usb3_set_bit(usb3
, USB_COM_CON_PN_WDATAIF_NL
|
705 USB_COM_CON_PN_RDATAIF_NL
| USB_COM_CON_PN_LSTTR_PP
,
707 usb3_write(usb3
, USB_OTG_IDMON
, USB3_USB_OTG_INT_STA
);
708 usb3_write(usb3
, USB_OTG_IDMON
, USB3_USB_OTG_INT_ENA
);
711 usb3_check_vbus(usb3
);
714 static void renesas_usb3_stop_controller(struct renesas_usb3
*usb3
)
716 usb3_disconnect(usb3
);
717 usb3_write(usb3
, 0, USB3_P0_INT_ENA
);
718 usb3_write(usb3
, 0, USB3_USB_OTG_INT_ENA
);
719 usb3_write(usb3
, 0, USB3_USB_INT_ENA_1
);
720 usb3_write(usb3
, 0, USB3_USB_INT_ENA_2
);
721 usb3_write(usb3
, 0, USB3_AXI_INT_ENA
);
724 static void usb3_irq_epc_int_1_pll_wakeup(struct renesas_usb3
*usb3
)
726 usb3_disable_irq_1(usb3
, USB_INT_1_B3_PLLWKUP
);
727 usb3_clear_bit(usb3
, USB30_CON_B3_PLLWAKE
, USB3_USB30_CON
);
728 usb3_start_usb3_connection(usb3
);
731 static void usb3_irq_epc_int_1_linkup_success(struct renesas_usb3
*usb3
)
733 usb3_transition_to_default_state(usb3
, true);
736 static void usb3_irq_epc_int_1_resume(struct renesas_usb3
*usb3
)
738 usb3_disable_irq_1(usb3
, USB_INT_1_B2_RSUM
);
739 usb3_start_usb2_connection(usb3
);
740 usb3_transition_to_default_state(usb3
, false);
743 static void usb3_irq_epc_int_1_disable(struct renesas_usb3
*usb3
)
745 usb3_stop_usb3_connection(usb3
);
746 if (usb3_wakeup_usb2_phy(usb3
))
747 usb3_irq_epc_int_1_resume(usb3
);
750 static void usb3_irq_epc_int_1_bus_reset(struct renesas_usb3
*usb3
)
752 usb3_reset_epc(usb3
);
753 if (usb3
->disabled_count
< 3)
754 usb3_start_usb3_connection(usb3
);
756 usb3_start_usb2_connection(usb3
);
759 static void usb3_irq_epc_int_1_vbus_change(struct renesas_usb3
*usb3
)
761 usb3_check_vbus(usb3
);
764 static void usb3_irq_epc_int_1_hot_reset(struct renesas_usb3
*usb3
)
766 usb3_reset_epc(usb3
);
767 usb3_set_bit(usb3
, USB_COM_CON_EP0_EN
, USB3_USB_COM_CON
);
769 /* This bit shall be set within 12ms from the start of HotReset */
770 usb3_set_bit(usb3
, USB30_CON_B3_HOTRST_CMP
, USB3_USB30_CON
);
773 static void usb3_irq_epc_int_1_warm_reset(struct renesas_usb3
*usb3
)
775 usb3_reset_epc(usb3
);
776 usb3_set_bit(usb3
, USB_COM_CON_EP0_EN
, USB3_USB_COM_CON
);
778 usb3_start_operation_for_usb3(usb3
);
779 usb3_enable_irq_1(usb3
, USB_INT_1_SPEED
);
782 static void usb3_irq_epc_int_1_speed(struct renesas_usb3
*usb3
)
784 u32 speed
= usb3_read(usb3
, USB3_USB_STA
) & USB_STA_SPEED_MASK
;
787 case USB_STA_SPEED_SS
:
788 usb3
->gadget
.speed
= USB_SPEED_SUPER
;
790 case USB_STA_SPEED_HS
:
791 usb3
->gadget
.speed
= USB_SPEED_HIGH
;
793 case USB_STA_SPEED_FS
:
794 usb3
->gadget
.speed
= USB_SPEED_FULL
;
797 usb3
->gadget
.speed
= USB_SPEED_UNKNOWN
;
802 static void usb3_irq_epc_int_1(struct renesas_usb3
*usb3
, u32 int_sta_1
)
804 if (int_sta_1
& USB_INT_1_B3_PLLWKUP
)
805 usb3_irq_epc_int_1_pll_wakeup(usb3
);
807 if (int_sta_1
& USB_INT_1_B3_LUPSUCS
)
808 usb3_irq_epc_int_1_linkup_success(usb3
);
810 if (int_sta_1
& USB_INT_1_B3_HOTRST
)
811 usb3_irq_epc_int_1_hot_reset(usb3
);
813 if (int_sta_1
& USB_INT_1_B3_WRMRST
)
814 usb3_irq_epc_int_1_warm_reset(usb3
);
816 if (int_sta_1
& USB_INT_1_B3_DISABLE
)
817 usb3_irq_epc_int_1_disable(usb3
);
819 if (int_sta_1
& USB_INT_1_B2_USBRST
)
820 usb3_irq_epc_int_1_bus_reset(usb3
);
822 if (int_sta_1
& USB_INT_1_B2_RSUM
)
823 usb3_irq_epc_int_1_resume(usb3
);
825 if (int_sta_1
& USB_INT_1_SPEED
)
826 usb3_irq_epc_int_1_speed(usb3
);
828 if (int_sta_1
& USB_INT_1_VBUS_CNG
)
829 usb3_irq_epc_int_1_vbus_change(usb3
);
832 static struct renesas_usb3_request
*__usb3_get_request(struct renesas_usb3_ep
835 return list_first_entry_or_null(&usb3_ep
->queue
,
836 struct renesas_usb3_request
, queue
);
839 static struct renesas_usb3_request
*usb3_get_request(struct renesas_usb3_ep
842 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
843 struct renesas_usb3_request
*usb3_req
;
846 spin_lock_irqsave(&usb3
->lock
, flags
);
847 usb3_req
= __usb3_get_request(usb3_ep
);
848 spin_unlock_irqrestore(&usb3
->lock
, flags
);
853 static void __usb3_request_done(struct renesas_usb3_ep
*usb3_ep
,
854 struct renesas_usb3_request
*usb3_req
,
857 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
859 dev_dbg(usb3_to_dev(usb3
), "giveback: ep%2d, %u, %u, %d\n",
860 usb3_ep
->num
, usb3_req
->req
.length
, usb3_req
->req
.actual
,
862 usb3_req
->req
.status
= status
;
863 usb3_ep
->started
= false;
864 list_del_init(&usb3_req
->queue
);
865 spin_unlock(&usb3
->lock
);
866 usb_gadget_giveback_request(&usb3_ep
->ep
, &usb3_req
->req
);
867 spin_lock(&usb3
->lock
);
870 static void usb3_request_done(struct renesas_usb3_ep
*usb3_ep
,
871 struct renesas_usb3_request
*usb3_req
, int status
)
873 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
876 spin_lock_irqsave(&usb3
->lock
, flags
);
877 __usb3_request_done(usb3_ep
, usb3_req
, status
);
878 spin_unlock_irqrestore(&usb3
->lock
, flags
);
881 static void usb3_irq_epc_pipe0_status_end(struct renesas_usb3
*usb3
)
883 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, 0);
884 struct renesas_usb3_request
*usb3_req
= usb3_get_request(usb3_ep
);
887 usb3_request_done(usb3_ep
, usb3_req
, 0);
889 usb3_set_test_mode(usb3
);
892 static void usb3_get_setup_data(struct renesas_usb3
*usb3
,
893 struct usb_ctrlrequest
*ctrl
)
895 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, 0);
896 u32
*data
= (u32
*)ctrl
;
898 *data
++ = usb3_read(usb3
, USB3_STUP_DAT_0
);
899 *data
= usb3_read(usb3
, USB3_STUP_DAT_1
);
901 /* update this driver's flag */
902 usb3_ep
->dir_in
= !!(ctrl
->bRequestType
& USB_DIR_IN
);
905 static void usb3_set_p0_con_update_res(struct renesas_usb3
*usb3
, u32 res
)
907 u32 val
= usb3_read(usb3
, USB3_P0_CON
);
909 val
&= ~(P0_CON_ST_RES_MASK
| P0_CON_OT_RES_MASK
| P0_CON_IN_RES_MASK
);
910 val
|= res
| P0_CON_RES_WEN
;
911 usb3_write(usb3
, val
, USB3_P0_CON
);
914 static void usb3_set_p0_con_for_ctrl_read_data(struct renesas_usb3
*usb3
)
916 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_FORCE_NRDY
|
917 P0_CON_OT_RES_FORCE_STALL
|
918 P0_CON_IN_RES_NORMAL
);
921 static void usb3_set_p0_con_for_ctrl_read_status(struct renesas_usb3
*usb3
)
923 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_NORMAL
|
924 P0_CON_OT_RES_FORCE_STALL
|
925 P0_CON_IN_RES_NORMAL
);
928 static void usb3_set_p0_con_for_ctrl_write_data(struct renesas_usb3
*usb3
)
930 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_FORCE_NRDY
|
931 P0_CON_OT_RES_NORMAL
|
932 P0_CON_IN_RES_FORCE_STALL
);
935 static void usb3_set_p0_con_for_ctrl_write_status(struct renesas_usb3
*usb3
)
937 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_NORMAL
|
938 P0_CON_OT_RES_NORMAL
|
939 P0_CON_IN_RES_FORCE_STALL
);
942 static void usb3_set_p0_con_for_no_data(struct renesas_usb3
*usb3
)
944 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_NORMAL
|
945 P0_CON_OT_RES_FORCE_STALL
|
946 P0_CON_IN_RES_FORCE_STALL
);
949 static void usb3_set_p0_con_stall(struct renesas_usb3
*usb3
)
951 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_FORCE_STALL
|
952 P0_CON_OT_RES_FORCE_STALL
|
953 P0_CON_IN_RES_FORCE_STALL
);
956 static void usb3_set_p0_con_stop(struct renesas_usb3
*usb3
)
958 usb3_set_p0_con_update_res(usb3
, P0_CON_ST_RES_FORCE_NRDY
|
959 P0_CON_OT_RES_FORCE_NRDY
|
960 P0_CON_IN_RES_FORCE_NRDY
);
963 static int usb3_pn_change(struct renesas_usb3
*usb3
, int num
)
965 if (num
== 0 || num
> usb3
->num_usb3_eps
)
968 usb3_write(usb3
, num
, USB3_PIPE_COM
);
973 static void usb3_set_pn_con_update_res(struct renesas_usb3
*usb3
, u32 res
)
975 u32 val
= usb3_read(usb3
, USB3_PN_CON
);
977 val
&= ~PN_CON_RES_MASK
;
978 val
|= res
& PN_CON_RES_MASK
;
979 val
|= PN_CON_RES_WEN
;
980 usb3_write(usb3
, val
, USB3_PN_CON
);
983 static void usb3_pn_start(struct renesas_usb3
*usb3
)
985 usb3_set_pn_con_update_res(usb3
, PN_CON_RES_NORMAL
);
988 static void usb3_pn_stop(struct renesas_usb3
*usb3
)
990 usb3_set_pn_con_update_res(usb3
, PN_CON_RES_FORCE_NRDY
);
993 static void usb3_pn_stall(struct renesas_usb3
*usb3
)
995 usb3_set_pn_con_update_res(usb3
, PN_CON_RES_FORCE_STALL
);
998 static int usb3_pn_con_clear(struct renesas_usb3
*usb3
)
1000 usb3_set_bit(usb3
, PN_CON_CLR
, USB3_PN_CON
);
1002 return usb3_wait(usb3
, USB3_PN_CON
, PN_CON_CLR
, 0);
1005 static bool usb3_is_transfer_complete(struct renesas_usb3_ep
*usb3_ep
,
1006 struct renesas_usb3_request
*usb3_req
)
1008 struct usb_request
*req
= &usb3_req
->req
;
1010 if ((!req
->zero
&& req
->actual
== req
->length
) ||
1011 (req
->actual
% usb3_ep
->ep
.maxpacket
) || (req
->length
== 0))
1017 static int usb3_wait_pipe_status(struct renesas_usb3_ep
*usb3_ep
, u32 mask
)
1019 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1020 u32 sta_reg
= usb3_ep
->num
? USB3_PN_STA
: USB3_P0_STA
;
1022 return usb3_wait(usb3
, sta_reg
, mask
, mask
);
1025 static void usb3_set_px_con_send(struct renesas_usb3_ep
*usb3_ep
, int bytes
,
1028 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1029 u32 con_reg
= usb3_ep
->num
? USB3_PN_CON
: USB3_P0_CON
;
1030 u32 val
= usb3_read(usb3
, con_reg
);
1032 val
|= PX_CON_SEND
| PX_CON_BYTE_EN_BYTES(bytes
);
1033 val
|= (usb3_ep
->num
&& last
) ? PN_CON_LAST
: 0;
1034 usb3_write(usb3
, val
, con_reg
);
1037 static int usb3_write_pipe(struct renesas_usb3_ep
*usb3_ep
,
1038 struct renesas_usb3_request
*usb3_req
,
1041 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1043 int len
= min_t(unsigned, usb3_req
->req
.length
- usb3_req
->req
.actual
,
1044 usb3_ep
->ep
.maxpacket
);
1045 u8
*buf
= usb3_req
->req
.buf
+ usb3_req
->req
.actual
;
1047 bool is_last
= !len
? true : false;
1049 if (usb3_wait_pipe_status(usb3_ep
, PX_STA_BUFSTS
) < 0)
1052 /* Update gadget driver parameter */
1053 usb3_req
->req
.actual
+= len
;
1055 /* Write data to the register */
1057 iowrite32_rep(usb3
->reg
+ fifo_reg
, buf
, len
/ 4);
1058 buf
+= (len
/ 4) * 4;
1059 len
%= 4; /* update len to use usb3_set_pX_con_send() */
1063 for (i
= 0; i
< len
; i
++)
1064 tmp
|= buf
[i
] << (8 * i
);
1065 usb3_write(usb3
, tmp
, fifo_reg
);
1069 is_last
= usb3_is_transfer_complete(usb3_ep
, usb3_req
);
1071 usb3_set_px_con_send(usb3_ep
, len
, is_last
);
1073 return is_last
? 0 : -EAGAIN
;
1076 static u32
usb3_get_received_length(struct renesas_usb3_ep
*usb3_ep
)
1078 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1079 u32 lng_reg
= usb3_ep
->num
? USB3_PN_LNG
: USB3_P0_LNG
;
1081 return usb3_read(usb3
, lng_reg
);
1084 static int usb3_read_pipe(struct renesas_usb3_ep
*usb3_ep
,
1085 struct renesas_usb3_request
*usb3_req
, u32 fifo_reg
)
1087 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1089 int len
= min_t(unsigned, usb3_req
->req
.length
- usb3_req
->req
.actual
,
1090 usb3_get_received_length(usb3_ep
));
1091 u8
*buf
= usb3_req
->req
.buf
+ usb3_req
->req
.actual
;
1097 /* Update gadget driver parameter */
1098 usb3_req
->req
.actual
+= len
;
1100 /* Read data from the register */
1102 ioread32_rep(usb3
->reg
+ fifo_reg
, buf
, len
/ 4);
1103 buf
+= (len
/ 4) * 4;
1108 tmp
= usb3_read(usb3
, fifo_reg
);
1109 for (i
= 0; i
< len
; i
++)
1110 buf
[i
] = (tmp
>> (8 * i
)) & 0xff;
1113 return usb3_is_transfer_complete(usb3_ep
, usb3_req
) ? 0 : -EAGAIN
;
1116 static void usb3_set_status_stage(struct renesas_usb3_ep
*usb3_ep
,
1117 struct renesas_usb3_request
*usb3_req
)
1119 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1121 if (usb3_ep
->dir_in
) {
1122 usb3_set_p0_con_for_ctrl_read_status(usb3
);
1124 if (!usb3_req
->req
.length
)
1125 usb3_set_p0_con_for_no_data(usb3
);
1127 usb3_set_p0_con_for_ctrl_write_status(usb3
);
1131 static void usb3_p0_xfer(struct renesas_usb3_ep
*usb3_ep
,
1132 struct renesas_usb3_request
*usb3_req
)
1136 if (usb3_ep
->dir_in
)
1137 ret
= usb3_write_pipe(usb3_ep
, usb3_req
, USB3_P0_WRITE
);
1139 ret
= usb3_read_pipe(usb3_ep
, usb3_req
, USB3_P0_READ
);
1142 usb3_set_status_stage(usb3_ep
, usb3_req
);
1145 static void usb3_start_pipe0(struct renesas_usb3_ep
*usb3_ep
,
1146 struct renesas_usb3_request
*usb3_req
)
1148 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1150 if (usb3_ep
->started
)
1153 usb3_ep
->started
= true;
1155 if (usb3_ep
->dir_in
) {
1156 usb3_set_bit(usb3
, P0_MOD_DIR
, USB3_P0_MOD
);
1157 usb3_set_p0_con_for_ctrl_read_data(usb3
);
1159 usb3_clear_bit(usb3
, P0_MOD_DIR
, USB3_P0_MOD
);
1160 if (usb3_req
->req
.length
)
1161 usb3_set_p0_con_for_ctrl_write_data(usb3
);
1164 usb3_p0_xfer(usb3_ep
, usb3_req
);
1167 static void usb3_enable_dma_pipen(struct renesas_usb3
*usb3
)
1169 usb3_set_bit(usb3
, PN_CON_DATAIF_EN
, USB3_PN_CON
);
1172 static void usb3_disable_dma_pipen(struct renesas_usb3
*usb3
)
1174 usb3_clear_bit(usb3
, PN_CON_DATAIF_EN
, USB3_PN_CON
);
1177 static void usb3_enable_dma_irq(struct renesas_usb3
*usb3
, int num
)
1179 usb3_set_bit(usb3
, DMA_INT(num
), USB3_DMA_INT_ENA
);
1182 static void usb3_disable_dma_irq(struct renesas_usb3
*usb3
, int num
)
1184 usb3_clear_bit(usb3
, DMA_INT(num
), USB3_DMA_INT_ENA
);
1187 static u32
usb3_dma_mps_to_prd_word1(struct renesas_usb3_ep
*usb3_ep
)
1189 switch (usb3_ep
->ep
.maxpacket
) {
1191 return USB3_PRD1_MPS_8
;
1193 return USB3_PRD1_MPS_16
;
1195 return USB3_PRD1_MPS_32
;
1197 return USB3_PRD1_MPS_64
;
1199 return USB3_PRD1_MPS_512
;
1201 return USB3_PRD1_MPS_1024
;
1203 return USB3_PRD1_MPS_RESERVED
;
1207 static bool usb3_dma_get_setting_area(struct renesas_usb3_ep
*usb3_ep
,
1208 struct renesas_usb3_request
*usb3_req
)
1210 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1211 struct renesas_usb3_dma
*dma
;
1215 if (usb3_req
->req
.length
> USB3_DMA_MAX_XFER_SIZE_ALL_PRDS
) {
1216 dev_dbg(usb3_to_dev(usb3
), "%s: the length is too big (%d)\n",
1217 __func__
, usb3_req
->req
.length
);
1221 /* The driver doesn't handle zero-length packet via dmac */
1222 if (!usb3_req
->req
.length
)
1225 if (usb3_dma_mps_to_prd_word1(usb3_ep
) == USB3_PRD1_MPS_RESERVED
)
1228 usb3_for_each_dma(usb3
, dma
, i
) {
1232 if (usb_gadget_map_request(&usb3
->gadget
, &usb3_req
->req
,
1233 usb3_ep
->dir_in
) < 0)
1245 static void usb3_dma_put_setting_area(struct renesas_usb3_ep
*usb3_ep
,
1246 struct renesas_usb3_request
*usb3_req
)
1248 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1250 struct renesas_usb3_dma
*dma
;
1252 usb3_for_each_dma(usb3
, dma
, i
) {
1253 if (usb3_ep
->dma
== dma
) {
1254 usb_gadget_unmap_request(&usb3
->gadget
, &usb3_req
->req
,
1257 usb3_ep
->dma
= NULL
;
1263 static void usb3_dma_fill_prd(struct renesas_usb3_ep
*usb3_ep
,
1264 struct renesas_usb3_request
*usb3_req
)
1266 struct renesas_usb3_prd
*cur_prd
= usb3_ep
->dma
->prd
;
1267 u32 remain
= usb3_req
->req
.length
;
1268 u32 dma
= usb3_req
->req
.dma
;
1273 len
= min_t(u32
, remain
, USB3_DMA_MAX_XFER_SIZE
) &
1274 USB3_PRD1_SIZE_MASK
;
1275 cur_prd
->word1
= usb3_dma_mps_to_prd_word1(usb3_ep
) |
1276 USB3_PRD1_B_INC
| len
;
1280 if (!remain
|| (i
+ 1) < USB3_DMA_NUM_PRD_ENTRIES
)
1287 cur_prd
->word1
|= USB3_PRD1_E
| USB3_PRD1_INT
;
1288 if (usb3_ep
->dir_in
)
1289 cur_prd
->word1
|= USB3_PRD1_LST
;
1292 static void usb3_dma_kick_prd(struct renesas_usb3_ep
*usb3_ep
)
1294 struct renesas_usb3_dma
*dma
= usb3_ep
->dma
;
1295 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1296 u32 dma_con
= DMA_COM_PIPE_NO(usb3_ep
->num
) | DMA_CON_PRD_EN
;
1298 if (usb3_ep
->dir_in
)
1299 dma_con
|= DMA_CON_PIPE_DIR
;
1301 wmb(); /* prd entries should be in system memory here */
1303 usb3_write(usb3
, 1 << usb3_ep
->num
, USB3_DMA_INT_STA
);
1304 usb3_write(usb3
, AXI_INT_PRDEN_CLR_STA(dma
->num
) |
1305 AXI_INT_PRDERR_STA(dma
->num
), USB3_AXI_INT_STA
);
1307 usb3_write(usb3
, dma
->prd_dma
, USB3_DMA_CH0_PRD_ADR(dma
->num
));
1308 usb3_write(usb3
, dma_con
, USB3_DMA_CH0_CON(dma
->num
));
1309 usb3_enable_dma_irq(usb3
, usb3_ep
->num
);
1312 static void usb3_dma_stop_prd(struct renesas_usb3_ep
*usb3_ep
)
1314 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1315 struct renesas_usb3_dma
*dma
= usb3_ep
->dma
;
1317 usb3_disable_dma_irq(usb3
, usb3_ep
->num
);
1318 usb3_write(usb3
, 0, USB3_DMA_CH0_CON(dma
->num
));
1321 static int usb3_dma_update_status(struct renesas_usb3_ep
*usb3_ep
,
1322 struct renesas_usb3_request
*usb3_req
)
1324 struct renesas_usb3_prd
*cur_prd
= usb3_ep
->dma
->prd
;
1325 struct usb_request
*req
= &usb3_req
->req
;
1330 rmb(); /* The controller updated prd entries */
1333 if (cur_prd
->word1
& USB3_PRD1_D
)
1335 if (cur_prd
->word1
& USB3_PRD1_E
)
1336 len
= req
->length
% USB3_DMA_MAX_XFER_SIZE
;
1338 len
= USB3_DMA_MAX_XFER_SIZE
;
1339 remain
= cur_prd
->word1
& USB3_PRD1_SIZE_MASK
;
1340 req
->actual
+= len
- remain
;
1342 if (cur_prd
->word1
& USB3_PRD1_E
||
1343 (i
+ 1) < USB3_DMA_NUM_PRD_ENTRIES
)
1353 static bool usb3_dma_try_start(struct renesas_usb3_ep
*usb3_ep
,
1354 struct renesas_usb3_request
*usb3_req
)
1356 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1361 if (usb3_dma_get_setting_area(usb3_ep
, usb3_req
)) {
1363 usb3_enable_dma_pipen(usb3
);
1364 usb3_dma_fill_prd(usb3_ep
, usb3_req
);
1365 usb3_dma_kick_prd(usb3_ep
);
1366 usb3_pn_start(usb3
);
1373 static int usb3_dma_try_stop(struct renesas_usb3_ep
*usb3_ep
,
1374 struct renesas_usb3_request
*usb3_req
)
1376 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1377 unsigned long flags
;
1380 spin_lock_irqsave(&usb3
->lock
, flags
);
1384 if (!usb3_pn_change(usb3
, usb3_ep
->num
))
1385 usb3_disable_dma_pipen(usb3
);
1386 usb3_dma_stop_prd(usb3_ep
);
1387 status
= usb3_dma_update_status(usb3_ep
, usb3_req
);
1388 usb3_dma_put_setting_area(usb3_ep
, usb3_req
);
1391 spin_unlock_irqrestore(&usb3
->lock
, flags
);
1395 static int renesas_usb3_dma_free_prd(struct renesas_usb3
*usb3
,
1399 struct renesas_usb3_dma
*dma
;
1401 usb3_for_each_dma(usb3
, dma
, i
) {
1403 dma_free_coherent(dev
, USB3_DMA_PRD_SIZE
,
1404 dma
->prd
, dma
->prd_dma
);
1412 static int renesas_usb3_dma_alloc_prd(struct renesas_usb3
*usb3
,
1416 struct renesas_usb3_dma
*dma
;
1421 usb3_for_each_dma(usb3
, dma
, i
) {
1422 dma
->prd
= dma_alloc_coherent(dev
, USB3_DMA_PRD_SIZE
,
1423 &dma
->prd_dma
, GFP_KERNEL
);
1425 renesas_usb3_dma_free_prd(usb3
, dev
);
1434 static void usb3_start_pipen(struct renesas_usb3_ep
*usb3_ep
,
1435 struct renesas_usb3_request
*usb3_req
)
1437 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1438 struct renesas_usb3_request
*usb3_req_first
= usb3_get_request(usb3_ep
);
1439 unsigned long flags
;
1441 u32 enable_bits
= 0;
1443 spin_lock_irqsave(&usb3
->lock
, flags
);
1444 if (usb3_ep
->halt
|| usb3_ep
->started
)
1446 if (usb3_req
!= usb3_req_first
)
1449 if (usb3_pn_change(usb3
, usb3_ep
->num
) < 0)
1452 usb3_ep
->started
= true;
1454 if (usb3_dma_try_start(usb3_ep
, usb3_req
))
1457 usb3_pn_start(usb3
);
1459 if (usb3_ep
->dir_in
) {
1460 ret
= usb3_write_pipe(usb3_ep
, usb3_req
, USB3_PN_WRITE
);
1461 enable_bits
|= PN_INT_LSTTR
;
1465 enable_bits
|= PN_INT_BFRDY
;
1468 usb3_set_bit(usb3
, enable_bits
, USB3_PN_INT_ENA
);
1469 usb3_enable_pipe_irq(usb3
, usb3_ep
->num
);
1472 spin_unlock_irqrestore(&usb3
->lock
, flags
);
1475 static int renesas_usb3_ep_queue(struct usb_ep
*_ep
, struct usb_request
*_req
,
1478 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
1479 struct renesas_usb3_request
*usb3_req
= usb_req_to_usb3_req(_req
);
1480 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1481 unsigned long flags
;
1483 dev_dbg(usb3_to_dev(usb3
), "ep_queue: ep%2d, %u\n", usb3_ep
->num
,
1486 _req
->status
= -EINPROGRESS
;
1488 spin_lock_irqsave(&usb3
->lock
, flags
);
1489 list_add_tail(&usb3_req
->queue
, &usb3_ep
->queue
);
1490 spin_unlock_irqrestore(&usb3
->lock
, flags
);
1493 usb3_start_pipe0(usb3_ep
, usb3_req
);
1495 usb3_start_pipen(usb3_ep
, usb3_req
);
1500 static void usb3_set_device_address(struct renesas_usb3
*usb3
, u16 addr
)
1502 /* DEV_ADDR bit field is cleared by WarmReset, HotReset and BusReset */
1503 usb3_set_bit(usb3
, USB_COM_CON_DEV_ADDR(addr
), USB3_USB_COM_CON
);
1506 static bool usb3_std_req_set_address(struct renesas_usb3
*usb3
,
1507 struct usb_ctrlrequest
*ctrl
)
1509 if (ctrl
->wValue
>= 128)
1510 return true; /* stall */
1512 usb3_set_device_address(usb3
, ctrl
->wValue
);
1513 usb3_set_p0_con_for_no_data(usb3
);
1518 static void usb3_pipe0_internal_xfer(struct renesas_usb3
*usb3
,
1519 void *tx_data
, size_t len
,
1520 void (*complete
)(struct usb_ep
*ep
,
1521 struct usb_request
*req
))
1523 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, 0);
1526 memcpy(usb3
->ep0_buf
, tx_data
,
1527 min_t(size_t, len
, USB3_EP0_BUF_SIZE
));
1529 usb3
->ep0_req
->buf
= &usb3
->ep0_buf
;
1530 usb3
->ep0_req
->length
= len
;
1531 usb3
->ep0_req
->complete
= complete
;
1532 renesas_usb3_ep_queue(&usb3_ep
->ep
, usb3
->ep0_req
, GFP_ATOMIC
);
1535 static void usb3_pipe0_get_status_completion(struct usb_ep
*ep
,
1536 struct usb_request
*req
)
1540 static bool usb3_std_req_get_status(struct renesas_usb3
*usb3
,
1541 struct usb_ctrlrequest
*ctrl
)
1544 struct renesas_usb3_ep
*usb3_ep
;
1548 switch (ctrl
->bRequestType
& USB_RECIP_MASK
) {
1549 case USB_RECIP_DEVICE
:
1550 if (usb3
->gadget
.is_selfpowered
)
1551 status
|= 1 << USB_DEVICE_SELF_POWERED
;
1552 if (usb3
->gadget
.speed
== USB_SPEED_SUPER
)
1553 status
|= usb3_feature_get_un_enabled(usb3
);
1555 case USB_RECIP_INTERFACE
:
1557 case USB_RECIP_ENDPOINT
:
1558 num
= le16_to_cpu(ctrl
->wIndex
) & USB_ENDPOINT_NUMBER_MASK
;
1559 usb3_ep
= usb3_get_ep(usb3
, num
);
1561 status
|= 1 << USB_ENDPOINT_HALT
;
1569 status
= cpu_to_le16(status
);
1570 dev_dbg(usb3_to_dev(usb3
), "get_status: req = %p\n",
1571 usb_req_to_usb3_req(usb3
->ep0_req
));
1572 usb3_pipe0_internal_xfer(usb3
, &status
, sizeof(status
),
1573 usb3_pipe0_get_status_completion
);
1579 static bool usb3_std_req_feature_device(struct renesas_usb3
*usb3
,
1580 struct usb_ctrlrequest
*ctrl
, bool set
)
1583 u16 w_value
= le16_to_cpu(ctrl
->wValue
);
1586 case USB_DEVICE_TEST_MODE
:
1589 usb3
->test_mode
= le16_to_cpu(ctrl
->wIndex
) >> 8;
1592 case USB_DEVICE_U1_ENABLE
:
1593 case USB_DEVICE_U2_ENABLE
:
1594 if (usb3
->gadget
.speed
!= USB_SPEED_SUPER
)
1596 if (w_value
== USB_DEVICE_U1_ENABLE
)
1597 usb3_feature_u1_enable(usb3
, set
);
1598 if (w_value
== USB_DEVICE_U2_ENABLE
)
1599 usb3_feature_u2_enable(usb3
, set
);
1609 static int usb3_set_halt_p0(struct renesas_usb3_ep
*usb3_ep
, bool halt
)
1611 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1613 if (unlikely(usb3_ep
->num
))
1616 usb3_ep
->halt
= halt
;
1618 usb3_set_p0_con_stall(usb3
);
1620 usb3_set_p0_con_stop(usb3
);
1625 static int usb3_set_halt_pn(struct renesas_usb3_ep
*usb3_ep
, bool halt
,
1626 bool is_clear_feature
)
1628 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
1629 unsigned long flags
;
1631 spin_lock_irqsave(&usb3
->lock
, flags
);
1632 if (!usb3_pn_change(usb3
, usb3_ep
->num
)) {
1633 usb3_ep
->halt
= halt
;
1635 usb3_pn_stall(usb3
);
1636 } else if (!is_clear_feature
|| !usb3_ep
->wedge
) {
1637 usb3_pn_con_clear(usb3
);
1638 usb3_set_bit(usb3
, PN_CON_EN
, USB3_PN_CON
);
1642 spin_unlock_irqrestore(&usb3
->lock
, flags
);
1647 static int usb3_set_halt(struct renesas_usb3_ep
*usb3_ep
, bool halt
,
1648 bool is_clear_feature
)
1652 if (halt
&& usb3_ep
->started
)
1656 ret
= usb3_set_halt_pn(usb3_ep
, halt
, is_clear_feature
);
1658 ret
= usb3_set_halt_p0(usb3_ep
, halt
);
1663 static bool usb3_std_req_feature_endpoint(struct renesas_usb3
*usb3
,
1664 struct usb_ctrlrequest
*ctrl
,
1667 int num
= le16_to_cpu(ctrl
->wIndex
) & USB_ENDPOINT_NUMBER_MASK
;
1668 struct renesas_usb3_ep
*usb3_ep
;
1669 struct renesas_usb3_request
*usb3_req
;
1671 if (le16_to_cpu(ctrl
->wValue
) != USB_ENDPOINT_HALT
)
1672 return true; /* stall */
1674 usb3_ep
= usb3_get_ep(usb3
, num
);
1675 usb3_set_halt(usb3_ep
, set
, true);
1677 /* Restarts a queue if clear feature */
1679 usb3_ep
->started
= false;
1680 usb3_req
= usb3_get_request(usb3_ep
);
1682 usb3_start_pipen(usb3_ep
, usb3_req
);
1688 static bool usb3_std_req_feature(struct renesas_usb3
*usb3
,
1689 struct usb_ctrlrequest
*ctrl
, bool set
)
1693 switch (ctrl
->bRequestType
& USB_RECIP_MASK
) {
1694 case USB_RECIP_DEVICE
:
1695 stall
= usb3_std_req_feature_device(usb3
, ctrl
, set
);
1697 case USB_RECIP_INTERFACE
:
1699 case USB_RECIP_ENDPOINT
:
1700 stall
= usb3_std_req_feature_endpoint(usb3
, ctrl
, set
);
1708 usb3_set_p0_con_for_no_data(usb3
);
1713 static void usb3_pipe0_set_sel_completion(struct usb_ep
*ep
,
1714 struct usb_request
*req
)
1719 static bool usb3_std_req_set_sel(struct renesas_usb3
*usb3
,
1720 struct usb_ctrlrequest
*ctrl
)
1722 u16 w_length
= le16_to_cpu(ctrl
->wLength
);
1725 return true; /* stall */
1727 dev_dbg(usb3_to_dev(usb3
), "set_sel: req = %p\n",
1728 usb_req_to_usb3_req(usb3
->ep0_req
));
1729 usb3_pipe0_internal_xfer(usb3
, NULL
, 6, usb3_pipe0_set_sel_completion
);
1734 static bool usb3_std_req_set_configuration(struct renesas_usb3
*usb3
,
1735 struct usb_ctrlrequest
*ctrl
)
1737 if (ctrl
->wValue
> 0)
1738 usb3_set_bit(usb3
, USB_COM_CON_CONF
, USB3_USB_COM_CON
);
1740 usb3_clear_bit(usb3
, USB_COM_CON_CONF
, USB3_USB_COM_CON
);
1746 * usb3_handle_standard_request - handle some standard requests
1747 * @usb3: the renesas_usb3 pointer
1748 * @ctrl: a pointer of setup data
1750 * Returns true if this function handled a standard request
1752 static bool usb3_handle_standard_request(struct renesas_usb3
*usb3
,
1753 struct usb_ctrlrequest
*ctrl
)
1758 if ((ctrl
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_STANDARD
) {
1759 switch (ctrl
->bRequest
) {
1760 case USB_REQ_SET_ADDRESS
:
1761 stall
= usb3_std_req_set_address(usb3
, ctrl
);
1764 case USB_REQ_GET_STATUS
:
1765 stall
= usb3_std_req_get_status(usb3
, ctrl
);
1768 case USB_REQ_CLEAR_FEATURE
:
1769 stall
= usb3_std_req_feature(usb3
, ctrl
, false);
1772 case USB_REQ_SET_FEATURE
:
1773 stall
= usb3_std_req_feature(usb3
, ctrl
, true);
1776 case USB_REQ_SET_SEL
:
1777 stall
= usb3_std_req_set_sel(usb3
, ctrl
);
1780 case USB_REQ_SET_ISOCH_DELAY
:
1781 /* This hardware doesn't support Isochronous xfer */
1785 case USB_REQ_SET_CONFIGURATION
:
1786 usb3_std_req_set_configuration(usb3
, ctrl
);
1794 usb3_set_p0_con_stall(usb3
);
1799 static int usb3_p0_con_clear_buffer(struct renesas_usb3
*usb3
)
1801 usb3_set_bit(usb3
, P0_CON_BCLR
, USB3_P0_CON
);
1803 return usb3_wait(usb3
, USB3_P0_CON
, P0_CON_BCLR
, 0);
1806 static void usb3_irq_epc_pipe0_setup(struct renesas_usb3
*usb3
)
1808 struct usb_ctrlrequest ctrl
;
1809 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, 0);
1811 /* Call giveback function if previous transfer is not completed */
1812 if (usb3_ep
->started
)
1813 usb3_request_done(usb3_ep
, usb3_get_request(usb3_ep
),
1816 usb3_p0_con_clear_buffer(usb3
);
1817 usb3_get_setup_data(usb3
, &ctrl
);
1818 if (!usb3_handle_standard_request(usb3
, &ctrl
))
1819 if (usb3
->driver
->setup(&usb3
->gadget
, &ctrl
) < 0)
1820 usb3_set_p0_con_stall(usb3
);
1823 static void usb3_irq_epc_pipe0_bfrdy(struct renesas_usb3
*usb3
)
1825 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, 0);
1826 struct renesas_usb3_request
*usb3_req
= usb3_get_request(usb3_ep
);
1831 usb3_p0_xfer(usb3_ep
, usb3_req
);
1834 static void usb3_irq_epc_pipe0(struct renesas_usb3
*usb3
)
1836 u32 p0_int_sta
= usb3_read(usb3
, USB3_P0_INT_STA
);
1838 p0_int_sta
&= usb3_read(usb3
, USB3_P0_INT_ENA
);
1839 usb3_write(usb3
, p0_int_sta
, USB3_P0_INT_STA
);
1840 if (p0_int_sta
& P0_INT_STSED
)
1841 usb3_irq_epc_pipe0_status_end(usb3
);
1842 if (p0_int_sta
& P0_INT_SETUP
)
1843 usb3_irq_epc_pipe0_setup(usb3
);
1844 if (p0_int_sta
& P0_INT_BFRDY
)
1845 usb3_irq_epc_pipe0_bfrdy(usb3
);
1848 static void usb3_request_done_pipen(struct renesas_usb3
*usb3
,
1849 struct renesas_usb3_ep
*usb3_ep
,
1850 struct renesas_usb3_request
*usb3_req
,
1853 unsigned long flags
;
1855 spin_lock_irqsave(&usb3
->lock
, flags
);
1856 if (usb3_pn_change(usb3
, usb3_ep
->num
))
1858 spin_unlock_irqrestore(&usb3
->lock
, flags
);
1860 usb3_disable_pipe_irq(usb3
, usb3_ep
->num
);
1861 usb3_request_done(usb3_ep
, usb3_req
, status
);
1863 /* get next usb3_req */
1864 usb3_req
= usb3_get_request(usb3_ep
);
1866 usb3_start_pipen(usb3_ep
, usb3_req
);
1869 static void usb3_irq_epc_pipen_lsttr(struct renesas_usb3
*usb3
, int num
)
1871 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, num
);
1872 struct renesas_usb3_request
*usb3_req
= usb3_get_request(usb3_ep
);
1877 if (usb3_ep
->dir_in
) {
1878 dev_dbg(usb3_to_dev(usb3
), "%s: len = %u, actual = %u\n",
1879 __func__
, usb3_req
->req
.length
, usb3_req
->req
.actual
);
1880 usb3_request_done_pipen(usb3
, usb3_ep
, usb3_req
, 0);
1884 static void usb3_irq_epc_pipen_bfrdy(struct renesas_usb3
*usb3
, int num
)
1886 struct renesas_usb3_ep
*usb3_ep
= usb3_get_ep(usb3
, num
);
1887 struct renesas_usb3_request
*usb3_req
= usb3_get_request(usb3_ep
);
1893 spin_lock(&usb3
->lock
);
1894 if (usb3_pn_change(usb3
, num
))
1897 if (usb3_ep
->dir_in
) {
1898 /* Do not stop the IN pipe here to detect LSTTR interrupt */
1899 if (!usb3_write_pipe(usb3_ep
, usb3_req
, USB3_PN_WRITE
))
1900 usb3_clear_bit(usb3
, PN_INT_BFRDY
, USB3_PN_INT_ENA
);
1902 if (!usb3_read_pipe(usb3_ep
, usb3_req
, USB3_PN_READ
))
1907 /* need to unlock because usb3_request_done_pipen() locks it */
1908 spin_unlock(&usb3
->lock
);
1911 usb3_request_done_pipen(usb3
, usb3_ep
, usb3_req
, 0);
1914 static void usb3_irq_epc_pipen(struct renesas_usb3
*usb3
, int num
)
1918 spin_lock(&usb3
->lock
);
1919 if (usb3_pn_change(usb3
, num
) < 0) {
1920 spin_unlock(&usb3
->lock
);
1924 pn_int_sta
= usb3_read(usb3
, USB3_PN_INT_STA
);
1925 pn_int_sta
&= usb3_read(usb3
, USB3_PN_INT_ENA
);
1926 usb3_write(usb3
, pn_int_sta
, USB3_PN_INT_STA
);
1927 spin_unlock(&usb3
->lock
);
1928 if (pn_int_sta
& PN_INT_LSTTR
)
1929 usb3_irq_epc_pipen_lsttr(usb3
, num
);
1930 if (pn_int_sta
& PN_INT_BFRDY
)
1931 usb3_irq_epc_pipen_bfrdy(usb3
, num
);
1934 static void usb3_irq_epc_int_2(struct renesas_usb3
*usb3
, u32 int_sta_2
)
1938 for (i
= 0; i
< usb3
->num_usb3_eps
; i
++) {
1939 if (int_sta_2
& USB_INT_2_PIPE(i
)) {
1941 usb3_irq_epc_pipe0(usb3
);
1943 usb3_irq_epc_pipen(usb3
, i
);
1948 static void usb3_irq_idmon_change(struct renesas_usb3
*usb3
)
1950 usb3_check_id(usb3
);
1953 static void usb3_irq_otg_int(struct renesas_usb3
*usb3
, u32 otg_int_sta
)
1955 if (otg_int_sta
& USB_OTG_IDMON
)
1956 usb3_irq_idmon_change(usb3
);
1959 static void usb3_irq_epc(struct renesas_usb3
*usb3
)
1961 u32 int_sta_1
= usb3_read(usb3
, USB3_USB_INT_STA_1
);
1962 u32 int_sta_2
= usb3_read(usb3
, USB3_USB_INT_STA_2
);
1963 u32 otg_int_sta
= usb3_read(usb3
, USB3_USB_OTG_INT_STA
);
1965 int_sta_1
&= usb3_read(usb3
, USB3_USB_INT_ENA_1
);
1967 usb3_write(usb3
, int_sta_1
, USB3_USB_INT_STA_1
);
1968 usb3_irq_epc_int_1(usb3
, int_sta_1
);
1971 int_sta_2
&= usb3_read(usb3
, USB3_USB_INT_ENA_2
);
1973 usb3_irq_epc_int_2(usb3
, int_sta_2
);
1975 otg_int_sta
&= usb3_read(usb3
, USB3_USB_OTG_INT_ENA
);
1977 usb3_write(usb3
, otg_int_sta
, USB3_USB_OTG_INT_STA
);
1978 usb3_irq_otg_int(usb3
, otg_int_sta
);
1982 static void usb3_irq_dma_int(struct renesas_usb3
*usb3
, u32 dma_sta
)
1984 struct renesas_usb3_ep
*usb3_ep
;
1985 struct renesas_usb3_request
*usb3_req
;
1988 for (i
= 0; i
< usb3
->num_usb3_eps
; i
++) {
1989 if (!(dma_sta
& DMA_INT(i
)))
1992 usb3_ep
= usb3_get_ep(usb3
, i
);
1993 if (!(usb3_read(usb3
, USB3_AXI_INT_STA
) &
1994 AXI_INT_PRDEN_CLR_STA(usb3_ep
->dma
->num
)))
1997 usb3_req
= usb3_get_request(usb3_ep
);
1998 status
= usb3_dma_try_stop(usb3_ep
, usb3_req
);
1999 usb3_request_done_pipen(usb3
, usb3_ep
, usb3_req
, status
);
2003 static void usb3_irq_dma(struct renesas_usb3
*usb3
)
2005 u32 dma_sta
= usb3_read(usb3
, USB3_DMA_INT_STA
);
2007 dma_sta
&= usb3_read(usb3
, USB3_DMA_INT_ENA
);
2009 usb3_write(usb3
, dma_sta
, USB3_DMA_INT_STA
);
2010 usb3_irq_dma_int(usb3
, dma_sta
);
2014 static irqreturn_t
renesas_usb3_irq(int irq
, void *_usb3
)
2016 struct renesas_usb3
*usb3
= _usb3
;
2017 irqreturn_t ret
= IRQ_NONE
;
2018 u32 axi_int_sta
= usb3_read(usb3
, USB3_AXI_INT_STA
);
2020 if (axi_int_sta
& AXI_INT_DMAINT
) {
2025 if (axi_int_sta
& AXI_INT_EPCINT
) {
2033 static void usb3_write_pn_mod(struct renesas_usb3_ep
*usb3_ep
,
2034 const struct usb_endpoint_descriptor
*desc
)
2036 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
2039 val
|= usb3_ep
->dir_in
? PN_MOD_DIR
: 0;
2040 val
|= PN_MOD_TYPE(usb_endpoint_type(desc
));
2041 val
|= PN_MOD_EPNUM(usb_endpoint_num(desc
));
2042 usb3_write(usb3
, val
, USB3_PN_MOD
);
2045 static u32
usb3_calc_ramarea(int ram_size
)
2047 WARN_ON(ram_size
> SZ_16K
);
2049 if (ram_size
<= SZ_1K
)
2050 return PN_RAMMAP_RAMAREA_1KB
;
2051 else if (ram_size
<= SZ_2K
)
2052 return PN_RAMMAP_RAMAREA_2KB
;
2053 else if (ram_size
<= SZ_4K
)
2054 return PN_RAMMAP_RAMAREA_4KB
;
2055 else if (ram_size
<= SZ_8K
)
2056 return PN_RAMMAP_RAMAREA_8KB
;
2058 return PN_RAMMAP_RAMAREA_16KB
;
2061 static u32
usb3_calc_rammap_val(struct renesas_usb3_ep
*usb3_ep
,
2062 const struct usb_endpoint_descriptor
*desc
)
2065 static const u32 max_packet_array
[] = {8, 16, 32, 64, 512};
2066 u32 mpkt
= PN_RAMMAP_MPKT(1024);
2068 for (i
= 0; i
< ARRAY_SIZE(max_packet_array
); i
++) {
2069 if (usb_endpoint_maxp(desc
) <= max_packet_array
[i
])
2070 mpkt
= PN_RAMMAP_MPKT(max_packet_array
[i
]);
2073 return usb3_ep
->rammap_val
| mpkt
;
2076 static int usb3_enable_pipe_n(struct renesas_usb3_ep
*usb3_ep
,
2077 const struct usb_endpoint_descriptor
*desc
)
2079 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
2080 unsigned long flags
;
2082 usb3_ep
->dir_in
= usb_endpoint_dir_in(desc
);
2084 spin_lock_irqsave(&usb3
->lock
, flags
);
2085 if (!usb3_pn_change(usb3
, usb3_ep
->num
)) {
2086 usb3_write_pn_mod(usb3_ep
, desc
);
2087 usb3_write(usb3
, usb3_calc_rammap_val(usb3_ep
, desc
),
2089 usb3_pn_con_clear(usb3
);
2090 usb3_set_bit(usb3
, PN_CON_EN
, USB3_PN_CON
);
2092 spin_unlock_irqrestore(&usb3
->lock
, flags
);
2097 static int usb3_disable_pipe_n(struct renesas_usb3_ep
*usb3_ep
)
2099 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
2100 unsigned long flags
;
2102 usb3_ep
->halt
= false;
2104 spin_lock_irqsave(&usb3
->lock
, flags
);
2105 if (!usb3_pn_change(usb3
, usb3_ep
->num
)) {
2106 usb3_write(usb3
, 0, USB3_PN_INT_ENA
);
2107 usb3_write(usb3
, 0, USB3_PN_RAMMAP
);
2108 usb3_clear_bit(usb3
, PN_CON_EN
, USB3_PN_CON
);
2110 spin_unlock_irqrestore(&usb3
->lock
, flags
);
2115 /*------- usb_ep_ops -----------------------------------------------------*/
2116 static int renesas_usb3_ep_enable(struct usb_ep
*_ep
,
2117 const struct usb_endpoint_descriptor
*desc
)
2119 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
2121 return usb3_enable_pipe_n(usb3_ep
, desc
);
2124 static int renesas_usb3_ep_disable(struct usb_ep
*_ep
)
2126 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
2127 struct renesas_usb3_request
*usb3_req
;
2130 usb3_req
= usb3_get_request(usb3_ep
);
2133 usb3_dma_try_stop(usb3_ep
, usb3_req
);
2134 usb3_request_done(usb3_ep
, usb3_req
, -ESHUTDOWN
);
2137 return usb3_disable_pipe_n(usb3_ep
);
2140 static struct usb_request
*__renesas_usb3_ep_alloc_request(gfp_t gfp_flags
)
2142 struct renesas_usb3_request
*usb3_req
;
2144 usb3_req
= kzalloc(sizeof(struct renesas_usb3_request
), gfp_flags
);
2148 INIT_LIST_HEAD(&usb3_req
->queue
);
2150 return &usb3_req
->req
;
2153 static void __renesas_usb3_ep_free_request(struct usb_request
*_req
)
2155 struct renesas_usb3_request
*usb3_req
= usb_req_to_usb3_req(_req
);
2160 static struct usb_request
*renesas_usb3_ep_alloc_request(struct usb_ep
*_ep
,
2163 return __renesas_usb3_ep_alloc_request(gfp_flags
);
2166 static void renesas_usb3_ep_free_request(struct usb_ep
*_ep
,
2167 struct usb_request
*_req
)
2169 __renesas_usb3_ep_free_request(_req
);
2172 static int renesas_usb3_ep_dequeue(struct usb_ep
*_ep
, struct usb_request
*_req
)
2174 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
2175 struct renesas_usb3_request
*usb3_req
= usb_req_to_usb3_req(_req
);
2176 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
2178 dev_dbg(usb3_to_dev(usb3
), "ep_dequeue: ep%2d, %u\n", usb3_ep
->num
,
2181 usb3_dma_try_stop(usb3_ep
, usb3_req
);
2182 usb3_request_done_pipen(usb3
, usb3_ep
, usb3_req
, -ECONNRESET
);
2187 static int renesas_usb3_ep_set_halt(struct usb_ep
*_ep
, int value
)
2189 return usb3_set_halt(usb_ep_to_usb3_ep(_ep
), !!value
, false);
2192 static int renesas_usb3_ep_set_wedge(struct usb_ep
*_ep
)
2194 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
2196 usb3_ep
->wedge
= true;
2197 return usb3_set_halt(usb3_ep
, true, false);
2200 static void renesas_usb3_ep_fifo_flush(struct usb_ep
*_ep
)
2202 struct renesas_usb3_ep
*usb3_ep
= usb_ep_to_usb3_ep(_ep
);
2203 struct renesas_usb3
*usb3
= usb3_ep_to_usb3(usb3_ep
);
2204 unsigned long flags
;
2207 spin_lock_irqsave(&usb3
->lock
, flags
);
2208 if (!usb3_pn_change(usb3
, usb3_ep
->num
)) {
2209 usb3_pn_con_clear(usb3
);
2210 usb3_set_bit(usb3
, PN_CON_EN
, USB3_PN_CON
);
2212 spin_unlock_irqrestore(&usb3
->lock
, flags
);
2214 usb3_p0_con_clear_buffer(usb3
);
2218 static const struct usb_ep_ops renesas_usb3_ep_ops
= {
2219 .enable
= renesas_usb3_ep_enable
,
2220 .disable
= renesas_usb3_ep_disable
,
2222 .alloc_request
= renesas_usb3_ep_alloc_request
,
2223 .free_request
= renesas_usb3_ep_free_request
,
2225 .queue
= renesas_usb3_ep_queue
,
2226 .dequeue
= renesas_usb3_ep_dequeue
,
2228 .set_halt
= renesas_usb3_ep_set_halt
,
2229 .set_wedge
= renesas_usb3_ep_set_wedge
,
2230 .fifo_flush
= renesas_usb3_ep_fifo_flush
,
2233 /*------- usb_gadget_ops -------------------------------------------------*/
2234 static int renesas_usb3_start(struct usb_gadget
*gadget
,
2235 struct usb_gadget_driver
*driver
)
2237 struct renesas_usb3
*usb3
;
2239 if (!driver
|| driver
->max_speed
< USB_SPEED_FULL
||
2243 usb3
= gadget_to_renesas_usb3(gadget
);
2245 /* hook up the driver */
2246 usb3
->driver
= driver
;
2249 phy_init(usb3
->phy
);
2251 pm_runtime_get_sync(usb3_to_dev(usb3
));
2253 renesas_usb3_init_controller(usb3
);
2258 static int renesas_usb3_stop(struct usb_gadget
*gadget
)
2260 struct renesas_usb3
*usb3
= gadget_to_renesas_usb3(gadget
);
2262 usb3
->softconnect
= false;
2263 usb3
->gadget
.speed
= USB_SPEED_UNKNOWN
;
2264 usb3
->driver
= NULL
;
2265 renesas_usb3_stop_controller(usb3
);
2268 phy_exit(usb3
->phy
);
2270 pm_runtime_put(usb3_to_dev(usb3
));
2275 static int renesas_usb3_get_frame(struct usb_gadget
*_gadget
)
2280 static int renesas_usb3_pullup(struct usb_gadget
*gadget
, int is_on
)
2282 struct renesas_usb3
*usb3
= gadget_to_renesas_usb3(gadget
);
2284 usb3
->softconnect
= !!is_on
;
2289 static int renesas_usb3_set_selfpowered(struct usb_gadget
*gadget
, int is_self
)
2291 gadget
->is_selfpowered
= !!is_self
;
2296 static const struct usb_gadget_ops renesas_usb3_gadget_ops
= {
2297 .get_frame
= renesas_usb3_get_frame
,
2298 .udc_start
= renesas_usb3_start
,
2299 .udc_stop
= renesas_usb3_stop
,
2300 .pullup
= renesas_usb3_pullup
,
2301 .set_selfpowered
= renesas_usb3_set_selfpowered
,
2304 static ssize_t
role_store(struct device
*dev
, struct device_attribute
*attr
,
2305 const char *buf
, size_t count
)
2307 struct renesas_usb3
*usb3
= dev_get_drvdata(dev
);
2308 bool new_mode_is_host
;
2313 if (usb3
->forced_b_device
)
2316 if (!strncmp(buf
, "host", strlen("host")))
2317 new_mode_is_host
= true;
2318 else if (!strncmp(buf
, "peripheral", strlen("peripheral")))
2319 new_mode_is_host
= false;
2323 if (new_mode_is_host
== usb3_is_host(usb3
))
2326 usb3_mode_config(usb3
, new_mode_is_host
, usb3_is_a_device(usb3
));
2331 static ssize_t
role_show(struct device
*dev
, struct device_attribute
*attr
,
2334 struct renesas_usb3
*usb3
= dev_get_drvdata(dev
);
2339 return sprintf(buf
, "%s\n", usb3_is_host(usb3
) ? "host" : "peripheral");
2341 static DEVICE_ATTR_RW(role
);
2343 static int renesas_usb3_b_device_show(struct seq_file
*s
, void *unused
)
2345 struct renesas_usb3
*usb3
= s
->private;
2347 seq_printf(s
, "%d\n", usb3
->forced_b_device
);
2352 static int renesas_usb3_b_device_open(struct inode
*inode
, struct file
*file
)
2354 return single_open(file
, renesas_usb3_b_device_show
, inode
->i_private
);
2357 static ssize_t
renesas_usb3_b_device_write(struct file
*file
,
2358 const char __user
*ubuf
,
2359 size_t count
, loff_t
*ppos
)
2361 struct seq_file
*s
= file
->private_data
;
2362 struct renesas_usb3
*usb3
= s
->private;
2368 if (copy_from_user(&buf
, ubuf
, min_t(size_t, sizeof(buf
) - 1, count
)))
2371 if (!strncmp(buf
, "1", 1))
2372 usb3
->forced_b_device
= true;
2374 usb3
->forced_b_device
= false;
2376 /* Let this driver call usb3_connect() anyway */
2377 usb3_check_id(usb3
);
2382 static const struct file_operations renesas_usb3_b_device_fops
= {
2383 .open
= renesas_usb3_b_device_open
,
2384 .write
= renesas_usb3_b_device_write
,
2386 .llseek
= seq_lseek
,
2387 .release
= single_release
,
2390 static void renesas_usb3_debugfs_init(struct renesas_usb3
*usb3
,
2393 struct dentry
*root
, *file
;
2395 root
= debugfs_create_dir(dev_name(dev
), NULL
);
2396 if (IS_ERR_OR_NULL(root
)) {
2397 dev_info(dev
, "%s: Can't create the root\n", __func__
);
2401 file
= debugfs_create_file("b_device", 0644, root
, usb3
,
2402 &renesas_usb3_b_device_fops
);
2404 dev_info(dev
, "%s: Can't create debugfs mode\n", __func__
);
2407 /*------- platform_driver ------------------------------------------------*/
2408 static int renesas_usb3_remove(struct platform_device
*pdev
)
2410 struct renesas_usb3
*usb3
= platform_get_drvdata(pdev
);
2412 device_remove_file(&pdev
->dev
, &dev_attr_role
);
2414 usb_del_gadget_udc(&usb3
->gadget
);
2415 renesas_usb3_dma_free_prd(usb3
, &pdev
->dev
);
2417 __renesas_usb3_ep_free_request(usb3
->ep0_req
);
2420 pm_runtime_disable(&pdev
->dev
);
2425 static int renesas_usb3_init_ep(struct renesas_usb3
*usb3
, struct device
*dev
,
2426 const struct renesas_usb3_priv
*priv
)
2428 struct renesas_usb3_ep
*usb3_ep
;
2431 /* calculate num_usb3_eps from renesas_usb3_priv */
2432 usb3
->num_usb3_eps
= priv
->ramsize_per_ramif
* priv
->num_ramif
* 2 /
2433 priv
->ramsize_per_pipe
+ 1;
2435 if (usb3
->num_usb3_eps
> USB3_MAX_NUM_PIPES
)
2436 usb3
->num_usb3_eps
= USB3_MAX_NUM_PIPES
;
2438 usb3
->usb3_ep
= devm_kzalloc(dev
, sizeof(*usb3_ep
) * usb3
->num_usb3_eps
,
2443 dev_dbg(dev
, "%s: num_usb3_eps = %d\n", __func__
, usb3
->num_usb3_eps
);
2445 * This driver prepares pipes as follows:
2446 * - odd pipes = IN pipe
2447 * - even pipes = OUT pipe (except pipe 0)
2449 usb3_for_each_ep(usb3_ep
, usb3
, i
) {
2450 snprintf(usb3_ep
->ep_name
, sizeof(usb3_ep
->ep_name
), "ep%d", i
);
2451 usb3_ep
->usb3
= usb3
;
2453 usb3_ep
->ep
.name
= usb3_ep
->ep_name
;
2454 usb3_ep
->ep
.ops
= &renesas_usb3_ep_ops
;
2455 INIT_LIST_HEAD(&usb3_ep
->queue
);
2456 INIT_LIST_HEAD(&usb3_ep
->ep
.ep_list
);
2458 /* for control pipe */
2459 usb3
->gadget
.ep0
= &usb3_ep
->ep
;
2460 usb_ep_set_maxpacket_limit(&usb3_ep
->ep
,
2461 USB3_EP0_HSFS_MAX_PACKET_SIZE
);
2462 usb3_ep
->ep
.caps
.type_control
= true;
2463 usb3_ep
->ep
.caps
.dir_in
= true;
2464 usb3_ep
->ep
.caps
.dir_out
= true;
2468 /* for bulk or interrupt pipe */
2469 usb_ep_set_maxpacket_limit(&usb3_ep
->ep
, ~0);
2470 list_add_tail(&usb3_ep
->ep
.ep_list
, &usb3
->gadget
.ep_list
);
2471 usb3_ep
->ep
.caps
.type_bulk
= true;
2472 usb3_ep
->ep
.caps
.type_int
= true;
2474 usb3_ep
->ep
.caps
.dir_in
= true;
2476 usb3_ep
->ep
.caps
.dir_out
= true;
2482 static void renesas_usb3_init_ram(struct renesas_usb3
*usb3
, struct device
*dev
,
2483 const struct renesas_usb3_priv
*priv
)
2485 struct renesas_usb3_ep
*usb3_ep
;
2487 u32 ramif
[2], basead
[2]; /* index 0 = for IN pipes */
2488 u32
*cur_ramif
, *cur_basead
;
2491 memset(ramif
, 0, sizeof(ramif
));
2492 memset(basead
, 0, sizeof(basead
));
2495 * This driver prepares pipes as follows:
2496 * - all pipes = the same size as "ramsize_per_pipe"
2497 * Please refer to the "Method of Specifying RAM Mapping"
2499 usb3_for_each_ep(usb3_ep
, usb3
, i
) {
2501 continue; /* out of scope if ep num = 0 */
2502 if (usb3_ep
->ep
.caps
.dir_in
) {
2503 cur_ramif
= &ramif
[0];
2504 cur_basead
= &basead
[0];
2506 cur_ramif
= &ramif
[1];
2507 cur_basead
= &basead
[1];
2510 if (*cur_basead
> priv
->ramsize_per_ramif
)
2511 continue; /* out of memory for IN or OUT pipe */
2513 /* calculate rammap_val */
2514 val
= PN_RAMMAP_RAMIF(*cur_ramif
);
2515 val
|= usb3_calc_ramarea(priv
->ramsize_per_pipe
);
2516 val
|= PN_RAMMAP_BASEAD(*cur_basead
);
2517 usb3_ep
->rammap_val
= val
;
2519 dev_dbg(dev
, "ep%2d: val = %08x, ramif = %d, base = %x\n",
2520 i
, val
, *cur_ramif
, *cur_basead
);
2522 /* update current ramif */
2523 if (*cur_ramif
+ 1 == priv
->num_ramif
) {
2525 *cur_basead
+= priv
->ramsize_per_pipe
;
2532 static const struct renesas_usb3_priv renesas_usb3_priv_r8a7795_es1
= {
2533 .ramsize_per_ramif
= SZ_16K
,
2535 .ramsize_per_pipe
= SZ_4K
,
2536 .workaround_for_vbus
= true,
2539 static const struct renesas_usb3_priv renesas_usb3_priv_gen3
= {
2540 .ramsize_per_ramif
= SZ_16K
,
2542 .ramsize_per_pipe
= SZ_4K
,
2545 static const struct of_device_id usb3_of_match
[] = {
2547 .compatible
= "renesas,r8a7795-usb3-peri",
2548 .data
= &renesas_usb3_priv_gen3
,
2551 .compatible
= "renesas,rcar-gen3-usb3-peri",
2552 .data
= &renesas_usb3_priv_gen3
,
2556 MODULE_DEVICE_TABLE(of
, usb3_of_match
);
2558 static const struct soc_device_attribute renesas_usb3_quirks_match
[] = {
2560 .soc_id
= "r8a7795", .revision
= "ES1.*",
2561 .data
= &renesas_usb3_priv_r8a7795_es1
,
2566 static const unsigned int renesas_usb3_cable
[] = {
2572 static int renesas_usb3_probe(struct platform_device
*pdev
)
2574 struct renesas_usb3
*usb3
;
2575 struct resource
*res
;
2577 const struct renesas_usb3_priv
*priv
;
2578 const struct soc_device_attribute
*attr
;
2580 attr
= soc_device_match(renesas_usb3_quirks_match
);
2584 priv
= of_device_get_match_data(&pdev
->dev
);
2586 irq
= platform_get_irq(pdev
, 0);
2588 dev_err(&pdev
->dev
, "Failed to get IRQ: %d\n", irq
);
2592 usb3
= devm_kzalloc(&pdev
->dev
, sizeof(*usb3
), GFP_KERNEL
);
2596 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
2597 usb3
->reg
= devm_ioremap_resource(&pdev
->dev
, res
);
2598 if (IS_ERR(usb3
->reg
))
2599 return PTR_ERR(usb3
->reg
);
2601 platform_set_drvdata(pdev
, usb3
);
2602 spin_lock_init(&usb3
->lock
);
2604 usb3
->gadget
.ops
= &renesas_usb3_gadget_ops
;
2605 usb3
->gadget
.name
= udc_name
;
2606 usb3
->gadget
.max_speed
= USB_SPEED_SUPER
;
2607 INIT_LIST_HEAD(&usb3
->gadget
.ep_list
);
2608 ret
= renesas_usb3_init_ep(usb3
, &pdev
->dev
, priv
);
2611 renesas_usb3_init_ram(usb3
, &pdev
->dev
, priv
);
2613 ret
= devm_request_irq(&pdev
->dev
, irq
, renesas_usb3_irq
, 0,
2614 dev_name(&pdev
->dev
), usb3
);
2618 INIT_WORK(&usb3
->extcon_work
, renesas_usb3_extcon_work
);
2619 usb3
->extcon
= devm_extcon_dev_allocate(&pdev
->dev
, renesas_usb3_cable
);
2620 if (IS_ERR(usb3
->extcon
))
2621 return PTR_ERR(usb3
->extcon
);
2623 ret
= devm_extcon_dev_register(&pdev
->dev
, usb3
->extcon
);
2625 dev_err(&pdev
->dev
, "Failed to register extcon\n");
2629 /* for ep0 handling */
2630 usb3
->ep0_req
= __renesas_usb3_ep_alloc_request(GFP_KERNEL
);
2634 ret
= renesas_usb3_dma_alloc_prd(usb3
, &pdev
->dev
);
2638 ret
= usb_add_gadget_udc(&pdev
->dev
, &usb3
->gadget
);
2642 ret
= device_create_file(&pdev
->dev
, &dev_attr_role
);
2644 goto err_dev_create
;
2647 * This is an optional. So, if this driver cannot get a phy,
2648 * this driver will not handle a phy anymore.
2650 usb3
->phy
= devm_phy_get(&pdev
->dev
, "usb");
2651 if (IS_ERR(usb3
->phy
))
2654 usb3
->workaround_for_vbus
= priv
->workaround_for_vbus
;
2656 renesas_usb3_debugfs_init(usb3
, &pdev
->dev
);
2658 dev_info(&pdev
->dev
, "probed%s\n", usb3
->phy
? " with phy" : "");
2659 pm_runtime_enable(usb3_to_dev(usb3
));
2664 usb_del_gadget_udc(&usb3
->gadget
);
2667 renesas_usb3_dma_free_prd(usb3
, &pdev
->dev
);
2670 __renesas_usb3_ep_free_request(usb3
->ep0_req
);
2675 #ifdef CONFIG_PM_SLEEP
2676 static int renesas_usb3_suspend(struct device
*dev
)
2678 struct renesas_usb3
*usb3
= dev_get_drvdata(dev
);
2684 renesas_usb3_stop_controller(usb3
);
2686 phy_exit(usb3
->phy
);
2687 pm_runtime_put(dev
);
2692 static int renesas_usb3_resume(struct device
*dev
)
2694 struct renesas_usb3
*usb3
= dev_get_drvdata(dev
);
2701 phy_init(usb3
->phy
);
2702 pm_runtime_get_sync(dev
);
2703 renesas_usb3_init_controller(usb3
);
2709 static SIMPLE_DEV_PM_OPS(renesas_usb3_pm_ops
, renesas_usb3_suspend
,
2710 renesas_usb3_resume
);
2712 static struct platform_driver renesas_usb3_driver
= {
2713 .probe
= renesas_usb3_probe
,
2714 .remove
= renesas_usb3_remove
,
2716 .name
= (char *)udc_name
,
2717 .pm
= &renesas_usb3_pm_ops
,
2718 .of_match_table
= of_match_ptr(usb3_of_match
),
2721 module_platform_driver(renesas_usb3_driver
);
2723 MODULE_DESCRIPTION("Renesas USB3.0 Peripheral driver");
2724 MODULE_LICENSE("GPL v2");
2725 MODULE_AUTHOR("Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>");
2726 MODULE_ALIAS("platform:renesas_usb3");