1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Cadence USBHS-DEV driver.
4  *
5  * Copyright (C) 2023 Cadence Design Systems.
6  *
7  * Authors: Pawel Laszczak <pawell@cadence.com>
8  */
9 
10 #include <linux/usb/composite.h>
11 #include <asm/unaligned.h>
12 
13 #include "cdns2-gadget.h"
14 #include "cdns2-trace.h"
15 
16 static struct usb_endpoint_descriptor cdns2_gadget_ep0_desc = {
17 	.bLength = USB_DT_ENDPOINT_SIZE,
18 	.bDescriptorType = USB_DT_ENDPOINT,
19 	.bmAttributes =	 USB_ENDPOINT_XFER_CONTROL,
20 	.wMaxPacketSize = cpu_to_le16(64)
21 };
22 
23 static int cdns2_w_index_to_ep_index(u16 wIndex)
24 {
25 	if (!(wIndex & USB_ENDPOINT_NUMBER_MASK))
26 		return 0;
27 
28 	return ((wIndex & USB_ENDPOINT_NUMBER_MASK) * 2) +
29 		(wIndex & USB_ENDPOINT_DIR_MASK ? 1 : 0) - 1;
30 }
31 
32 static bool cdns2_check_new_setup(struct cdns2_device *pdev)
33 {
34 	u8 reg;
35 
36 	reg = readb(&pdev->ep0_regs->cs);
37 
38 	return !!(reg & EP0CS_CHGSET);
39 }
40 
41 static void cdns2_ep0_enqueue(struct cdns2_device *pdev, dma_addr_t dma_addr,
42 			      unsigned int length, int zlp)
43 {
44 	struct cdns2_adma_regs __iomem *regs = pdev->adma_regs;
45 	struct cdns2_endpoint *pep = &pdev->eps[0];
46 	struct cdns2_ring *ring = &pep->ring;
47 
48 	ring->trbs[0].buffer = cpu_to_le32(TRB_BUFFER(dma_addr));
49 	ring->trbs[0].length = cpu_to_le32(TRB_LEN(length));
50 
51 	if (zlp) {
52 		ring->trbs[0].control = cpu_to_le32(TRB_CYCLE |
53 						    TRB_TYPE(TRB_NORMAL));
54 		ring->trbs[1].buffer = cpu_to_le32(TRB_BUFFER(dma_addr));
55 		ring->trbs[1].length = cpu_to_le32(TRB_LEN(0));
56 		ring->trbs[1].control = cpu_to_le32(TRB_CYCLE | TRB_IOC |
57 					TRB_TYPE(TRB_NORMAL));
58 	} else {
59 		ring->trbs[0].control = cpu_to_le32(TRB_CYCLE | TRB_IOC |
60 					TRB_TYPE(TRB_NORMAL));
61 		ring->trbs[1].control = 0;
62 	}
63 
64 	trace_cdns2_queue_trb(pep, ring->trbs);
65 
66 	if (!pep->dir)
67 		writel(0, &pdev->ep0_regs->rxbc);
68 
69 	cdns2_select_ep(pdev, pep->dir);
70 
71 	writel(DMA_EP_STS_TRBERR, &regs->ep_sts);
72 	writel(pep->ring.dma, &regs->ep_traddr);
73 
74 	trace_cdns2_doorbell_ep0(pep, readl(&regs->ep_traddr));
75 
76 	writel(DMA_EP_CMD_DRDY, &regs->ep_cmd);
77 }
78 
79 static int cdns2_ep0_delegate_req(struct cdns2_device *pdev)
80 {
81 	int ret;
82 
83 	spin_unlock(&pdev->lock);
84 	ret = pdev->gadget_driver->setup(&pdev->gadget, &pdev->setup);
85 	spin_lock(&pdev->lock);
86 
87 	return ret;
88 }
89 
90 static void cdns2_ep0_stall(struct cdns2_device *pdev)
91 {
92 	struct cdns2_endpoint *pep = &pdev->eps[0];
93 	struct cdns2_request *preq;
94 
95 	preq = cdns2_next_preq(&pep->pending_list);
96 	set_reg_bit_8(&pdev->ep0_regs->cs, EP0CS_DSTALL);
97 
98 	if (pdev->ep0_stage == CDNS2_DATA_STAGE && preq)
99 		cdns2_gadget_giveback(pep, preq, -ECONNRESET);
100 	else if (preq)
101 		list_del_init(&preq->list);
102 
103 	pdev->ep0_stage = CDNS2_SETUP_STAGE;
104 	pep->ep_state |= EP_STALLED;
105 }
106 
107 static void cdns2_status_stage(struct cdns2_device *pdev)
108 {
109 	struct cdns2_endpoint *pep = &pdev->eps[0];
110 	struct cdns2_request *preq;
111 
112 	preq = cdns2_next_preq(&pep->pending_list);
113 	if (preq)
114 		list_del_init(&preq->list);
115 
116 	pdev->ep0_stage = CDNS2_SETUP_STAGE;
117 	writeb(EP0CS_HSNAK, &pdev->ep0_regs->cs);
118 }
119 
120 static int cdns2_req_ep0_set_configuration(struct cdns2_device *pdev,
121 					   struct usb_ctrlrequest *ctrl_req)
122 {
123 	enum usb_device_state state = pdev->gadget.state;
124 	u32 config = le16_to_cpu(ctrl_req->wValue);
125 	int ret;
126 
127 	if (state < USB_STATE_ADDRESS) {
128 		dev_err(pdev->dev, "Set Configuration - bad device state\n");
129 		return -EINVAL;
130 	}
131 
132 	ret = cdns2_ep0_delegate_req(pdev);
133 	if (ret)
134 		return ret;
135 
136 	trace_cdns2_device_state(config ? "configured" : "addressed");
137 
138 	if (!config)
139 		usb_gadget_set_state(&pdev->gadget, USB_STATE_ADDRESS);
140 
141 	return 0;
142 }
143 
144 static int cdns2_req_ep0_set_address(struct cdns2_device *pdev, u32 addr)
145 {
146 	enum usb_device_state device_state = pdev->gadget.state;
147 	u8 reg;
148 
149 	if (addr > USB_DEVICE_MAX_ADDRESS) {
150 		dev_err(pdev->dev,
151 			"Device address (%d) cannot be greater than %d\n",
152 			addr, USB_DEVICE_MAX_ADDRESS);
153 		return -EINVAL;
154 	}
155 
156 	if (device_state == USB_STATE_CONFIGURED) {
157 		dev_err(pdev->dev,
158 			"can't set_address from configured state\n");
159 		return -EINVAL;
160 	}
161 
162 	reg = readb(&pdev->usb_regs->fnaddr);
163 	pdev->dev_address = reg;
164 
165 	usb_gadget_set_state(&pdev->gadget,
166 			     (addr ? USB_STATE_ADDRESS : USB_STATE_DEFAULT));
167 
168 	trace_cdns2_device_state(addr ? "addressed" : "default");
169 
170 	return 0;
171 }
172 
173 static int cdns2_req_ep0_handle_status(struct cdns2_device *pdev,
174 				       struct usb_ctrlrequest *ctrl)
175 {
176 	struct cdns2_endpoint *pep;
177 	__le16 *response_pkt;
178 	u16 status = 0;
179 	int ep_sts;
180 	u32 recip;
181 
182 	recip = ctrl->bRequestType & USB_RECIP_MASK;
183 
184 	switch (recip) {
185 	case USB_RECIP_DEVICE:
186 		status = pdev->gadget.is_selfpowered;
187 		status |= pdev->may_wakeup << USB_DEVICE_REMOTE_WAKEUP;
188 		break;
189 	case USB_RECIP_INTERFACE:
190 		return cdns2_ep0_delegate_req(pdev);
191 	case USB_RECIP_ENDPOINT:
192 		ep_sts = cdns2_w_index_to_ep_index(le16_to_cpu(ctrl->wIndex));
193 		pep = &pdev->eps[ep_sts];
194 
195 		if (pep->ep_state & EP_STALLED)
196 			status =  BIT(USB_ENDPOINT_HALT);
197 		break;
198 	default:
199 		return -EINVAL;
200 	}
201 
202 	put_unaligned_le16(status, (__le16 *)pdev->ep0_preq.request.buf);
203 
204 	cdns2_ep0_enqueue(pdev, pdev->ep0_preq.request.dma,
205 			  sizeof(*response_pkt), 0);
206 
207 	return 0;
208 }
209 
210 static int cdns2_ep0_handle_feature_device(struct cdns2_device *pdev,
211 					   struct usb_ctrlrequest *ctrl,
212 					   int set)
213 {
214 	enum usb_device_state state;
215 	enum usb_device_speed speed;
216 	int ret = 0;
217 	u32 wValue;
218 	u16 tmode;
219 
220 	wValue = le16_to_cpu(ctrl->wValue);
221 	state = pdev->gadget.state;
222 	speed = pdev->gadget.speed;
223 
224 	switch (wValue) {
225 	case USB_DEVICE_REMOTE_WAKEUP:
226 		pdev->may_wakeup = !!set;
227 		break;
228 	case USB_DEVICE_TEST_MODE:
229 		if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH)
230 			return -EINVAL;
231 
232 		tmode = le16_to_cpu(ctrl->wIndex);
233 
234 		if (!set || (tmode & 0xff) != 0)
235 			return -EINVAL;
236 
237 		tmode >>= 8;
238 		switch (tmode) {
239 		case USB_TEST_J:
240 		case USB_TEST_K:
241 		case USB_TEST_SE0_NAK:
242 		case USB_TEST_PACKET:
243 			/*
244 			 * The USBHS controller automatically handles the
245 			 * Set_Feature(testmode) request. Standard test modes
246 			 * that use values of test mode selector from
247 			 * 01h to 04h (Test_J, Test_K, Test_SE0_NAK,
248 			 * Test_Packet) are supported by the
249 			 * controller(HS - ack, FS - stall).
250 			 */
251 			break;
252 		default:
253 			ret = -EINVAL;
254 		}
255 		break;
256 	default:
257 		ret = -EINVAL;
258 	}
259 
260 	return ret;
261 }
262 
263 static int cdns2_ep0_handle_feature_intf(struct cdns2_device *pdev,
264 					 struct usb_ctrlrequest *ctrl,
265 					 int set)
266 {
267 	int ret = 0;
268 	u32 wValue;
269 
270 	wValue = le16_to_cpu(ctrl->wValue);
271 
272 	switch (wValue) {
273 	case USB_INTRF_FUNC_SUSPEND:
274 		break;
275 	default:
276 		ret = -EINVAL;
277 	}
278 
279 	return ret;
280 }
281 
282 static int cdns2_ep0_handle_feature_endpoint(struct cdns2_device *pdev,
283 					     struct usb_ctrlrequest *ctrl,
284 					     int set)
285 {
286 	struct cdns2_endpoint *pep;
287 	u8 wValue;
288 
289 	wValue = le16_to_cpu(ctrl->wValue);
290 	pep = &pdev->eps[cdns2_w_index_to_ep_index(le16_to_cpu(ctrl->wIndex))];
291 
292 	if (wValue != USB_ENDPOINT_HALT)
293 		return -EINVAL;
294 
295 	if (!(le16_to_cpu(ctrl->wIndex) & ~USB_DIR_IN))
296 		return 0;
297 
298 	switch (wValue) {
299 	case USB_ENDPOINT_HALT:
300 		if (set || !(pep->ep_state & EP_WEDGE))
301 			return cdns2_halt_endpoint(pdev, pep, set);
302 		break;
303 	default:
304 		dev_warn(pdev->dev, "WARN Incorrect wValue %04x\n", wValue);
305 		return -EINVAL;
306 	}
307 
308 	return 0;
309 }
310 
311 static int cdns2_req_ep0_handle_feature(struct cdns2_device *pdev,
312 					struct usb_ctrlrequest *ctrl,
313 					int set)
314 {
315 	switch (ctrl->bRequestType & USB_RECIP_MASK) {
316 	case USB_RECIP_DEVICE:
317 		return cdns2_ep0_handle_feature_device(pdev, ctrl, set);
318 	case USB_RECIP_INTERFACE:
319 		return cdns2_ep0_handle_feature_intf(pdev, ctrl, set);
320 	case USB_RECIP_ENDPOINT:
321 		return cdns2_ep0_handle_feature_endpoint(pdev, ctrl, set);
322 	default:
323 		return -EINVAL;
324 	}
325 }
326 
327 static int cdns2_ep0_std_request(struct cdns2_device *pdev)
328 {
329 	struct usb_ctrlrequest *ctrl = &pdev->setup;
330 	int ret;
331 
332 	switch (ctrl->bRequest) {
333 	case USB_REQ_SET_ADDRESS:
334 		ret = cdns2_req_ep0_set_address(pdev,
335 						le16_to_cpu(ctrl->wValue));
336 		break;
337 	case USB_REQ_SET_CONFIGURATION:
338 		ret = cdns2_req_ep0_set_configuration(pdev, ctrl);
339 		break;
340 	case USB_REQ_GET_STATUS:
341 		ret = cdns2_req_ep0_handle_status(pdev, ctrl);
342 		break;
343 	case USB_REQ_CLEAR_FEATURE:
344 		ret = cdns2_req_ep0_handle_feature(pdev, ctrl, 0);
345 		break;
346 	case USB_REQ_SET_FEATURE:
347 		ret = cdns2_req_ep0_handle_feature(pdev, ctrl, 1);
348 		break;
349 	default:
350 		ret = cdns2_ep0_delegate_req(pdev);
351 		break;
352 	}
353 
354 	return ret;
355 }
356 
357 static void __pending_setup_status_handler(struct cdns2_device *pdev)
358 {
359 	struct usb_request *request = pdev->pending_status_request;
360 
361 	if (pdev->status_completion_no_call && request && request->complete) {
362 		request->complete(&pdev->eps[0].endpoint, request);
363 		pdev->status_completion_no_call = 0;
364 	}
365 }
366 
367 void cdns2_pending_setup_status_handler(struct work_struct *work)
368 {
369 	struct cdns2_device *pdev = container_of(work, struct cdns2_device,
370 						 pending_status_wq);
371 	unsigned long flags;
372 
373 	spin_lock_irqsave(&pdev->lock, flags);
374 	__pending_setup_status_handler(pdev);
375 	spin_unlock_irqrestore(&pdev->lock, flags);
376 }
377 
378 void cdns2_handle_setup_packet(struct cdns2_device *pdev)
379 {
380 	struct usb_ctrlrequest *ctrl = &pdev->setup;
381 	struct cdns2_endpoint *pep = &pdev->eps[0];
382 	struct cdns2_request *preq;
383 	int ret = 0;
384 	u16 len;
385 	u8 reg;
386 	int i;
387 
388 	writeb(EP0CS_CHGSET, &pdev->ep0_regs->cs);
389 
390 	for (i = 0; i < 8; i++)
391 		((u8 *)&pdev->setup)[i] = readb(&pdev->ep0_regs->setupdat[i]);
392 
393 	/*
394 	 * If SETUP packet was modified while reading just simple ignore it.
395 	 * The new one will be handled latter.
396 	 */
397 	if (cdns2_check_new_setup(pdev)) {
398 		trace_cdns2_ep0_setup("overridden");
399 		return;
400 	}
401 
402 	trace_cdns2_ctrl_req(ctrl);
403 
404 	if (!pdev->gadget_driver)
405 		goto out;
406 
407 	if (pdev->gadget.state == USB_STATE_NOTATTACHED) {
408 		dev_err(pdev->dev, "ERR: Setup detected in unattached state\n");
409 		ret = -EINVAL;
410 		goto out;
411 	}
412 
413 	pep = &pdev->eps[0];
414 
415 	/* Halt for Ep0 is cleared automatically when SETUP packet arrives. */
416 	pep->ep_state &= ~EP_STALLED;
417 
418 	if (!list_empty(&pep->pending_list)) {
419 		preq = cdns2_next_preq(&pep->pending_list);
420 		cdns2_gadget_giveback(pep, preq, -ECONNRESET);
421 	}
422 
423 	len = le16_to_cpu(ctrl->wLength);
424 	if (len)
425 		pdev->ep0_stage = CDNS2_DATA_STAGE;
426 	else
427 		pdev->ep0_stage = CDNS2_STATUS_STAGE;
428 
429 	pep->dir = ctrl->bRequestType & USB_DIR_IN;
430 
431 	/*
432 	 * SET_ADDRESS request is acknowledged automatically by controller and
433 	 * in the worse case driver may not notice this request. To check
434 	 * whether this request has been processed driver can use
435 	 * fnaddr register.
436 	 */
437 	reg = readb(&pdev->usb_regs->fnaddr);
438 	if (pdev->setup.bRequest != USB_REQ_SET_ADDRESS &&
439 	    pdev->dev_address != reg)
440 		cdns2_req_ep0_set_address(pdev, reg);
441 
442 	if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
443 		ret = cdns2_ep0_std_request(pdev);
444 	else
445 		ret = cdns2_ep0_delegate_req(pdev);
446 
447 	if (ret == USB_GADGET_DELAYED_STATUS) {
448 		trace_cdns2_ep0_status_stage("delayed");
449 		return;
450 	}
451 
452 out:
453 	if (ret < 0)
454 		cdns2_ep0_stall(pdev);
455 	else if (pdev->ep0_stage == CDNS2_STATUS_STAGE)
456 		cdns2_status_stage(pdev);
457 }
458 
459 static void cdns2_transfer_completed(struct cdns2_device *pdev)
460 {
461 	struct cdns2_endpoint *pep = &pdev->eps[0];
462 
463 	if (!list_empty(&pep->pending_list)) {
464 		struct cdns2_request *preq;
465 
466 		trace_cdns2_complete_trb(pep, pep->ring.trbs);
467 		preq = cdns2_next_preq(&pep->pending_list);
468 
469 		preq->request.actual =
470 			TRB_LEN(le32_to_cpu(pep->ring.trbs->length));
471 		cdns2_gadget_giveback(pep, preq, 0);
472 	}
473 
474 	cdns2_status_stage(pdev);
475 }
476 
477 void cdns2_handle_ep0_interrupt(struct cdns2_device *pdev, int dir)
478 {
479 	u32 ep_sts_reg;
480 
481 	cdns2_select_ep(pdev, dir);
482 
483 	trace_cdns2_ep0_irq(pdev);
484 
485 	ep_sts_reg = readl(&pdev->adma_regs->ep_sts);
486 	writel(ep_sts_reg, &pdev->adma_regs->ep_sts);
487 
488 	__pending_setup_status_handler(pdev);
489 
490 	if ((ep_sts_reg & DMA_EP_STS_IOC) || (ep_sts_reg & DMA_EP_STS_ISP)) {
491 		pdev->eps[0].dir = dir;
492 		cdns2_transfer_completed(pdev);
493 	}
494 }
495 
496 /*
497  * Function shouldn't be called by gadget driver,
498  * endpoint 0 is allways active.
499  */
500 static int cdns2_gadget_ep0_enable(struct usb_ep *ep,
501 				   const struct usb_endpoint_descriptor *desc)
502 {
503 	return -EINVAL;
504 }
505 
506 /*
507  * Function shouldn't be called by gadget driver,
508  * endpoint 0 is allways active.
509  */
510 static int cdns2_gadget_ep0_disable(struct usb_ep *ep)
511 {
512 	return -EINVAL;
513 }
514 
515 static int cdns2_gadget_ep0_set_halt(struct usb_ep *ep, int value)
516 {
517 	struct cdns2_endpoint *pep = ep_to_cdns2_ep(ep);
518 	struct cdns2_device *pdev = pep->pdev;
519 	unsigned long flags;
520 
521 	if (!value)
522 		return 0;
523 
524 	spin_lock_irqsave(&pdev->lock, flags);
525 	cdns2_ep0_stall(pdev);
526 	spin_unlock_irqrestore(&pdev->lock, flags);
527 
528 	return 0;
529 }
530 
531 static int cdns2_gadget_ep0_set_wedge(struct usb_ep *ep)
532 {
533 	return cdns2_gadget_ep0_set_halt(ep, 1);
534 }
535 
536 static int cdns2_gadget_ep0_queue(struct usb_ep *ep,
537 				  struct usb_request *request,
538 				  gfp_t gfp_flags)
539 {
540 	struct cdns2_endpoint *pep = ep_to_cdns2_ep(ep);
541 	struct cdns2_device *pdev = pep->pdev;
542 	struct cdns2_request *preq;
543 	unsigned long flags;
544 	u8 zlp = 0;
545 	int ret;
546 
547 	spin_lock_irqsave(&pdev->lock, flags);
548 
549 	preq = to_cdns2_request(request);
550 
551 	trace_cdns2_request_enqueue(preq);
552 
553 	/* Cancel the request if controller receive new SETUP packet. */
554 	if (cdns2_check_new_setup(pdev)) {
555 		trace_cdns2_ep0_setup("overridden");
556 		spin_unlock_irqrestore(&pdev->lock, flags);
557 		return -ECONNRESET;
558 	}
559 
560 	/* Send STATUS stage. Should be called only for SET_CONFIGURATION. */
561 	if (pdev->ep0_stage == CDNS2_STATUS_STAGE) {
562 		cdns2_status_stage(pdev);
563 
564 		request->actual = 0;
565 		pdev->status_completion_no_call = true;
566 		pdev->pending_status_request = request;
567 		usb_gadget_set_state(&pdev->gadget, USB_STATE_CONFIGURED);
568 		spin_unlock_irqrestore(&pdev->lock, flags);
569 
570 		/*
571 		 * Since there is no completion interrupt for status stage,
572 		 * it needs to call ->completion in software after
573 		 * cdns2_gadget_ep0_queue is back.
574 		 */
575 		queue_work(system_freezable_wq, &pdev->pending_status_wq);
576 		return 0;
577 	}
578 
579 	if (!list_empty(&pep->pending_list)) {
580 		trace_cdns2_ep0_setup("pending");
581 		dev_err(pdev->dev,
582 			"can't handle multiple requests for ep0\n");
583 		spin_unlock_irqrestore(&pdev->lock, flags);
584 		return -EBUSY;
585 	}
586 
587 	ret = usb_gadget_map_request_by_dev(pdev->dev, request, pep->dir);
588 	if (ret) {
589 		spin_unlock_irqrestore(&pdev->lock, flags);
590 		dev_err(pdev->dev, "failed to map request\n");
591 		return -EINVAL;
592 	}
593 
594 	request->status = -EINPROGRESS;
595 	list_add_tail(&preq->list, &pep->pending_list);
596 
597 	if (request->zero && request->length &&
598 	    (request->length % ep->maxpacket == 0))
599 		zlp = 1;
600 
601 	cdns2_ep0_enqueue(pdev, request->dma, request->length, zlp);
602 
603 	spin_unlock_irqrestore(&pdev->lock, flags);
604 
605 	return 0;
606 }
607 
608 static const struct usb_ep_ops cdns2_gadget_ep0_ops = {
609 	.enable = cdns2_gadget_ep0_enable,
610 	.disable = cdns2_gadget_ep0_disable,
611 	.alloc_request = cdns2_gadget_ep_alloc_request,
612 	.free_request = cdns2_gadget_ep_free_request,
613 	.queue = cdns2_gadget_ep0_queue,
614 	.dequeue = cdns2_gadget_ep_dequeue,
615 	.set_halt = cdns2_gadget_ep0_set_halt,
616 	.set_wedge = cdns2_gadget_ep0_set_wedge,
617 };
618 
619 void cdns2_ep0_config(struct cdns2_device *pdev)
620 {
621 	struct cdns2_endpoint *pep;
622 
623 	pep = &pdev->eps[0];
624 
625 	if (!list_empty(&pep->pending_list)) {
626 		struct cdns2_request *preq;
627 
628 		preq = cdns2_next_preq(&pep->pending_list);
629 		list_del_init(&preq->list);
630 	}
631 
632 	writeb(EP0_FIFO_AUTO, &pdev->ep0_regs->fifo);
633 	cdns2_select_ep(pdev, USB_DIR_OUT);
634 	writel(DMA_EP_CFG_ENABLE, &pdev->adma_regs->ep_cfg);
635 
636 	writeb(EP0_FIFO_IO_TX | EP0_FIFO_AUTO, &pdev->ep0_regs->fifo);
637 	cdns2_select_ep(pdev, USB_DIR_IN);
638 	writel(DMA_EP_CFG_ENABLE, &pdev->adma_regs->ep_cfg);
639 
640 	writeb(pdev->gadget.ep0->maxpacket, &pdev->ep0_regs->maxpack);
641 	writel(DMA_EP_IEN_EP_OUT0 | DMA_EP_IEN_EP_IN0,
642 	       &pdev->adma_regs->ep_ien);
643 }
644 
645 void cdns2_init_ep0(struct cdns2_device *pdev,
646 		    struct cdns2_endpoint *pep)
647 {
648 	u16 maxpacket = le16_to_cpu(cdns2_gadget_ep0_desc.wMaxPacketSize);
649 
650 	usb_ep_set_maxpacket_limit(&pep->endpoint, maxpacket);
651 
652 	pep->endpoint.ops = &cdns2_gadget_ep0_ops;
653 	pep->endpoint.desc = &cdns2_gadget_ep0_desc;
654 	pep->endpoint.caps.type_control = true;
655 	pep->endpoint.caps.dir_in = true;
656 	pep->endpoint.caps.dir_out = true;
657 
658 	pdev->gadget.ep0 = &pep->endpoint;
659 }
660