1 // SPDX-License-Identifier: GPL-2.0
3 * Cadence USBSS DRD Driver - gadget side.
5 * Copyright (C) 2018 Cadence Design Systems.
6 * Copyright (C) 2017-2018 NXP
8 * Authors: Pawel Jez <pjez@cadence.com>,
9 * Pawel Laszczak <pawell@cadence.com>
10 * Peter Chen <peter.chen@nxp.com>
14 #include <asm/cache.h>
15 #include <dm/device_compat.h>
16 #include <linux/bitops.h>
17 #include <linux/delay.h>
18 #include <linux/usb/composite.h>
19 #include <linux/iopoll.h>
24 #define readl_poll_timeout_atomic readl_poll_timeout
25 #define usleep_range(a, b) udelay((b))
27 static struct usb_endpoint_descriptor cdns3_gadget_ep0_desc = {
28 .bLength = USB_DT_ENDPOINT_SIZE,
29 .bDescriptorType = USB_DT_ENDPOINT,
30 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
34 * cdns3_ep0_run_transfer - Do transfer on default endpoint hardware
35 * @priv_dev: extended gadget object
36 * @dma_addr: physical address where data is/will be stored
37 * @length: data length
38 * @erdy: set it to 1 when ERDY packet should be sent -
39 * exit from flow control state
41 static void cdns3_ep0_run_transfer(struct cdns3_device *priv_dev,
43 unsigned int length, int erdy, int zlp)
45 struct cdns3_usb_regs __iomem *regs = priv_dev->regs;
46 struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
48 priv_ep->trb_pool[0].buffer = TRB_BUFFER(dma_addr);
49 priv_ep->trb_pool[0].length = TRB_LEN(length);
52 priv_ep->trb_pool[0].control = TRB_CYCLE | TRB_TYPE(TRB_NORMAL);
53 priv_ep->trb_pool[1].buffer = TRB_BUFFER(dma_addr);
54 priv_ep->trb_pool[1].length = TRB_LEN(0);
55 priv_ep->trb_pool[1].control = TRB_CYCLE | TRB_IOC |
58 priv_ep->trb_pool[0].control = TRB_CYCLE | TRB_IOC |
60 priv_ep->trb_pool[1].control = 0;
64 flush_dcache_range((unsigned long)priv_ep->trb_pool,
65 (unsigned long)priv_ep->trb_pool +
66 ROUND(sizeof(struct cdns3_trb) * 2,
67 CONFIG_SYS_CACHELINE_SIZE));
69 trace_cdns3_prepare_trb(priv_ep, priv_ep->trb_pool);
71 cdns3_select_ep(priv_dev, priv_dev->ep0_data_dir);
73 writel(EP_STS_TRBERR, ®s->ep_sts);
74 writel(EP_TRADDR_TRADDR(priv_ep->trb_pool_dma), ®s->ep_traddr);
75 trace_cdns3_doorbell_ep0(priv_dev->ep0_data_dir ? "ep0in" : "ep0out",
76 readl(®s->ep_traddr));
78 /* TRB should be prepared before starting transfer. */
79 writel(EP_CMD_DRDY, ®s->ep_cmd);
81 /* Resume controller before arming transfer. */
82 __cdns3_gadget_wakeup(priv_dev);
85 writel(EP_CMD_ERDY, &priv_dev->regs->ep_cmd);
89 * cdns3_ep0_delegate_req - Returns status of handling setup packet
90 * Setup is handled by gadget driver
91 * @priv_dev: extended gadget object
92 * @ctrl_req: pointer to received setup packet
94 * Returns zero on success or negative value on failure
96 static int cdns3_ep0_delegate_req(struct cdns3_device *priv_dev,
97 struct usb_ctrlrequest *ctrl_req)
101 spin_unlock(&priv_dev->lock);
102 priv_dev->setup_pending = 1;
103 ret = priv_dev->gadget_driver->setup(&priv_dev->gadget, ctrl_req);
104 priv_dev->setup_pending = 0;
105 spin_lock(&priv_dev->lock);
109 static void cdns3_prepare_setup_packet(struct cdns3_device *priv_dev)
111 priv_dev->ep0_data_dir = 0;
112 priv_dev->ep0_stage = CDNS3_SETUP_STAGE;
113 cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
114 sizeof(struct usb_ctrlrequest), 0, 0);
117 static void cdns3_ep0_complete_setup(struct cdns3_device *priv_dev,
118 u8 send_stall, u8 send_erdy)
120 struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
121 struct usb_request *request;
123 request = cdns3_next_request(&priv_ep->pending_req_list);
125 list_del_init(&request->list);
128 trace_cdns3_halt(priv_ep, send_stall, 0);
129 /* set_stall on ep0 */
130 cdns3_select_ep(priv_dev, 0x00);
131 writel(EP_CMD_SSTALL, &priv_dev->regs->ep_cmd);
133 cdns3_prepare_setup_packet(priv_dev);
136 priv_dev->ep0_stage = CDNS3_SETUP_STAGE;
137 writel((send_erdy ? EP_CMD_ERDY : 0) | EP_CMD_REQ_CMPL,
138 &priv_dev->regs->ep_cmd);
140 cdns3_allow_enable_l1(priv_dev, 1);
144 * cdns3_req_ep0_set_configuration - Handling of SET_CONFIG standard USB request
145 * @priv_dev: extended gadget object
146 * @ctrl_req: pointer to received setup packet
148 * Returns 0 if success, USB_GADGET_DELAYED_STATUS on deferred status stage,
149 * error code on error
151 static int cdns3_req_ep0_set_configuration(struct cdns3_device *priv_dev,
152 struct usb_ctrlrequest *ctrl_req)
154 enum usb_device_state device_state = priv_dev->gadget.state;
155 struct cdns3_endpoint *priv_ep;
156 u32 config = le16_to_cpu(ctrl_req->wValue);
160 switch (device_state) {
161 case USB_STATE_ADDRESS:
162 /* Configure non-control EPs */
163 for (i = 0; i < CDNS3_ENDPOINTS_MAX_COUNT; i++) {
164 priv_ep = priv_dev->eps[i];
168 if (priv_ep->flags & EP_CLAIMED)
169 cdns3_ep_config(priv_ep);
172 result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
178 cdns3_set_hw_configuration(priv_dev);
180 cdns3_hw_reset_eps_config(priv_dev);
181 usb_gadget_set_state(&priv_dev->gadget,
185 case USB_STATE_CONFIGURED:
186 result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
188 if (!config && !result) {
189 cdns3_hw_reset_eps_config(priv_dev);
190 usb_gadget_set_state(&priv_dev->gadget,
202 * cdns3_req_ep0_set_address - Handling of SET_ADDRESS standard USB request
203 * @priv_dev: extended gadget object
204 * @ctrl_req: pointer to received setup packet
206 * Returns 0 if success, error code on error
208 static int cdns3_req_ep0_set_address(struct cdns3_device *priv_dev,
209 struct usb_ctrlrequest *ctrl_req)
211 enum usb_device_state device_state = priv_dev->gadget.state;
215 addr = le16_to_cpu(ctrl_req->wValue);
217 if (addr > USB_DEVICE_MAX_ADDRESS) {
218 dev_err(priv_dev->dev,
219 "Device address (%d) cannot be greater than %d\n",
220 addr, USB_DEVICE_MAX_ADDRESS);
224 if (device_state == USB_STATE_CONFIGURED) {
225 dev_err(priv_dev->dev,
226 "can't set_address from configured state\n");
230 reg = readl(&priv_dev->regs->usb_cmd);
232 writel(reg | USB_CMD_FADDR(addr) | USB_CMD_SET_ADDR,
233 &priv_dev->regs->usb_cmd);
235 usb_gadget_set_state(&priv_dev->gadget,
236 (addr ? USB_STATE_ADDRESS : USB_STATE_DEFAULT));
242 * cdns3_req_ep0_get_status - Handling of GET_STATUS standard USB request
243 * @priv_dev: extended gadget object
244 * @ctrl_req: pointer to received setup packet
246 * Returns 0 if success, error code on error
248 static int cdns3_req_ep0_get_status(struct cdns3_device *priv_dev,
249 struct usb_ctrlrequest *ctrl)
251 __le16 *response_pkt;
255 recip = ctrl->bRequestType & USB_RECIP_MASK;
258 case USB_RECIP_DEVICE:
260 if (priv_dev->is_selfpowered)
261 usb_status = BIT(USB_DEVICE_SELF_POWERED);
263 if (priv_dev->wake_up_flag)
264 usb_status |= BIT(USB_DEVICE_REMOTE_WAKEUP);
266 if (priv_dev->gadget.speed != USB_SPEED_SUPER)
269 if (priv_dev->u1_allowed)
270 usb_status |= BIT(USB_DEV_STAT_U1_ENABLED);
272 if (priv_dev->u2_allowed)
273 usb_status |= BIT(USB_DEV_STAT_U2_ENABLED);
276 case USB_RECIP_INTERFACE:
277 return cdns3_ep0_delegate_req(priv_dev, ctrl);
278 case USB_RECIP_ENDPOINT:
279 /* check if endpoint is stalled */
280 cdns3_select_ep(priv_dev, ctrl->wIndex);
281 if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)))
282 usb_status = BIT(USB_ENDPOINT_HALT);
288 response_pkt = (__le16 *)priv_dev->setup_buf;
289 *response_pkt = cpu_to_le16(usb_status);
291 /* Flush setup response */
292 flush_dcache_range((unsigned long)priv_dev->setup_buf,
293 (unsigned long)priv_dev->setup_buf +
294 ROUND(sizeof(struct usb_ctrlrequest),
295 CONFIG_SYS_CACHELINE_SIZE));
297 cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
298 sizeof(*response_pkt), 1, 0);
302 static int cdns3_ep0_feature_handle_device(struct cdns3_device *priv_dev,
303 struct usb_ctrlrequest *ctrl,
306 enum usb_device_state state;
307 enum usb_device_speed speed;
311 state = priv_dev->gadget.state;
312 speed = priv_dev->gadget.speed;
314 switch (ctrl->wValue) {
315 case USB_DEVICE_REMOTE_WAKEUP:
316 priv_dev->wake_up_flag = !!set;
318 case USB_DEVICE_U1_ENABLE:
319 if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
322 priv_dev->u1_allowed = !!set;
324 case USB_DEVICE_U2_ENABLE:
325 if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
328 priv_dev->u2_allowed = !!set;
330 case USB_DEVICE_LTM_ENABLE:
333 case USB_DEVICE_TEST_MODE:
334 if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH)
337 tmode = le16_to_cpu(ctrl->wIndex);
339 if (!set || (tmode & 0xff) != 0)
342 switch (tmode >> 8) {
347 cdns3_ep0_complete_setup(priv_dev, 0, 1);
349 * Little delay to give the controller some time
350 * for sending status stage.
351 * This time should be less then 3ms.
353 usleep_range(1000, 2000);
354 cdns3_set_register_bit(&priv_dev->regs->usb_cmd,
356 USB_STS_TMODE_SEL(tmode - 1));
369 static int cdns3_ep0_feature_handle_intf(struct cdns3_device *priv_dev,
370 struct usb_ctrlrequest *ctrl,
376 wValue = le16_to_cpu(ctrl->wValue);
379 case USB_INTRF_FUNC_SUSPEND:
388 static int cdns3_ep0_feature_handle_endpoint(struct cdns3_device *priv_dev,
389 struct usb_ctrlrequest *ctrl,
392 struct cdns3_endpoint *priv_ep;
396 if (le16_to_cpu(ctrl->wValue) != USB_ENDPOINT_HALT)
399 if (!(ctrl->wIndex & ~USB_DIR_IN))
402 index = cdns3_ep_addr_to_index(ctrl->wIndex);
403 priv_ep = priv_dev->eps[index];
405 cdns3_select_ep(priv_dev, ctrl->wIndex);
408 __cdns3_gadget_ep_set_halt(priv_ep);
409 else if (!(priv_ep->flags & EP_WEDGE))
410 ret = __cdns3_gadget_ep_clear_halt(priv_ep);
412 cdns3_select_ep(priv_dev, 0x00);
418 * cdns3_req_ep0_handle_feature -
419 * Handling of GET/SET_FEATURE standard USB request
421 * @priv_dev: extended gadget object
422 * @ctrl_req: pointer to received setup packet
423 * @set: must be set to 1 for SET_FEATURE request
425 * Returns 0 if success, error code on error
427 static int cdns3_req_ep0_handle_feature(struct cdns3_device *priv_dev,
428 struct usb_ctrlrequest *ctrl,
434 recip = ctrl->bRequestType & USB_RECIP_MASK;
437 case USB_RECIP_DEVICE:
438 ret = cdns3_ep0_feature_handle_device(priv_dev, ctrl, set);
440 case USB_RECIP_INTERFACE:
441 ret = cdns3_ep0_feature_handle_intf(priv_dev, ctrl, set);
443 case USB_RECIP_ENDPOINT:
444 ret = cdns3_ep0_feature_handle_endpoint(priv_dev, ctrl, set);
454 * cdns3_req_ep0_set_sel - Handling of SET_SEL standard USB request
455 * @priv_dev: extended gadget object
456 * @ctrl_req: pointer to received setup packet
458 * Returns 0 if success, error code on error
460 static int cdns3_req_ep0_set_sel(struct cdns3_device *priv_dev,
461 struct usb_ctrlrequest *ctrl_req)
463 if (priv_dev->gadget.state < USB_STATE_ADDRESS)
466 if (ctrl_req->wLength != 6) {
467 dev_err(priv_dev->dev, "Set SEL should be 6 bytes, got %d\n",
472 cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma, 6, 1, 0);
477 * cdns3_req_ep0_set_isoch_delay -
478 * Handling of GET_ISOCH_DELAY standard USB request
479 * @priv_dev: extended gadget object
480 * @ctrl_req: pointer to received setup packet
482 * Returns 0 if success, error code on error
484 static int cdns3_req_ep0_set_isoch_delay(struct cdns3_device *priv_dev,
485 struct usb_ctrlrequest *ctrl_req)
487 if (ctrl_req->wIndex || ctrl_req->wLength)
490 priv_dev->isoch_delay = ctrl_req->wValue;
496 * cdns3_ep0_standard_request - Handling standard USB requests
497 * @priv_dev: extended gadget object
498 * @ctrl_req: pointer to received setup packet
500 * Returns 0 if success, error code on error
502 static int cdns3_ep0_standard_request(struct cdns3_device *priv_dev,
503 struct usb_ctrlrequest *ctrl_req)
507 switch (ctrl_req->bRequest) {
508 case USB_REQ_SET_ADDRESS:
509 ret = cdns3_req_ep0_set_address(priv_dev, ctrl_req);
511 case USB_REQ_SET_CONFIGURATION:
512 ret = cdns3_req_ep0_set_configuration(priv_dev, ctrl_req);
514 case USB_REQ_GET_STATUS:
515 ret = cdns3_req_ep0_get_status(priv_dev, ctrl_req);
517 case USB_REQ_CLEAR_FEATURE:
518 ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 0);
520 case USB_REQ_SET_FEATURE:
521 ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 1);
523 case USB_REQ_SET_SEL:
524 ret = cdns3_req_ep0_set_sel(priv_dev, ctrl_req);
526 case USB_REQ_SET_ISOCH_DELAY:
527 ret = cdns3_req_ep0_set_isoch_delay(priv_dev, ctrl_req);
530 ret = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
537 static void __pending_setup_status_handler(struct cdns3_device *priv_dev)
539 struct usb_request *request = priv_dev->pending_status_request;
541 if (priv_dev->status_completion_no_call && request &&
543 request->complete(&priv_dev->eps[0]->endpoint, request);
544 priv_dev->status_completion_no_call = 0;
548 void cdns3_pending_setup_status_handler(struct work_struct *work)
550 struct cdns3_device *priv_dev = container_of(work, struct cdns3_device,
554 spin_lock_irqsave(&priv_dev->lock, flags);
555 __pending_setup_status_handler(priv_dev);
556 spin_unlock_irqrestore(&priv_dev->lock, flags);
560 * cdns3_ep0_setup_phase - Handling setup USB requests
561 * @priv_dev: extended gadget object
563 static void cdns3_ep0_setup_phase(struct cdns3_device *priv_dev)
565 struct usb_ctrlrequest *ctrl = priv_dev->setup_buf;
566 struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
569 /* Invalidate Setup Packet received */
570 invalidate_dcache_range(priv_dev->setup_dma,
571 priv_dev->setup_dma + ARCH_DMA_MINALIGN);
573 priv_dev->ep0_data_dir = ctrl->bRequestType & USB_DIR_IN;
575 trace_cdns3_ctrl_req(ctrl);
577 if (!list_empty(&priv_ep->pending_req_list)) {
578 struct usb_request *request;
580 request = cdns3_next_request(&priv_ep->pending_req_list);
581 priv_ep->dir = priv_dev->ep0_data_dir;
582 cdns3_gadget_giveback(priv_ep, to_cdns3_request(request),
586 if (le16_to_cpu(ctrl->wLength))
587 priv_dev->ep0_stage = CDNS3_DATA_STAGE;
589 priv_dev->ep0_stage = CDNS3_STATUS_STAGE;
591 if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
592 result = cdns3_ep0_standard_request(priv_dev, ctrl);
594 result = cdns3_ep0_delegate_req(priv_dev, ctrl);
596 if (result == USB_GADGET_DELAYED_STATUS)
600 cdns3_ep0_complete_setup(priv_dev, 1, 1);
601 else if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE)
602 cdns3_ep0_complete_setup(priv_dev, 0, 1);
605 static void cdns3_transfer_completed(struct cdns3_device *priv_dev)
607 struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
609 if (!list_empty(&priv_ep->pending_req_list)) {
610 struct usb_request *request;
612 trace_cdns3_complete_trb(priv_ep, priv_ep->trb_pool);
613 request = cdns3_next_request(&priv_ep->pending_req_list);
615 /* Invalidate TRB before accessing it */
616 invalidate_dcache_range((unsigned long)priv_ep->trb_pool,
617 (unsigned long)priv_ep->trb_pool +
618 ROUND(sizeof(struct cdns3_trb),
619 CONFIG_SYS_CACHELINE_SIZE));
622 TRB_LEN(le32_to_cpu(priv_ep->trb_pool->length));
624 priv_ep->dir = priv_dev->ep0_data_dir;
625 cdns3_gadget_giveback(priv_ep, to_cdns3_request(request), 0);
628 cdns3_ep0_complete_setup(priv_dev, 0, 0);
632 * cdns3_check_new_setup - Check if controller receive new SETUP packet.
633 * @priv_dev: extended gadget object
635 * The SETUP packet can be kept in on-chip memory or in system memory.
637 static bool cdns3_check_new_setup(struct cdns3_device *priv_dev)
641 cdns3_select_ep(priv_dev, 0 | USB_DIR_OUT);
642 ep_sts_reg = readl(&priv_dev->regs->ep_sts);
644 return !!(ep_sts_reg & (EP_STS_SETUP | EP_STS_STPWAIT));
648 * cdns3_check_ep0_interrupt_proceed - Processes interrupt related to endpoint 0
649 * @priv_dev: extended gadget object
650 * @dir: USB_DIR_IN for IN direction, USB_DIR_OUT for OUT direction
652 void cdns3_check_ep0_interrupt_proceed(struct cdns3_device *priv_dev, int dir)
656 cdns3_select_ep(priv_dev, dir);
658 ep_sts_reg = readl(&priv_dev->regs->ep_sts);
659 writel(ep_sts_reg, &priv_dev->regs->ep_sts);
661 trace_cdns3_ep0_irq(priv_dev, ep_sts_reg);
663 __pending_setup_status_handler(priv_dev);
665 if (ep_sts_reg & EP_STS_SETUP)
666 priv_dev->wait_for_setup = 1;
668 if (priv_dev->wait_for_setup && ep_sts_reg & EP_STS_IOC) {
669 priv_dev->wait_for_setup = 0;
670 cdns3_allow_enable_l1(priv_dev, 0);
671 cdns3_ep0_setup_phase(priv_dev);
672 } else if ((ep_sts_reg & EP_STS_IOC) || (ep_sts_reg & EP_STS_ISP)) {
673 priv_dev->ep0_data_dir = dir;
674 cdns3_transfer_completed(priv_dev);
677 if (ep_sts_reg & EP_STS_DESCMIS) {
678 if (dir == 0 && !priv_dev->setup_pending)
679 cdns3_prepare_setup_packet(priv_dev);
684 * cdns3_gadget_ep0_enable
685 * Function shouldn't be called by gadget driver,
686 * endpoint 0 is allways active
688 static int cdns3_gadget_ep0_enable(struct usb_ep *ep,
689 const struct usb_endpoint_descriptor *desc)
695 * cdns3_gadget_ep0_disable
696 * Function shouldn't be called by gadget driver,
697 * endpoint 0 is allways active
699 static int cdns3_gadget_ep0_disable(struct usb_ep *ep)
705 * cdns3_gadget_ep0_set_halt
706 * @ep: pointer to endpoint zero object
707 * @value: 1 for set stall, 0 for clear stall
711 static int cdns3_gadget_ep0_set_halt(struct usb_ep *ep, int value)
718 * cdns3_gadget_ep0_queue Transfer data on endpoint zero
719 * @ep: pointer to endpoint zero object
720 * @request: pointer to request object
721 * @gfp_flags: gfp flags
723 * Returns 0 on success, error code elsewhere
725 static int cdns3_gadget_ep0_queue(struct usb_ep *ep,
726 struct usb_request *request,
729 struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
730 struct cdns3_device *priv_dev = priv_ep->cdns3_dev;
736 trace_cdns3_ep0_queue(priv_dev, request);
738 /* cancel the request if controller receive new SETUP packet. */
739 if (cdns3_check_new_setup(priv_dev))
742 /* send STATUS stage. Should be called only for SET_CONFIGURATION */
743 if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE) {
744 spin_lock_irqsave(&priv_dev->lock, flags);
745 cdns3_select_ep(priv_dev, 0x00);
747 erdy_sent = !priv_dev->hw_configured_flag;
748 cdns3_set_hw_configuration(priv_dev);
751 cdns3_ep0_complete_setup(priv_dev, 0, 1);
753 cdns3_allow_enable_l1(priv_dev, 1);
756 priv_dev->status_completion_no_call = true;
757 priv_dev->pending_status_request = request;
758 spin_unlock_irqrestore(&priv_dev->lock, flags);
761 * Since there is no completion interrupt for status stage,
762 * it needs to call ->completion in software after
766 queue_work(system_freezable_wq, &priv_dev->pending_status_wq);
768 __pending_setup_status_handler(priv_dev);
773 spin_lock_irqsave(&priv_dev->lock, flags);
774 if (!list_empty(&priv_ep->pending_req_list)) {
775 dev_err(priv_dev->dev,
776 "can't handle multiple requests for ep0\n");
777 spin_unlock_irqrestore(&priv_dev->lock, flags);
781 ret = usb_gadget_map_request(&priv_dev->gadget, request,
782 priv_dev->ep0_data_dir);
784 spin_unlock_irqrestore(&priv_dev->lock, flags);
785 dev_err(priv_dev->dev, "failed to map request\n");
789 request->status = -EINPROGRESS;
790 list_add_tail(&request->list, &priv_ep->pending_req_list);
792 if (request->zero && request->length &&
793 (request->length % ep->maxpacket == 0))
796 cdns3_ep0_run_transfer(priv_dev, request->dma, request->length, 1, zlp);
798 spin_unlock_irqrestore(&priv_dev->lock, flags);
804 * cdns3_gadget_ep_set_wedge Set wedge on selected endpoint
805 * @ep: endpoint object
809 int cdns3_gadget_ep_set_wedge(struct usb_ep *ep)
811 struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
813 dev_dbg(priv_dev->dev, "Wedge for %s\n", ep->name);
814 cdns3_gadget_ep_set_halt(ep, 1);
815 priv_ep->flags |= EP_WEDGE;
820 const struct usb_ep_ops cdns3_gadget_ep0_ops = {
821 .enable = cdns3_gadget_ep0_enable,
822 .disable = cdns3_gadget_ep0_disable,
823 .alloc_request = cdns3_gadget_ep_alloc_request,
824 .free_request = cdns3_gadget_ep_free_request,
825 .queue = cdns3_gadget_ep0_queue,
826 .dequeue = cdns3_gadget_ep_dequeue,
827 .set_halt = cdns3_gadget_ep0_set_halt,
828 .set_wedge = cdns3_gadget_ep_set_wedge,
832 * cdns3_ep0_config - Configures default endpoint
833 * @priv_dev: extended gadget object
835 * Functions sets parameters: maximal packet size and enables interrupts
837 void cdns3_ep0_config(struct cdns3_device *priv_dev)
839 struct cdns3_usb_regs __iomem *regs;
840 struct cdns3_endpoint *priv_ep;
841 u32 max_packet_size = 64;
843 regs = priv_dev->regs;
845 if (priv_dev->gadget.speed == USB_SPEED_SUPER)
846 max_packet_size = 512;
848 priv_ep = priv_dev->eps[0];
850 if (!list_empty(&priv_ep->pending_req_list)) {
851 struct usb_request *request;
853 request = cdns3_next_request(&priv_ep->pending_req_list);
854 list_del_init(&request->list);
857 priv_dev->u1_allowed = 0;
858 priv_dev->u2_allowed = 0;
860 priv_dev->gadget.ep0->maxpacket = max_packet_size;
861 cdns3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(max_packet_size);
864 cdns3_select_ep(priv_dev, USB_DIR_OUT);
866 if (priv_dev->dev_ver >= DEV_VER_V3) {
867 cdns3_set_register_bit(&priv_dev->regs->dtrans,
869 cdns3_set_register_bit(&priv_dev->regs->tdl_from_trb,
873 writel(EP_CFG_ENABLE | EP_CFG_MAXPKTSIZE(max_packet_size),
876 writel(EP_STS_EN_SETUPEN | EP_STS_EN_DESCMISEN | EP_STS_EN_TRBERREN,
880 cdns3_select_ep(priv_dev, USB_DIR_IN);
882 writel(EP_CFG_ENABLE | EP_CFG_MAXPKTSIZE(max_packet_size),
885 writel(EP_STS_EN_SETUPEN | EP_STS_EN_TRBERREN, ®s->ep_sts_en);
887 cdns3_set_register_bit(®s->usb_conf, USB_CONF_U1DS | USB_CONF_U2DS);
891 * cdns3_init_ep0 Initializes software endpoint 0 of gadget
892 * @priv_dev: extended gadget object
893 * @ep_priv: extended endpoint object
895 * Returns 0 on success else error code.
897 int cdns3_init_ep0(struct cdns3_device *priv_dev,
898 struct cdns3_endpoint *priv_ep)
900 sprintf(priv_ep->name, "ep0");
902 /* fill linux fields */
903 priv_ep->endpoint.ops = &cdns3_gadget_ep0_ops;
904 priv_ep->endpoint.maxburst = 1;
905 usb_ep_set_maxpacket_limit(&priv_ep->endpoint,
906 CDNS3_EP0_MAX_PACKET_LIMIT);
908 priv_ep->endpoint.address = 0;
910 priv_ep->endpoint.caps.type_control = 1;
911 priv_ep->endpoint.caps.dir_in = 1;
912 priv_ep->endpoint.caps.dir_out = 1;
913 priv_ep->endpoint.name = priv_ep->name;
914 priv_ep->endpoint.desc = &cdns3_gadget_ep0_desc;
915 priv_dev->gadget.ep0 = &priv_ep->endpoint;
916 priv_ep->type = USB_ENDPOINT_XFER_CONTROL;
918 return cdns3_allocate_trb_pool(priv_ep);