1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * mtu3_gadget.c - MediaTek usb3 DRD peripheral support
4 *
5 * Copyright (C) 2016 MediaTek Inc.
6 *
7 * Author: Chunfeng Yun <chunfeng.yun@mediatek.com>
8 */
9
10 #include <linux/string_choices.h>
11 #include "mtu3.h"
12 #include "mtu3_trace.h"
13
mtu3_req_complete(struct mtu3_ep * mep,struct usb_request * req,int status)14 void mtu3_req_complete(struct mtu3_ep *mep,
15 struct usb_request *req, int status)
16 __releases(mep->mtu->lock)
17 __acquires(mep->mtu->lock)
18 {
19 struct mtu3_request *mreq = to_mtu3_request(req);
20 struct mtu3 *mtu = mreq->mtu;
21
22 list_del(&mreq->list);
23 if (req->status == -EINPROGRESS)
24 req->status = status;
25
26 trace_mtu3_req_complete(mreq);
27
28 /* ep0 makes use of PIO, needn't unmap it */
29 if (mep->epnum)
30 usb_gadget_unmap_request(&mtu->g, req, mep->is_in);
31
32 dev_dbg(mtu->dev, "%s complete req: %p, sts %d, %d/%d\n",
33 mep->name, req, req->status, req->actual, req->length);
34
35 spin_unlock(&mtu->lock);
36 usb_gadget_giveback_request(&mep->ep, req);
37 spin_lock(&mtu->lock);
38 }
39
nuke(struct mtu3_ep * mep,const int status)40 static void nuke(struct mtu3_ep *mep, const int status)
41 {
42 struct mtu3_request *mreq = NULL;
43
44 if (list_empty(&mep->req_list))
45 return;
46
47 dev_dbg(mep->mtu->dev, "abort %s's req: sts %d\n", mep->name, status);
48
49 /* exclude EP0 */
50 if (mep->epnum)
51 mtu3_qmu_flush(mep);
52
53 while (!list_empty(&mep->req_list)) {
54 mreq = list_first_entry(&mep->req_list,
55 struct mtu3_request, list);
56 mtu3_req_complete(mep, &mreq->request, status);
57 }
58 }
59
mtu3_ep_enable(struct mtu3_ep * mep)60 static int mtu3_ep_enable(struct mtu3_ep *mep)
61 {
62 const struct usb_endpoint_descriptor *desc;
63 const struct usb_ss_ep_comp_descriptor *comp_desc;
64 struct mtu3 *mtu = mep->mtu;
65 u32 interval = 0;
66 u32 mult = 0;
67 u32 burst = 0;
68 int ret;
69
70 desc = mep->desc;
71 comp_desc = mep->comp_desc;
72 mep->type = usb_endpoint_type(desc);
73 mep->maxp = usb_endpoint_maxp(desc);
74
75 switch (mtu->g.speed) {
76 case USB_SPEED_SUPER:
77 case USB_SPEED_SUPER_PLUS:
78 if (usb_endpoint_xfer_int(desc) ||
79 usb_endpoint_xfer_isoc(desc)) {
80 interval = desc->bInterval;
81 interval = clamp_val(interval, 1, 16);
82 if (usb_endpoint_xfer_isoc(desc) && comp_desc)
83 mult = comp_desc->bmAttributes;
84 }
85 if (comp_desc)
86 burst = comp_desc->bMaxBurst;
87
88 break;
89 case USB_SPEED_HIGH:
90 if (usb_endpoint_xfer_isoc(desc) ||
91 usb_endpoint_xfer_int(desc)) {
92 interval = desc->bInterval;
93 interval = clamp_val(interval, 1, 16);
94 mult = usb_endpoint_maxp_mult(desc) - 1;
95 }
96 break;
97 case USB_SPEED_FULL:
98 if (usb_endpoint_xfer_isoc(desc))
99 interval = clamp_val(desc->bInterval, 1, 16);
100 else if (usb_endpoint_xfer_int(desc))
101 interval = clamp_val(desc->bInterval, 1, 255);
102
103 break;
104 default:
105 break; /*others are ignored */
106 }
107
108 dev_dbg(mtu->dev, "%s maxp:%d, interval:%d, burst:%d, mult:%d\n",
109 __func__, mep->maxp, interval, burst, mult);
110
111 mep->ep.maxpacket = mep->maxp;
112 mep->ep.desc = desc;
113 mep->ep.comp_desc = comp_desc;
114
115 /* slot mainly affects bulk/isoc transfer, so ignore int */
116 mep->slot = usb_endpoint_xfer_int(desc) ? 0 : mtu->slot;
117
118 ret = mtu3_config_ep(mtu, mep, interval, burst, mult);
119 if (ret < 0)
120 return ret;
121
122 ret = mtu3_gpd_ring_alloc(mep);
123 if (ret < 0) {
124 mtu3_deconfig_ep(mtu, mep);
125 return ret;
126 }
127
128 mtu3_qmu_start(mep);
129
130 return 0;
131 }
132
mtu3_ep_disable(struct mtu3_ep * mep)133 static int mtu3_ep_disable(struct mtu3_ep *mep)
134 {
135 struct mtu3 *mtu = mep->mtu;
136
137 /* abort all pending requests */
138 nuke(mep, -ESHUTDOWN);
139 mtu3_qmu_stop(mep);
140 mtu3_deconfig_ep(mtu, mep);
141 mtu3_gpd_ring_free(mep);
142
143 mep->desc = NULL;
144 mep->ep.desc = NULL;
145 mep->comp_desc = NULL;
146 mep->type = 0;
147 mep->flags = 0;
148
149 return 0;
150 }
151
mtu3_gadget_ep_enable(struct usb_ep * ep,const struct usb_endpoint_descriptor * desc)152 static int mtu3_gadget_ep_enable(struct usb_ep *ep,
153 const struct usb_endpoint_descriptor *desc)
154 {
155 struct mtu3_ep *mep;
156 struct mtu3 *mtu;
157 unsigned long flags;
158 int ret = -EINVAL;
159
160 if (!ep || !desc || desc->bDescriptorType != USB_DT_ENDPOINT) {
161 pr_debug("%s invalid parameters\n", __func__);
162 return -EINVAL;
163 }
164
165 if (!desc->wMaxPacketSize) {
166 pr_debug("%s missing wMaxPacketSize\n", __func__);
167 return -EINVAL;
168 }
169 mep = to_mtu3_ep(ep);
170 mtu = mep->mtu;
171
172 /* check ep number and direction against endpoint */
173 if (usb_endpoint_num(desc) != mep->epnum)
174 return -EINVAL;
175
176 if (!!usb_endpoint_dir_in(desc) ^ !!mep->is_in)
177 return -EINVAL;
178
179 dev_dbg(mtu->dev, "%s %s\n", __func__, ep->name);
180
181 if (mep->flags & MTU3_EP_ENABLED) {
182 dev_WARN_ONCE(mtu->dev, true, "%s is already enabled\n",
183 mep->name);
184 return 0;
185 }
186
187 spin_lock_irqsave(&mtu->lock, flags);
188 mep->desc = desc;
189 mep->comp_desc = ep->comp_desc;
190
191 ret = mtu3_ep_enable(mep);
192 if (ret)
193 goto error;
194
195 mep->flags = MTU3_EP_ENABLED;
196 mtu->active_ep++;
197
198 error:
199 spin_unlock_irqrestore(&mtu->lock, flags);
200
201 dev_dbg(mtu->dev, "%s active_ep=%d\n", __func__, mtu->active_ep);
202 trace_mtu3_gadget_ep_enable(mep);
203
204 return ret;
205 }
206
mtu3_gadget_ep_disable(struct usb_ep * ep)207 static int mtu3_gadget_ep_disable(struct usb_ep *ep)
208 {
209 struct mtu3_ep *mep = to_mtu3_ep(ep);
210 struct mtu3 *mtu = mep->mtu;
211 unsigned long flags;
212
213 dev_dbg(mtu->dev, "%s %s\n", __func__, mep->name);
214 trace_mtu3_gadget_ep_disable(mep);
215
216 if (!(mep->flags & MTU3_EP_ENABLED)) {
217 dev_warn(mtu->dev, "%s is already disabled\n", mep->name);
218 return 0;
219 }
220
221 spin_lock_irqsave(&mtu->lock, flags);
222 mtu3_ep_disable(mep);
223 mep->flags = 0;
224 mtu->active_ep--;
225 spin_unlock_irqrestore(&(mtu->lock), flags);
226
227 dev_dbg(mtu->dev, "%s active_ep=%d, mtu3 is_active=%d\n",
228 __func__, mtu->active_ep, mtu->is_active);
229
230 return 0;
231 }
232
mtu3_alloc_request(struct usb_ep * ep,gfp_t gfp_flags)233 struct usb_request *mtu3_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
234 {
235 struct mtu3_ep *mep = to_mtu3_ep(ep);
236 struct mtu3_request *mreq;
237
238 mreq = kzalloc_obj(*mreq, gfp_flags);
239 if (!mreq)
240 return NULL;
241
242 mreq->request.dma = DMA_ADDR_INVALID;
243 mreq->epnum = mep->epnum;
244 mreq->mep = mep;
245 INIT_LIST_HEAD(&mreq->list);
246 trace_mtu3_alloc_request(mreq);
247
248 return &mreq->request;
249 }
250
mtu3_free_request(struct usb_ep * ep,struct usb_request * req)251 void mtu3_free_request(struct usb_ep *ep, struct usb_request *req)
252 {
253 struct mtu3_request *mreq = to_mtu3_request(req);
254
255 trace_mtu3_free_request(mreq);
256 kfree(mreq);
257 }
258
mtu3_gadget_queue(struct usb_ep * ep,struct usb_request * req,gfp_t gfp_flags)259 static int mtu3_gadget_queue(struct usb_ep *ep,
260 struct usb_request *req, gfp_t gfp_flags)
261 {
262 struct mtu3_ep *mep = to_mtu3_ep(ep);
263 struct mtu3_request *mreq = to_mtu3_request(req);
264 struct mtu3 *mtu = mep->mtu;
265 unsigned long flags;
266 int ret = 0;
267
268 if (!req->buf)
269 return -ENODATA;
270
271 if (mreq->mep != mep)
272 return -EINVAL;
273
274 dev_dbg(mtu->dev, "%s %s EP%d(%s), req=%p, maxp=%d, len#%d\n",
275 __func__, mep->is_in ? "TX" : "RX", mreq->epnum, ep->name,
276 mreq, ep->maxpacket, mreq->request.length);
277
278 if (req->length > GPD_BUF_SIZE ||
279 (mtu->gen2cp && req->length > GPD_BUF_SIZE_EL)) {
280 dev_warn(mtu->dev,
281 "req length > supported MAX:%d requested:%d\n",
282 mtu->gen2cp ? GPD_BUF_SIZE_EL : GPD_BUF_SIZE,
283 req->length);
284 return -EOPNOTSUPP;
285 }
286
287 /* don't queue if the ep is down */
288 if (!mep->desc) {
289 dev_dbg(mtu->dev, "req=%p queued to %s while it's disabled\n",
290 req, ep->name);
291 return -ESHUTDOWN;
292 }
293
294 mreq->mtu = mtu;
295 mreq->request.actual = 0;
296 mreq->request.status = -EINPROGRESS;
297
298 ret = usb_gadget_map_request(&mtu->g, req, mep->is_in);
299 if (ret) {
300 dev_err(mtu->dev, "dma mapping failed\n");
301 return ret;
302 }
303
304 spin_lock_irqsave(&mtu->lock, flags);
305
306 if (mtu3_prepare_transfer(mep)) {
307 ret = -EAGAIN;
308 usb_gadget_unmap_request(&mtu->g, req, mep->is_in);
309 goto error;
310 }
311
312 list_add_tail(&mreq->list, &mep->req_list);
313 mtu3_insert_gpd(mep, mreq);
314 mtu3_qmu_resume(mep);
315
316 error:
317 spin_unlock_irqrestore(&mtu->lock, flags);
318 trace_mtu3_gadget_queue(mreq);
319
320 return ret;
321 }
322
mtu3_gadget_dequeue(struct usb_ep * ep,struct usb_request * req)323 static int mtu3_gadget_dequeue(struct usb_ep *ep, struct usb_request *req)
324 {
325 struct mtu3_ep *mep = to_mtu3_ep(ep);
326 struct mtu3_request *mreq = to_mtu3_request(req);
327 struct mtu3_request *r;
328 struct mtu3 *mtu = mep->mtu;
329 unsigned long flags;
330 int ret = 0;
331
332 if (mreq->mep != mep)
333 return -EINVAL;
334
335 dev_dbg(mtu->dev, "%s : req=%p\n", __func__, req);
336 trace_mtu3_gadget_dequeue(mreq);
337
338 spin_lock_irqsave(&mtu->lock, flags);
339
340 list_for_each_entry(r, &mep->req_list, list) {
341 if (r == mreq)
342 break;
343 }
344 if (r != mreq) {
345 dev_dbg(mtu->dev, "req=%p not queued to %s\n", req, ep->name);
346 ret = -EINVAL;
347 goto done;
348 }
349
350 mtu3_qmu_flush(mep); /* REVISIT: set BPS ?? */
351 mtu3_req_complete(mep, req, -ECONNRESET);
352 mtu3_qmu_start(mep);
353
354 done:
355 spin_unlock_irqrestore(&mtu->lock, flags);
356
357 return ret;
358 }
359
360 /*
361 * Set or clear the halt bit of an EP.
362 * A halted EP won't TX/RX any data but will queue requests.
363 */
mtu3_gadget_ep_set_halt(struct usb_ep * ep,int value)364 static int mtu3_gadget_ep_set_halt(struct usb_ep *ep, int value)
365 {
366 struct mtu3_ep *mep = to_mtu3_ep(ep);
367 struct mtu3 *mtu = mep->mtu;
368 struct mtu3_request *mreq;
369 unsigned long flags;
370 int ret = 0;
371
372 dev_dbg(mtu->dev, "%s : %s...", __func__, ep->name);
373
374 spin_lock_irqsave(&mtu->lock, flags);
375
376 if (mep->type == USB_ENDPOINT_XFER_ISOC) {
377 ret = -EINVAL;
378 goto done;
379 }
380
381 mreq = next_request(mep);
382 if (value) {
383 /*
384 * If there is not request for TX-EP, QMU will not transfer
385 * data to TX-FIFO, so no need check whether TX-FIFO
386 * holds bytes or not here
387 */
388 if (mreq) {
389 dev_dbg(mtu->dev, "req in progress, cannot halt %s\n",
390 ep->name);
391 ret = -EAGAIN;
392 goto done;
393 }
394 } else {
395 mep->flags &= ~MTU3_EP_WEDGE;
396 }
397
398 dev_dbg(mtu->dev, "%s %s stall\n", ep->name, value ? "set" : "clear");
399
400 mtu3_ep_stall_set(mep, value);
401
402 done:
403 spin_unlock_irqrestore(&mtu->lock, flags);
404 trace_mtu3_gadget_ep_set_halt(mep);
405
406 return ret;
407 }
408
409 /* Sets the halt feature with the clear requests ignored */
mtu3_gadget_ep_set_wedge(struct usb_ep * ep)410 static int mtu3_gadget_ep_set_wedge(struct usb_ep *ep)
411 {
412 struct mtu3_ep *mep = to_mtu3_ep(ep);
413
414 mep->flags |= MTU3_EP_WEDGE;
415
416 return usb_ep_set_halt(ep);
417 }
418
419 static const struct usb_ep_ops mtu3_ep_ops = {
420 .enable = mtu3_gadget_ep_enable,
421 .disable = mtu3_gadget_ep_disable,
422 .alloc_request = mtu3_alloc_request,
423 .free_request = mtu3_free_request,
424 .queue = mtu3_gadget_queue,
425 .dequeue = mtu3_gadget_dequeue,
426 .set_halt = mtu3_gadget_ep_set_halt,
427 .set_wedge = mtu3_gadget_ep_set_wedge,
428 };
429
mtu3_gadget_get_frame(struct usb_gadget * gadget)430 static int mtu3_gadget_get_frame(struct usb_gadget *gadget)
431 {
432 struct mtu3 *mtu = gadget_to_mtu3(gadget);
433
434 return (int)mtu3_readl(mtu->mac_base, U3D_USB20_FRAME_NUM);
435 }
436
function_wake_notif(struct mtu3 * mtu,u8 intf)437 static void function_wake_notif(struct mtu3 *mtu, u8 intf)
438 {
439 mtu3_writel(mtu->mac_base, U3D_DEV_NOTIF_0,
440 TYPE_FUNCTION_WAKE | DEV_NOTIF_VAL_FW(intf));
441 mtu3_setbits(mtu->mac_base, U3D_DEV_NOTIF_0, SEND_DEV_NOTIF);
442 }
443
mtu3_gadget_wakeup(struct usb_gadget * gadget)444 static int mtu3_gadget_wakeup(struct usb_gadget *gadget)
445 {
446 struct mtu3 *mtu = gadget_to_mtu3(gadget);
447 unsigned long flags;
448
449 dev_dbg(mtu->dev, "%s\n", __func__);
450
451 /* remote wakeup feature is not enabled by host */
452 if (!mtu->may_wakeup)
453 return -EOPNOTSUPP;
454
455 spin_lock_irqsave(&mtu->lock, flags);
456 if (mtu->g.speed >= USB_SPEED_SUPER) {
457 /*
458 * class driver may do function wakeup even UFP is in U0,
459 * and UX_EXIT only takes effect in U1/U2/U3;
460 */
461 mtu3_setbits(mtu->mac_base, U3D_LINK_POWER_CONTROL, UX_EXIT);
462 /*
463 * Assume there's only one function on the composite device
464 * and enable remote wake for the first interface.
465 * FIXME if the IAD (interface association descriptor) shows
466 * there is more than one function.
467 */
468 function_wake_notif(mtu, 0);
469 } else {
470 mtu3_setbits(mtu->mac_base, U3D_POWER_MANAGEMENT, RESUME);
471 spin_unlock_irqrestore(&mtu->lock, flags);
472 usleep_range(10000, 11000);
473 spin_lock_irqsave(&mtu->lock, flags);
474 mtu3_clrbits(mtu->mac_base, U3D_POWER_MANAGEMENT, RESUME);
475 }
476 spin_unlock_irqrestore(&mtu->lock, flags);
477 return 0;
478 }
479
mtu3_gadget_set_self_powered(struct usb_gadget * gadget,int is_selfpowered)480 static int mtu3_gadget_set_self_powered(struct usb_gadget *gadget,
481 int is_selfpowered)
482 {
483 struct mtu3 *mtu = gadget_to_mtu3(gadget);
484
485 mtu->is_self_powered = !!is_selfpowered;
486 return 0;
487 }
488
mtu3_gadget_pullup(struct usb_gadget * gadget,int is_on)489 static int mtu3_gadget_pullup(struct usb_gadget *gadget, int is_on)
490 {
491 struct mtu3 *mtu = gadget_to_mtu3(gadget);
492 unsigned long flags;
493
494 dev_dbg(mtu->dev, "%s (%s) for %sactive device\n", __func__,
495 str_on_off(is_on), mtu->is_active ? "" : "in");
496
497 pm_runtime_get_sync(mtu->dev);
498
499 /* we'd rather not pullup unless the device is active. */
500 spin_lock_irqsave(&mtu->lock, flags);
501
502 is_on = !!is_on;
503 if (!mtu->is_active) {
504 /* save it for mtu3_start() to process the request */
505 mtu->softconnect = is_on;
506 } else if (is_on != mtu->softconnect) {
507 mtu->softconnect = is_on;
508 mtu3_dev_on_off(mtu, is_on);
509 }
510
511 spin_unlock_irqrestore(&mtu->lock, flags);
512 pm_runtime_put(mtu->dev);
513
514 return 0;
515 }
516
mtu3_gadget_start(struct usb_gadget * gadget,struct usb_gadget_driver * driver)517 static int mtu3_gadget_start(struct usb_gadget *gadget,
518 struct usb_gadget_driver *driver)
519 {
520 struct mtu3 *mtu = gadget_to_mtu3(gadget);
521 unsigned long flags;
522
523 if (mtu->gadget_driver) {
524 dev_err(mtu->dev, "%s is already bound to %s\n",
525 mtu->g.name, mtu->gadget_driver->driver.name);
526 return -EBUSY;
527 }
528
529 dev_dbg(mtu->dev, "bind driver %s\n", driver->function);
530 pm_runtime_get_sync(mtu->dev);
531
532 spin_lock_irqsave(&mtu->lock, flags);
533
534 mtu->softconnect = 0;
535 mtu->gadget_driver = driver;
536
537 if (mtu->ssusb->dr_mode == USB_DR_MODE_PERIPHERAL)
538 mtu3_start(mtu);
539
540 spin_unlock_irqrestore(&mtu->lock, flags);
541 pm_runtime_put(mtu->dev);
542
543 return 0;
544 }
545
stop_activity(struct mtu3 * mtu)546 static void stop_activity(struct mtu3 *mtu)
547 {
548 struct usb_gadget_driver *driver = mtu->gadget_driver;
549 int i;
550
551 /* don't disconnect if it's not connected */
552 if (mtu->g.speed == USB_SPEED_UNKNOWN)
553 driver = NULL;
554 else
555 mtu->g.speed = USB_SPEED_UNKNOWN;
556
557 /* deactivate the hardware */
558 if (mtu->softconnect) {
559 mtu->softconnect = 0;
560 mtu3_dev_on_off(mtu, 0);
561 }
562
563 /*
564 * killing any outstanding requests will quiesce the driver;
565 * then report disconnect
566 */
567 nuke(mtu->ep0, -ESHUTDOWN);
568 for (i = 1; i < mtu->num_eps; i++) {
569 nuke(mtu->in_eps + i, -ESHUTDOWN);
570 nuke(mtu->out_eps + i, -ESHUTDOWN);
571 }
572
573 if (driver) {
574 spin_unlock(&mtu->lock);
575 driver->disconnect(&mtu->g);
576 spin_lock(&mtu->lock);
577 }
578 }
579
mtu3_gadget_stop(struct usb_gadget * g)580 static int mtu3_gadget_stop(struct usb_gadget *g)
581 {
582 struct mtu3 *mtu = gadget_to_mtu3(g);
583 unsigned long flags;
584
585 dev_dbg(mtu->dev, "%s\n", __func__);
586
587 spin_lock_irqsave(&mtu->lock, flags);
588
589 stop_activity(mtu);
590 mtu->gadget_driver = NULL;
591
592 if (mtu->ssusb->dr_mode == USB_DR_MODE_PERIPHERAL)
593 mtu3_stop(mtu);
594
595 spin_unlock_irqrestore(&mtu->lock, flags);
596
597 synchronize_irq(mtu->irq);
598 return 0;
599 }
600
601 static void
mtu3_gadget_set_speed(struct usb_gadget * g,enum usb_device_speed speed)602 mtu3_gadget_set_speed(struct usb_gadget *g, enum usb_device_speed speed)
603 {
604 struct mtu3 *mtu = gadget_to_mtu3(g);
605 unsigned long flags;
606
607 dev_dbg(mtu->dev, "%s %s\n", __func__, usb_speed_string(speed));
608
609 spin_lock_irqsave(&mtu->lock, flags);
610 mtu->speed = speed;
611 spin_unlock_irqrestore(&mtu->lock, flags);
612 }
613
mtu3_gadget_async_callbacks(struct usb_gadget * g,bool enable)614 static void mtu3_gadget_async_callbacks(struct usb_gadget *g, bool enable)
615 {
616 struct mtu3 *mtu = gadget_to_mtu3(g);
617 unsigned long flags;
618
619 dev_dbg(mtu->dev, "%s %s\n", __func__, enable ? "en" : "dis");
620
621 spin_lock_irqsave(&mtu->lock, flags);
622 mtu->async_callbacks = enable;
623 spin_unlock_irqrestore(&mtu->lock, flags);
624 }
625
626 static const struct usb_gadget_ops mtu3_gadget_ops = {
627 .get_frame = mtu3_gadget_get_frame,
628 .wakeup = mtu3_gadget_wakeup,
629 .set_selfpowered = mtu3_gadget_set_self_powered,
630 .pullup = mtu3_gadget_pullup,
631 .udc_start = mtu3_gadget_start,
632 .udc_stop = mtu3_gadget_stop,
633 .udc_set_speed = mtu3_gadget_set_speed,
634 .udc_async_callbacks = mtu3_gadget_async_callbacks,
635 };
636
mtu3_state_reset(struct mtu3 * mtu)637 static void mtu3_state_reset(struct mtu3 *mtu)
638 {
639 mtu->address = 0;
640 mtu->ep0_state = MU3D_EP0_STATE_SETUP;
641 mtu->may_wakeup = 0;
642 mtu->u1_enable = 0;
643 mtu->u2_enable = 0;
644 mtu->delayed_status = false;
645 mtu->test_mode = false;
646 }
647
init_hw_ep(struct mtu3 * mtu,struct mtu3_ep * mep,u32 epnum,u32 is_in)648 static void init_hw_ep(struct mtu3 *mtu, struct mtu3_ep *mep,
649 u32 epnum, u32 is_in)
650 {
651 mep->epnum = epnum;
652 mep->mtu = mtu;
653 mep->is_in = is_in;
654
655 INIT_LIST_HEAD(&mep->req_list);
656
657 sprintf(mep->name, "ep%d%s", epnum,
658 !epnum ? "" : (is_in ? "in" : "out"));
659
660 mep->ep.name = mep->name;
661 INIT_LIST_HEAD(&mep->ep.ep_list);
662
663 /* initialize maxpacket as SS */
664 if (!epnum) {
665 usb_ep_set_maxpacket_limit(&mep->ep, 512);
666 mep->ep.caps.type_control = true;
667 mep->ep.ops = &mtu3_ep0_ops;
668 mtu->g.ep0 = &mep->ep;
669 } else {
670 usb_ep_set_maxpacket_limit(&mep->ep, 1024);
671 mep->ep.caps.type_iso = true;
672 mep->ep.caps.type_bulk = true;
673 mep->ep.caps.type_int = true;
674 mep->ep.ops = &mtu3_ep_ops;
675 list_add_tail(&mep->ep.ep_list, &mtu->g.ep_list);
676 }
677
678 dev_dbg(mtu->dev, "%s, name=%s, maxp=%d\n", __func__, mep->ep.name,
679 mep->ep.maxpacket);
680
681 if (!epnum) {
682 mep->ep.caps.dir_in = true;
683 mep->ep.caps.dir_out = true;
684 } else if (is_in) {
685 mep->ep.caps.dir_in = true;
686 } else {
687 mep->ep.caps.dir_out = true;
688 }
689 }
690
mtu3_gadget_init_eps(struct mtu3 * mtu)691 static void mtu3_gadget_init_eps(struct mtu3 *mtu)
692 {
693 u8 epnum;
694
695 /* initialize endpoint list just once */
696 INIT_LIST_HEAD(&(mtu->g.ep_list));
697
698 dev_dbg(mtu->dev, "%s num_eps(1 for a pair of tx&rx ep)=%d\n",
699 __func__, mtu->num_eps);
700
701 init_hw_ep(mtu, mtu->ep0, 0, 0);
702 for (epnum = 1; epnum < mtu->num_eps; epnum++) {
703 init_hw_ep(mtu, mtu->in_eps + epnum, epnum, 1);
704 init_hw_ep(mtu, mtu->out_eps + epnum, epnum, 0);
705 }
706 }
707
mtu3_gadget_setup(struct mtu3 * mtu)708 int mtu3_gadget_setup(struct mtu3 *mtu)
709 {
710 mtu->g.ops = &mtu3_gadget_ops;
711 mtu->g.max_speed = mtu->max_speed;
712 mtu->g.speed = USB_SPEED_UNKNOWN;
713 mtu->g.sg_supported = 0;
714 mtu->g.name = MTU3_DRIVER_NAME;
715 mtu->g.irq = mtu->irq;
716 mtu->is_active = 0;
717 mtu->delayed_status = false;
718
719 mtu3_gadget_init_eps(mtu);
720
721 return usb_add_gadget_udc(mtu->dev, &mtu->g);
722 }
723
mtu3_gadget_cleanup(struct mtu3 * mtu)724 void mtu3_gadget_cleanup(struct mtu3 *mtu)
725 {
726 usb_del_gadget_udc(&mtu->g);
727 }
728
mtu3_gadget_resume(struct mtu3 * mtu)729 void mtu3_gadget_resume(struct mtu3 *mtu)
730 {
731 dev_dbg(mtu->dev, "gadget RESUME\n");
732 if (mtu->async_callbacks && mtu->gadget_driver && mtu->gadget_driver->resume) {
733 spin_unlock(&mtu->lock);
734 mtu->gadget_driver->resume(&mtu->g);
735 spin_lock(&mtu->lock);
736 }
737 }
738
739 /* called when SOF packets stop for 3+ msec or enters U3 */
mtu3_gadget_suspend(struct mtu3 * mtu)740 void mtu3_gadget_suspend(struct mtu3 *mtu)
741 {
742 dev_dbg(mtu->dev, "gadget SUSPEND\n");
743 if (mtu->async_callbacks && mtu->gadget_driver && mtu->gadget_driver->suspend) {
744 spin_unlock(&mtu->lock);
745 mtu->gadget_driver->suspend(&mtu->g);
746 spin_lock(&mtu->lock);
747 }
748 }
749
750 /* called when VBUS drops below session threshold, and in other cases */
mtu3_gadget_disconnect(struct mtu3 * mtu)751 void mtu3_gadget_disconnect(struct mtu3 *mtu)
752 {
753 dev_dbg(mtu->dev, "gadget DISCONNECT\n");
754 if (mtu->async_callbacks && mtu->gadget_driver && mtu->gadget_driver->disconnect) {
755 spin_unlock(&mtu->lock);
756 mtu->gadget_driver->disconnect(&mtu->g);
757 spin_lock(&mtu->lock);
758 }
759
760 mtu3_state_reset(mtu);
761 usb_gadget_set_state(&mtu->g, USB_STATE_NOTATTACHED);
762 }
763
mtu3_gadget_reset(struct mtu3 * mtu)764 void mtu3_gadget_reset(struct mtu3 *mtu)
765 {
766 dev_dbg(mtu->dev, "gadget RESET\n");
767
768 /* report disconnect, if we didn't flush EP state */
769 if (mtu->g.speed != USB_SPEED_UNKNOWN)
770 mtu3_gadget_disconnect(mtu);
771 else
772 mtu3_state_reset(mtu);
773 }
774