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