enable docker ppp

hc

2023-12-09 95099d4622f8cb224d94e314c7a8e0df60b13f87

 kernel/drivers/usb/mtu3/mtu3_gadget.c
..
..
@@ -8,43 +8,38 @@
8
8
  */
9
9
 
10
10
 #include "mtu3.h"
11
+#include "mtu3_trace.h"
11
12
 
12
13
 void mtu3_req_complete(struct mtu3_ep *mep,
13
14
 		     struct usb_request *req, int status)
14
15
 __releases(mep->mtu->lock)
15
16
 __acquires(mep->mtu->lock)
16
17
 {
17
-	struct mtu3_request *mreq;
18
-	struct mtu3 *mtu;
19
-	int busy = mep->busy;
18
+	struct mtu3_request *mreq = to_mtu3_request(req);
19
+	struct mtu3 *mtu = mreq->mtu;
20
20
 
21
-	mreq = to_mtu3_request(req);
22
21
 	list_del(&mreq->list);
23
-	if (mreq->request.status == -EINPROGRESS)
24
-		mreq->request.status = status;
22
+	if (req->status == -EINPROGRESS)
23
+		req->status = status;
25
24
 
26
-	mtu = mreq->mtu;
27
-	mep->busy = 1;
25
+	trace_mtu3_req_complete(mreq);
28
26
 	spin_unlock(&mtu->lock);
29
27
 
30
28
 	/* ep0 makes use of PIO, needn't unmap it */
31
29
 	if (mep->epnum)
32
30
 		usb_gadget_unmap_request(&mtu->g, req, mep->is_in);
33
31
 
34
-	dev_dbg(mtu->dev, "%s complete req: %p, sts %d, %d/%d\n", mep->name,
35
-		req, req->status, mreq->request.actual, mreq->request.length);
32
+	dev_dbg(mtu->dev, "%s complete req: %p, sts %d, %d/%d\n",
33
+		mep->name, req, req->status, req->actual, req->length);
36
34
 
37
-	usb_gadget_giveback_request(&mep->ep, &mreq->request);
38
-
35
+	usb_gadget_giveback_request(&mep->ep, req);
39
36
 	spin_lock(&mtu->lock);
40
-	mep->busy = busy;
41
37
 }
42
38
 
43
39
 static void nuke(struct mtu3_ep *mep, const int status)
44
40
 {
45
41
 	struct mtu3_request *mreq = NULL;
46
42
 
47
-	mep->busy = 1;
48
43
 	if (list_empty(&mep->req_list))
49
44
 		return;
50
45
 
..
..
@@ -197,15 +192,14 @@
197
192
 	if (ret)
198
193
 		goto error;
199
194
 
200
-	mep->busy = 0;
201
-	mep->wedged = 0;
202
-	mep->flags |= MTU3_EP_ENABLED;
195
+	mep->flags = MTU3_EP_ENABLED;
203
196
 	mtu->active_ep++;
204
197
 
205
198
 error:
206
199
 	spin_unlock_irqrestore(&mtu->lock, flags);
207
200
 
208
201
 	dev_dbg(mtu->dev, "%s active_ep=%d\n", __func__, mtu->active_ep);
202
+	trace_mtu3_gadget_ep_enable(mep);
209
203
 
210
204
 	return ret;
211
205
 }
..
..
@@ -217,6 +211,7 @@
217
211
 	unsigned long flags;
218
212
 
219
213
 	dev_dbg(mtu->dev, "%s %s\n", __func__, mep->name);
214
+	trace_mtu3_gadget_ep_disable(mep);
220
215
 
221
216
 	if (!(mep->flags & MTU3_EP_ENABLED)) {
222
217
 		dev_warn(mtu->dev, "%s is already disabled\n", mep->name);
..
..
@@ -225,7 +220,7 @@
225
220
 
226
221
 	spin_lock_irqsave(&mtu->lock, flags);
227
222
 	mtu3_ep_disable(mep);
228
-	mep->flags &= ~MTU3_EP_ENABLED;
223
+	mep->flags = 0;
229
224
 	mtu->active_ep--;
230
225
 	spin_unlock_irqrestore(&(mtu->lock), flags);
231
226
 
..
..
@@ -247,34 +242,31 @@
247
242
 	mreq->request.dma = DMA_ADDR_INVALID;
248
243
 	mreq->epnum = mep->epnum;
249
244
 	mreq->mep = mep;
245
+	INIT_LIST_HEAD(&mreq->list);
246
+	trace_mtu3_alloc_request(mreq);
250
247
 
251
248
 	return &mreq->request;
252
249
 }
253
250
 
254
251
 void mtu3_free_request(struct usb_ep *ep, struct usb_request *req)
255
252
 {
256
-	kfree(to_mtu3_request(req));
253
+	struct mtu3_request *mreq = to_mtu3_request(req);
254
+
255
+	trace_mtu3_free_request(mreq);
256
+	kfree(mreq);
257
257
 }
258
258
 
259
259
 static int mtu3_gadget_queue(struct usb_ep *ep,
260
260
 		struct usb_request *req, gfp_t gfp_flags)
261
261
 {
262
-	struct mtu3_ep *mep;
263
-	struct mtu3_request *mreq;
264
-	struct mtu3 *mtu;
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
265
 	unsigned long flags;
266
266
 	int ret = 0;
267
267
 
268
-	if (!ep || !req)
269
-		return -EINVAL;
270
-
271
268
 	if (!req->buf)
272
269
 		return -ENODATA;
273
-
274
-	mep = to_mtu3_ep(ep);
275
-	mtu = mep->mtu;
276
-	mreq = to_mtu3_request(req);
277
-	mreq->mtu = mtu;
278
270
 
279
271
 	if (mreq->mep != mep)
280
272
 		return -EINVAL;
..
..
@@ -283,10 +275,12 @@
283
275
 		__func__, mep->is_in ? "TX" : "RX", mreq->epnum, ep->name,
284
276
 		mreq, ep->maxpacket, mreq->request.length);
285
277
 
286
-	if (req->length > GPD_BUF_SIZE) {
278
+	if (req->length > GPD_BUF_SIZE ||
279
+	    (mtu->gen2cp && req->length > GPD_BUF_SIZE_EL)) {
287
280
 		dev_warn(mtu->dev,
288
281
 			"req length > supported MAX:%d requested:%d\n",
289
-			GPD_BUF_SIZE, req->length);
282
+			mtu->gen2cp ? GPD_BUF_SIZE_EL : GPD_BUF_SIZE,
283
+			req->length);
290
284
 		return -EOPNOTSUPP;
291
285
 	}
292
286
 
..
..
@@ -297,6 +291,7 @@
297
291
 		return -ESHUTDOWN;
298
292
 	}
299
293
 
294
+	mreq->mtu = mtu;
300
295
 	mreq->request.actual = 0;
301
296
 	mreq->request.status = -EINPROGRESS;
302
297
 
..
..
@@ -319,6 +314,7 @@
319
314
 
320
315
 error:
321
316
 	spin_unlock_irqrestore(&mtu->lock, flags);
317
+	trace_mtu3_gadget_queue(mreq);
322
318
 
323
319
 	return ret;
324
320
 }
..
..
@@ -328,14 +324,15 @@
328
324
 	struct mtu3_ep *mep = to_mtu3_ep(ep);
329
325
 	struct mtu3_request *mreq = to_mtu3_request(req);
330
326
 	struct mtu3_request *r;
327
+	struct mtu3 *mtu = mep->mtu;
331
328
 	unsigned long flags;
332
329
 	int ret = 0;
333
-	struct mtu3 *mtu = mep->mtu;
334
330
 
335
-	if (!ep || !req || mreq->mep != mep)
331
+	if (mreq->mep != mep)
336
332
 		return -EINVAL;
337
333
 
338
334
 	dev_dbg(mtu->dev, "%s : req=%p\n", __func__, req);
335
+	trace_mtu3_gadget_dequeue(mreq);
339
336
 
340
337
 	spin_lock_irqsave(&mtu->lock, flags);
341
338
 
..
..
@@ -371,9 +368,6 @@
371
368
 	unsigned long flags;
372
369
 	int ret = 0;
373
370
 
374
-	if (!ep)
375
-		return -EINVAL;
376
-
377
371
 	dev_dbg(mtu->dev, "%s : %s...", __func__, ep->name);
378
372
 
379
373
 	spin_lock_irqsave(&mtu->lock, flags);
..
..
@@ -397,7 +391,7 @@
397
391
 			goto done;
398
392
 		}
399
393
 	} else {
400
-		mep->wedged = 0;
394
+		mep->flags &= ~MTU3_EP_WEDGE;
401
395
 	}
402
396
 
403
397
 	dev_dbg(mtu->dev, "%s %s stall\n", ep->name, value ? "set" : "clear");
..
..
@@ -406,6 +400,7 @@
406
400
 
407
401
 done:
408
402
 	spin_unlock_irqrestore(&mtu->lock, flags);
403
+	trace_mtu3_gadget_ep_set_halt(mep);
409
404
 
410
405
 	return ret;
411
406
 }
..
..
@@ -415,10 +410,7 @@
415
410
 {
416
411
 	struct mtu3_ep *mep = to_mtu3_ep(ep);
417
412
 
418
-	if (!ep)
419
-		return -EINVAL;
420
-
421
-	mep->wedged = 1;
413
+	mep->flags |= MTU3_EP_WEDGE;
422
414
 
423
415
 	return usb_ep_set_halt(ep);
424
416
 }
..
..
@@ -582,6 +574,19 @@
582
574
 	return 0;
583
575
 }
584
576
 
577
+static void
578
+mtu3_gadget_set_speed(struct usb_gadget *g, enum usb_device_speed speed)
579
+{
580
+	struct mtu3 *mtu = gadget_to_mtu3(g);
581
+	unsigned long flags;
582
+
583
+	dev_dbg(mtu->dev, "%s %s\n", __func__, usb_speed_string(speed));
584
+
585
+	spin_lock_irqsave(&mtu->lock, flags);
586
+	mtu3_set_speed(mtu, speed);
587
+	spin_unlock_irqrestore(&mtu->lock, flags);
588
+}
589
+
585
590
 static const struct usb_gadget_ops mtu3_gadget_ops = {
586
591
 	.get_frame = mtu3_gadget_get_frame,
587
592
 	.wakeup = mtu3_gadget_wakeup,
..
..
@@ -589,6 +594,7 @@
589
594
 	.pullup = mtu3_gadget_pullup,
590
595
 	.udc_start = mtu3_gadget_start,
591
596
 	.udc_stop = mtu3_gadget_stop,
597
+	.udc_set_speed = mtu3_gadget_set_speed,
592
598
 };
593
599
 
594
600
 static void mtu3_state_reset(struct mtu3 *mtu)
..
..
@@ -664,8 +670,6 @@
664
670
 
665
671
 int mtu3_gadget_setup(struct mtu3 *mtu)
666
672
 {
667
-	int ret;
668
-
669
673
 	mtu->g.ops = &mtu3_gadget_ops;
670
674
 	mtu->g.max_speed = mtu->max_speed;
671
675
 	mtu->g.speed = USB_SPEED_UNKNOWN;
..
..
@@ -676,11 +680,7 @@
676
680
 
677
681
 	mtu3_gadget_init_eps(mtu);
678
682
 
679
-	ret = usb_add_gadget_udc(mtu->dev, &mtu->g);
680
-	if (ret)
681
-		dev_err(mtu->dev, "failed to register udc\n");
682
-
683
-	return ret;
683
+	return usb_add_gadget_udc(mtu->dev, &mtu->g);
684
684
 }
685
685
 
686
686
 void mtu3_gadget_cleanup(struct mtu3 *mtu)