Loading...
Note: File does not exist in v6.8.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Cadence USBSS DRD Driver - gadget side.
4 *
5 * Copyright (C) 2018 Cadence Design Systems.
6 * Copyright (C) 2017-2018 NXP
7 *
8 * Authors: Pawel Jez <pjez@cadence.com>,
9 * Pawel Laszczak <pawell@cadence.com>
10 * Peter Chen <peter.chen@nxp.com>
11 */
12
13#include <linux/usb/composite.h>
14#include <linux/iopoll.h>
15
16#include "gadget.h"
17#include "trace.h"
18
19static struct usb_endpoint_descriptor cdns3_gadget_ep0_desc = {
20 .bLength = USB_DT_ENDPOINT_SIZE,
21 .bDescriptorType = USB_DT_ENDPOINT,
22 .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
23};
24
25/**
26 * cdns3_ep0_run_transfer - Do transfer on default endpoint hardware
27 * @priv_dev: extended gadget object
28 * @dma_addr: physical address where data is/will be stored
29 * @length: data length
30 * @erdy: set it to 1 when ERDY packet should be sent -
31 * exit from flow control state
32 * @zlp: add zero length packet
33 */
34static void cdns3_ep0_run_transfer(struct cdns3_device *priv_dev,
35 dma_addr_t dma_addr,
36 unsigned int length, int erdy, int zlp)
37{
38 struct cdns3_usb_regs __iomem *regs = priv_dev->regs;
39 struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
40
41 priv_ep->trb_pool[0].buffer = cpu_to_le32(TRB_BUFFER(dma_addr));
42 priv_ep->trb_pool[0].length = cpu_to_le32(TRB_LEN(length));
43
44 if (zlp) {
45 priv_ep->trb_pool[0].control = cpu_to_le32(TRB_CYCLE | TRB_TYPE(TRB_NORMAL));
46 priv_ep->trb_pool[1].buffer = cpu_to_le32(TRB_BUFFER(dma_addr));
47 priv_ep->trb_pool[1].length = cpu_to_le32(TRB_LEN(0));
48 priv_ep->trb_pool[1].control = cpu_to_le32(TRB_CYCLE | TRB_IOC |
49 TRB_TYPE(TRB_NORMAL));
50 } else {
51 priv_ep->trb_pool[0].control = cpu_to_le32(TRB_CYCLE | TRB_IOC |
52 TRB_TYPE(TRB_NORMAL));
53 priv_ep->trb_pool[1].control = 0;
54 }
55
56 trace_cdns3_prepare_trb(priv_ep, priv_ep->trb_pool);
57
58 cdns3_select_ep(priv_dev, priv_dev->ep0_data_dir);
59
60 writel(EP_STS_TRBERR, ®s->ep_sts);
61 writel(EP_TRADDR_TRADDR(priv_ep->trb_pool_dma), ®s->ep_traddr);
62 trace_cdns3_doorbell_ep0(priv_dev->ep0_data_dir ? "ep0in" : "ep0out",
63 readl(®s->ep_traddr));
64
65 /* TRB should be prepared before starting transfer. */
66 writel(EP_CMD_DRDY, ®s->ep_cmd);
67
68 /* Resume controller before arming transfer. */
69 __cdns3_gadget_wakeup(priv_dev);
70
71 if (erdy)
72 writel(EP_CMD_ERDY, &priv_dev->regs->ep_cmd);
73}
74
75/**
76 * cdns3_ep0_delegate_req - Returns status of handling setup packet
77 * Setup is handled by gadget driver
78 * @priv_dev: extended gadget object
79 * @ctrl_req: pointer to received setup packet
80 *
81 * Returns zero on success or negative value on failure
82 */
83static int cdns3_ep0_delegate_req(struct cdns3_device *priv_dev,
84 struct usb_ctrlrequest *ctrl_req)
85{
86 int ret;
87
88 spin_unlock(&priv_dev->lock);
89 priv_dev->setup_pending = 1;
90 ret = priv_dev->gadget_driver->setup(&priv_dev->gadget, ctrl_req);
91 priv_dev->setup_pending = 0;
92 spin_lock(&priv_dev->lock);
93 return ret;
94}
95
96static void cdns3_prepare_setup_packet(struct cdns3_device *priv_dev)
97{
98 priv_dev->ep0_data_dir = 0;
99 priv_dev->ep0_stage = CDNS3_SETUP_STAGE;
100 cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
101 sizeof(struct usb_ctrlrequest), 0, 0);
102}
103
104static void cdns3_ep0_complete_setup(struct cdns3_device *priv_dev,
105 u8 send_stall, u8 send_erdy)
106{
107 struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
108 struct usb_request *request;
109
110 request = cdns3_next_request(&priv_ep->pending_req_list);
111 if (request)
112 list_del_init(&request->list);
113
114 if (send_stall) {
115 trace_cdns3_halt(priv_ep, send_stall, 0);
116 /* set_stall on ep0 */
117 cdns3_select_ep(priv_dev, 0x00);
118 writel(EP_CMD_SSTALL, &priv_dev->regs->ep_cmd);
119 } else {
120 cdns3_prepare_setup_packet(priv_dev);
121 }
122
123 priv_dev->ep0_stage = CDNS3_SETUP_STAGE;
124 writel((send_erdy ? EP_CMD_ERDY : 0) | EP_CMD_REQ_CMPL,
125 &priv_dev->regs->ep_cmd);
126}
127
128/**
129 * cdns3_req_ep0_set_configuration - Handling of SET_CONFIG standard USB request
130 * @priv_dev: extended gadget object
131 * @ctrl_req: pointer to received setup packet
132 *
133 * Returns 0 if success, USB_GADGET_DELAYED_STATUS on deferred status stage,
134 * error code on error
135 */
136static int cdns3_req_ep0_set_configuration(struct cdns3_device *priv_dev,
137 struct usb_ctrlrequest *ctrl_req)
138{
139 enum usb_device_state device_state = priv_dev->gadget.state;
140 struct cdns3_endpoint *priv_ep;
141 u32 config = le16_to_cpu(ctrl_req->wValue);
142 int result = 0;
143 int i;
144
145 switch (device_state) {
146 case USB_STATE_ADDRESS:
147 /* Configure non-control EPs */
148 for (i = 0; i < CDNS3_ENDPOINTS_MAX_COUNT; i++) {
149 priv_ep = priv_dev->eps[i];
150 if (!priv_ep)
151 continue;
152
153 if (priv_ep->flags & EP_CLAIMED)
154 cdns3_ep_config(priv_ep);
155 }
156
157 result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
158
159 if (result)
160 return result;
161
162 if (!config) {
163 cdns3_hw_reset_eps_config(priv_dev);
164 usb_gadget_set_state(&priv_dev->gadget,
165 USB_STATE_ADDRESS);
166 }
167
168 break;
169 case USB_STATE_CONFIGURED:
170 result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
171
172 if (!config && !result) {
173 cdns3_hw_reset_eps_config(priv_dev);
174 usb_gadget_set_state(&priv_dev->gadget,
175 USB_STATE_ADDRESS);
176 }
177 break;
178 default:
179 result = -EINVAL;
180 }
181
182 return result;
183}
184
185/**
186 * cdns3_req_ep0_set_address - Handling of SET_ADDRESS standard USB request
187 * @priv_dev: extended gadget object
188 * @ctrl_req: pointer to received setup packet
189 *
190 * Returns 0 if success, error code on error
191 */
192static int cdns3_req_ep0_set_address(struct cdns3_device *priv_dev,
193 struct usb_ctrlrequest *ctrl_req)
194{
195 enum usb_device_state device_state = priv_dev->gadget.state;
196 u32 reg;
197 u32 addr;
198
199 addr = le16_to_cpu(ctrl_req->wValue);
200
201 if (addr > USB_DEVICE_MAX_ADDRESS) {
202 dev_err(priv_dev->dev,
203 "Device address (%d) cannot be greater than %d\n",
204 addr, USB_DEVICE_MAX_ADDRESS);
205 return -EINVAL;
206 }
207
208 if (device_state == USB_STATE_CONFIGURED) {
209 dev_err(priv_dev->dev,
210 "can't set_address from configured state\n");
211 return -EINVAL;
212 }
213
214 reg = readl(&priv_dev->regs->usb_cmd);
215
216 writel(reg | USB_CMD_FADDR(addr) | USB_CMD_SET_ADDR,
217 &priv_dev->regs->usb_cmd);
218
219 usb_gadget_set_state(&priv_dev->gadget,
220 (addr ? USB_STATE_ADDRESS : USB_STATE_DEFAULT));
221
222 return 0;
223}
224
225/**
226 * cdns3_req_ep0_get_status - Handling of GET_STATUS standard USB request
227 * @priv_dev: extended gadget object
228 * @ctrl: pointer to received setup packet
229 *
230 * Returns 0 if success, error code on error
231 */
232static int cdns3_req_ep0_get_status(struct cdns3_device *priv_dev,
233 struct usb_ctrlrequest *ctrl)
234{
235 struct cdns3_endpoint *priv_ep;
236 __le16 *response_pkt;
237 u16 usb_status = 0;
238 u32 recip;
239 u8 index;
240
241 recip = ctrl->bRequestType & USB_RECIP_MASK;
242
243 switch (recip) {
244 case USB_RECIP_DEVICE:
245 /* self powered */
246 if (priv_dev->is_selfpowered)
247 usb_status = BIT(USB_DEVICE_SELF_POWERED);
248
249 if (priv_dev->wake_up_flag)
250 usb_status |= BIT(USB_DEVICE_REMOTE_WAKEUP);
251
252 if (priv_dev->gadget.speed != USB_SPEED_SUPER)
253 break;
254
255 if (priv_dev->u1_allowed)
256 usb_status |= BIT(USB_DEV_STAT_U1_ENABLED);
257
258 if (priv_dev->u2_allowed)
259 usb_status |= BIT(USB_DEV_STAT_U2_ENABLED);
260
261 break;
262 case USB_RECIP_INTERFACE:
263 return cdns3_ep0_delegate_req(priv_dev, ctrl);
264 case USB_RECIP_ENDPOINT:
265 index = cdns3_ep_addr_to_index(le16_to_cpu(ctrl->wIndex));
266 priv_ep = priv_dev->eps[index];
267
268 /* check if endpoint is stalled or stall is pending */
269 cdns3_select_ep(priv_dev, le16_to_cpu(ctrl->wIndex));
270 if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)) ||
271 (priv_ep->flags & EP_STALL_PENDING))
272 usb_status = BIT(USB_ENDPOINT_HALT);
273 break;
274 default:
275 return -EINVAL;
276 }
277
278 response_pkt = (__le16 *)priv_dev->setup_buf;
279 *response_pkt = cpu_to_le16(usb_status);
280
281 cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
282 sizeof(*response_pkt), 1, 0);
283 return 0;
284}
285
286static int cdns3_ep0_feature_handle_device(struct cdns3_device *priv_dev,
287 struct usb_ctrlrequest *ctrl,
288 int set)
289{
290 enum usb_device_state state;
291 enum usb_device_speed speed;
292 int ret = 0;
293 u32 wValue;
294 u16 tmode;
295
296 wValue = le16_to_cpu(ctrl->wValue);
297 state = priv_dev->gadget.state;
298 speed = priv_dev->gadget.speed;
299
300 switch (wValue) {
301 case USB_DEVICE_REMOTE_WAKEUP:
302 priv_dev->wake_up_flag = !!set;
303 break;
304 case USB_DEVICE_U1_ENABLE:
305 if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
306 return -EINVAL;
307
308 priv_dev->u1_allowed = !!set;
309 break;
310 case USB_DEVICE_U2_ENABLE:
311 if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
312 return -EINVAL;
313
314 priv_dev->u2_allowed = !!set;
315 break;
316 case USB_DEVICE_LTM_ENABLE:
317 ret = -EINVAL;
318 break;
319 case USB_DEVICE_TEST_MODE:
320 if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH)
321 return -EINVAL;
322
323 tmode = le16_to_cpu(ctrl->wIndex);
324
325 if (!set || (tmode & 0xff) != 0)
326 return -EINVAL;
327
328 tmode >>= 8;
329 switch (tmode) {
330 case USB_TEST_J:
331 case USB_TEST_K:
332 case USB_TEST_SE0_NAK:
333 case USB_TEST_PACKET:
334 cdns3_set_register_bit(&priv_dev->regs->usb_cmd,
335 USB_CMD_STMODE |
336 USB_STS_TMODE_SEL(tmode - 1));
337 break;
338 default:
339 ret = -EINVAL;
340 }
341 break;
342 default:
343 ret = -EINVAL;
344 }
345
346 return ret;
347}
348
349static int cdns3_ep0_feature_handle_intf(struct cdns3_device *priv_dev,
350 struct usb_ctrlrequest *ctrl,
351 int set)
352{
353 u32 wValue;
354 int ret = 0;
355
356 wValue = le16_to_cpu(ctrl->wValue);
357
358 switch (wValue) {
359 case USB_INTRF_FUNC_SUSPEND:
360 break;
361 default:
362 ret = -EINVAL;
363 }
364
365 return ret;
366}
367
368static int cdns3_ep0_feature_handle_endpoint(struct cdns3_device *priv_dev,
369 struct usb_ctrlrequest *ctrl,
370 int set)
371{
372 struct cdns3_endpoint *priv_ep;
373 int ret = 0;
374 u8 index;
375
376 if (le16_to_cpu(ctrl->wValue) != USB_ENDPOINT_HALT)
377 return -EINVAL;
378
379 if (!(ctrl->wIndex & ~USB_DIR_IN))
380 return 0;
381
382 index = cdns3_ep_addr_to_index(le16_to_cpu(ctrl->wIndex));
383 priv_ep = priv_dev->eps[index];
384
385 cdns3_select_ep(priv_dev, le16_to_cpu(ctrl->wIndex));
386
387 if (set)
388 __cdns3_gadget_ep_set_halt(priv_ep);
389 else if (!(priv_ep->flags & EP_WEDGE))
390 ret = __cdns3_gadget_ep_clear_halt(priv_ep);
391
392 cdns3_select_ep(priv_dev, 0x00);
393
394 return ret;
395}
396
397/**
398 * cdns3_req_ep0_handle_feature -
399 * Handling of GET/SET_FEATURE standard USB request
400 *
401 * @priv_dev: extended gadget object
402 * @ctrl: pointer to received setup packet
403 * @set: must be set to 1 for SET_FEATURE request
404 *
405 * Returns 0 if success, error code on error
406 */
407static int cdns3_req_ep0_handle_feature(struct cdns3_device *priv_dev,
408 struct usb_ctrlrequest *ctrl,
409 int set)
410{
411 int ret = 0;
412 u32 recip;
413
414 recip = ctrl->bRequestType & USB_RECIP_MASK;
415
416 switch (recip) {
417 case USB_RECIP_DEVICE:
418 ret = cdns3_ep0_feature_handle_device(priv_dev, ctrl, set);
419 break;
420 case USB_RECIP_INTERFACE:
421 ret = cdns3_ep0_feature_handle_intf(priv_dev, ctrl, set);
422 break;
423 case USB_RECIP_ENDPOINT:
424 ret = cdns3_ep0_feature_handle_endpoint(priv_dev, ctrl, set);
425 break;
426 default:
427 return -EINVAL;
428 }
429
430 return ret;
431}
432
433/**
434 * cdns3_req_ep0_set_sel - Handling of SET_SEL standard USB request
435 * @priv_dev: extended gadget object
436 * @ctrl_req: pointer to received setup packet
437 *
438 * Returns 0 if success, error code on error
439 */
440static int cdns3_req_ep0_set_sel(struct cdns3_device *priv_dev,
441 struct usb_ctrlrequest *ctrl_req)
442{
443 if (priv_dev->gadget.state < USB_STATE_ADDRESS)
444 return -EINVAL;
445
446 if (le16_to_cpu(ctrl_req->wLength) != 6) {
447 dev_err(priv_dev->dev, "Set SEL should be 6 bytes, got %d\n",
448 ctrl_req->wLength);
449 return -EINVAL;
450 }
451
452 cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma, 6, 1, 0);
453 return 0;
454}
455
456/**
457 * cdns3_req_ep0_set_isoch_delay -
458 * Handling of GET_ISOCH_DELAY standard USB request
459 * @priv_dev: extended gadget object
460 * @ctrl_req: pointer to received setup packet
461 *
462 * Returns 0 if success, error code on error
463 */
464static int cdns3_req_ep0_set_isoch_delay(struct cdns3_device *priv_dev,
465 struct usb_ctrlrequest *ctrl_req)
466{
467 if (ctrl_req->wIndex || ctrl_req->wLength)
468 return -EINVAL;
469
470 priv_dev->isoch_delay = le16_to_cpu(ctrl_req->wValue);
471
472 return 0;
473}
474
475/**
476 * cdns3_ep0_standard_request - Handling standard USB requests
477 * @priv_dev: extended gadget object
478 * @ctrl_req: pointer to received setup packet
479 *
480 * Returns 0 if success, error code on error
481 */
482static int cdns3_ep0_standard_request(struct cdns3_device *priv_dev,
483 struct usb_ctrlrequest *ctrl_req)
484{
485 int ret;
486
487 switch (ctrl_req->bRequest) {
488 case USB_REQ_SET_ADDRESS:
489 ret = cdns3_req_ep0_set_address(priv_dev, ctrl_req);
490 break;
491 case USB_REQ_SET_CONFIGURATION:
492 ret = cdns3_req_ep0_set_configuration(priv_dev, ctrl_req);
493 break;
494 case USB_REQ_GET_STATUS:
495 ret = cdns3_req_ep0_get_status(priv_dev, ctrl_req);
496 break;
497 case USB_REQ_CLEAR_FEATURE:
498 ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 0);
499 break;
500 case USB_REQ_SET_FEATURE:
501 ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 1);
502 break;
503 case USB_REQ_SET_SEL:
504 ret = cdns3_req_ep0_set_sel(priv_dev, ctrl_req);
505 break;
506 case USB_REQ_SET_ISOCH_DELAY:
507 ret = cdns3_req_ep0_set_isoch_delay(priv_dev, ctrl_req);
508 break;
509 default:
510 ret = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
511 break;
512 }
513
514 return ret;
515}
516
517static void __pending_setup_status_handler(struct cdns3_device *priv_dev)
518{
519 struct usb_request *request = priv_dev->pending_status_request;
520
521 if (priv_dev->status_completion_no_call && request &&
522 request->complete) {
523 request->complete(&priv_dev->eps[0]->endpoint, request);
524 priv_dev->status_completion_no_call = 0;
525 }
526}
527
528void cdns3_pending_setup_status_handler(struct work_struct *work)
529{
530 struct cdns3_device *priv_dev = container_of(work, struct cdns3_device,
531 pending_status_wq);
532 unsigned long flags;
533
534 spin_lock_irqsave(&priv_dev->lock, flags);
535 __pending_setup_status_handler(priv_dev);
536 spin_unlock_irqrestore(&priv_dev->lock, flags);
537}
538
539/**
540 * cdns3_ep0_setup_phase - Handling setup USB requests
541 * @priv_dev: extended gadget object
542 */
543static void cdns3_ep0_setup_phase(struct cdns3_device *priv_dev)
544{
545 struct usb_ctrlrequest *ctrl = priv_dev->setup_buf;
546 struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
547 int result;
548
549 priv_dev->ep0_data_dir = ctrl->bRequestType & USB_DIR_IN;
550
551 trace_cdns3_ctrl_req(ctrl);
552
553 if (!list_empty(&priv_ep->pending_req_list)) {
554 struct usb_request *request;
555
556 request = cdns3_next_request(&priv_ep->pending_req_list);
557 priv_ep->dir = priv_dev->ep0_data_dir;
558 cdns3_gadget_giveback(priv_ep, to_cdns3_request(request),
559 -ECONNRESET);
560 }
561
562 if (le16_to_cpu(ctrl->wLength))
563 priv_dev->ep0_stage = CDNS3_DATA_STAGE;
564 else
565 priv_dev->ep0_stage = CDNS3_STATUS_STAGE;
566
567 if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
568 result = cdns3_ep0_standard_request(priv_dev, ctrl);
569 else
570 result = cdns3_ep0_delegate_req(priv_dev, ctrl);
571
572 if (result == USB_GADGET_DELAYED_STATUS)
573 return;
574
575 if (result < 0)
576 cdns3_ep0_complete_setup(priv_dev, 1, 1);
577 else if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE)
578 cdns3_ep0_complete_setup(priv_dev, 0, 1);
579}
580
581static void cdns3_transfer_completed(struct cdns3_device *priv_dev)
582{
583 struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
584
585 if (!list_empty(&priv_ep->pending_req_list)) {
586 struct usb_request *request;
587
588 trace_cdns3_complete_trb(priv_ep, priv_ep->trb_pool);
589 request = cdns3_next_request(&priv_ep->pending_req_list);
590
591 request->actual =
592 TRB_LEN(le32_to_cpu(priv_ep->trb_pool->length));
593
594 priv_ep->dir = priv_dev->ep0_data_dir;
595 cdns3_gadget_giveback(priv_ep, to_cdns3_request(request), 0);
596 }
597
598 cdns3_ep0_complete_setup(priv_dev, 0, 0);
599}
600
601/**
602 * cdns3_check_new_setup - Check if controller receive new SETUP packet.
603 * @priv_dev: extended gadget object
604 *
605 * The SETUP packet can be kept in on-chip memory or in system memory.
606 */
607static bool cdns3_check_new_setup(struct cdns3_device *priv_dev)
608{
609 u32 ep_sts_reg;
610
611 cdns3_select_ep(priv_dev, USB_DIR_OUT);
612 ep_sts_reg = readl(&priv_dev->regs->ep_sts);
613
614 return !!(ep_sts_reg & (EP_STS_SETUP | EP_STS_STPWAIT));
615}
616
617/**
618 * cdns3_check_ep0_interrupt_proceed - Processes interrupt related to endpoint 0
619 * @priv_dev: extended gadget object
620 * @dir: USB_DIR_IN for IN direction, USB_DIR_OUT for OUT direction
621 */
622void cdns3_check_ep0_interrupt_proceed(struct cdns3_device *priv_dev, int dir)
623{
624 u32 ep_sts_reg;
625
626 cdns3_select_ep(priv_dev, dir);
627
628 ep_sts_reg = readl(&priv_dev->regs->ep_sts);
629 writel(ep_sts_reg, &priv_dev->regs->ep_sts);
630
631 trace_cdns3_ep0_irq(priv_dev, ep_sts_reg);
632
633 __pending_setup_status_handler(priv_dev);
634
635 if (ep_sts_reg & EP_STS_SETUP)
636 priv_dev->wait_for_setup = 1;
637
638 if (priv_dev->wait_for_setup && ep_sts_reg & EP_STS_IOC) {
639 priv_dev->wait_for_setup = 0;
640 cdns3_ep0_setup_phase(priv_dev);
641 } else if ((ep_sts_reg & EP_STS_IOC) || (ep_sts_reg & EP_STS_ISP)) {
642 priv_dev->ep0_data_dir = dir;
643 cdns3_transfer_completed(priv_dev);
644 }
645
646 if (ep_sts_reg & EP_STS_DESCMIS) {
647 if (dir == 0 && !priv_dev->setup_pending)
648 cdns3_prepare_setup_packet(priv_dev);
649 }
650}
651
652/**
653 * cdns3_gadget_ep0_enable
654 * @ep: pointer to endpoint zero object
655 * @desc: pointer to usb endpoint descriptor
656 *
657 * Function shouldn't be called by gadget driver,
658 * endpoint 0 is allways active
659 */
660static int cdns3_gadget_ep0_enable(struct usb_ep *ep,
661 const struct usb_endpoint_descriptor *desc)
662{
663 return -EINVAL;
664}
665
666/**
667 * cdns3_gadget_ep0_disable
668 * @ep: pointer to endpoint zero object
669 *
670 * Function shouldn't be called by gadget driver,
671 * endpoint 0 is allways active
672 */
673static int cdns3_gadget_ep0_disable(struct usb_ep *ep)
674{
675 return -EINVAL;
676}
677
678/**
679 * cdns3_gadget_ep0_set_halt
680 * @ep: pointer to endpoint zero object
681 * @value: 1 for set stall, 0 for clear stall
682 *
683 * Returns 0
684 */
685static int cdns3_gadget_ep0_set_halt(struct usb_ep *ep, int value)
686{
687 /* TODO */
688 return 0;
689}
690
691/**
692 * cdns3_gadget_ep0_queue Transfer data on endpoint zero
693 * @ep: pointer to endpoint zero object
694 * @request: pointer to request object
695 * @gfp_flags: gfp flags
696 *
697 * Returns 0 on success, error code elsewhere
698 */
699static int cdns3_gadget_ep0_queue(struct usb_ep *ep,
700 struct usb_request *request,
701 gfp_t gfp_flags)
702{
703 struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
704 struct cdns3_device *priv_dev = priv_ep->cdns3_dev;
705 unsigned long flags;
706 int ret = 0;
707 u8 zlp = 0;
708
709 spin_lock_irqsave(&priv_dev->lock, flags);
710 trace_cdns3_ep0_queue(priv_dev, request);
711
712 /* cancel the request if controller receive new SETUP packet. */
713 if (cdns3_check_new_setup(priv_dev)) {
714 spin_unlock_irqrestore(&priv_dev->lock, flags);
715 return -ECONNRESET;
716 }
717
718 /* send STATUS stage. Should be called only for SET_CONFIGURATION */
719 if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE) {
720 cdns3_select_ep(priv_dev, 0x00);
721 cdns3_set_hw_configuration(priv_dev);
722 cdns3_ep0_complete_setup(priv_dev, 0, 1);
723 request->actual = 0;
724 priv_dev->status_completion_no_call = true;
725 priv_dev->pending_status_request = request;
726 spin_unlock_irqrestore(&priv_dev->lock, flags);
727
728 /*
729 * Since there is no completion interrupt for status stage,
730 * it needs to call ->completion in software after
731 * ep0_queue is back.
732 */
733 queue_work(system_freezable_wq, &priv_dev->pending_status_wq);
734 return 0;
735 }
736
737 if (!list_empty(&priv_ep->pending_req_list)) {
738 dev_err(priv_dev->dev,
739 "can't handle multiple requests for ep0\n");
740 spin_unlock_irqrestore(&priv_dev->lock, flags);
741 return -EBUSY;
742 }
743
744 ret = usb_gadget_map_request_by_dev(priv_dev->sysdev, request,
745 priv_dev->ep0_data_dir);
746 if (ret) {
747 spin_unlock_irqrestore(&priv_dev->lock, flags);
748 dev_err(priv_dev->dev, "failed to map request\n");
749 return -EINVAL;
750 }
751
752 request->status = -EINPROGRESS;
753 list_add_tail(&request->list, &priv_ep->pending_req_list);
754
755 if (request->zero && request->length &&
756 (request->length % ep->maxpacket == 0))
757 zlp = 1;
758
759 cdns3_ep0_run_transfer(priv_dev, request->dma, request->length, 1, zlp);
760
761 spin_unlock_irqrestore(&priv_dev->lock, flags);
762
763 return ret;
764}
765
766/**
767 * cdns3_gadget_ep_set_wedge Set wedge on selected endpoint
768 * @ep: endpoint object
769 *
770 * Returns 0
771 */
772int cdns3_gadget_ep_set_wedge(struct usb_ep *ep)
773{
774 struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
775 struct cdns3_device *priv_dev = priv_ep->cdns3_dev;
776
777 dev_dbg(priv_dev->dev, "Wedge for %s\n", ep->name);
778 cdns3_gadget_ep_set_halt(ep, 1);
779 priv_ep->flags |= EP_WEDGE;
780
781 return 0;
782}
783
784const struct usb_ep_ops cdns3_gadget_ep0_ops = {
785 .enable = cdns3_gadget_ep0_enable,
786 .disable = cdns3_gadget_ep0_disable,
787 .alloc_request = cdns3_gadget_ep_alloc_request,
788 .free_request = cdns3_gadget_ep_free_request,
789 .queue = cdns3_gadget_ep0_queue,
790 .dequeue = cdns3_gadget_ep_dequeue,
791 .set_halt = cdns3_gadget_ep0_set_halt,
792 .set_wedge = cdns3_gadget_ep_set_wedge,
793};
794
795/**
796 * cdns3_ep0_config - Configures default endpoint
797 * @priv_dev: extended gadget object
798 *
799 * Functions sets parameters: maximal packet size and enables interrupts
800 */
801void cdns3_ep0_config(struct cdns3_device *priv_dev)
802{
803 struct cdns3_usb_regs __iomem *regs;
804 struct cdns3_endpoint *priv_ep;
805 u32 max_packet_size = 64;
806
807 regs = priv_dev->regs;
808
809 if (priv_dev->gadget.speed == USB_SPEED_SUPER)
810 max_packet_size = 512;
811
812 priv_ep = priv_dev->eps[0];
813
814 if (!list_empty(&priv_ep->pending_req_list)) {
815 struct usb_request *request;
816
817 request = cdns3_next_request(&priv_ep->pending_req_list);
818 list_del_init(&request->list);
819 }
820
821 priv_dev->u1_allowed = 0;
822 priv_dev->u2_allowed = 0;
823
824 priv_dev->gadget.ep0->maxpacket = max_packet_size;
825 cdns3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(max_packet_size);
826
827 /* init ep out */
828 cdns3_select_ep(priv_dev, USB_DIR_OUT);
829
830 if (priv_dev->dev_ver >= DEV_VER_V3) {
831 cdns3_set_register_bit(&priv_dev->regs->dtrans,
832 BIT(0) | BIT(16));
833 cdns3_set_register_bit(&priv_dev->regs->tdl_from_trb,
834 BIT(0) | BIT(16));
835 }
836
837 writel(EP_CFG_ENABLE | EP_CFG_MAXPKTSIZE(max_packet_size),
838 ®s->ep_cfg);
839
840 writel(EP_STS_EN_SETUPEN | EP_STS_EN_DESCMISEN | EP_STS_EN_TRBERREN,
841 ®s->ep_sts_en);
842
843 /* init ep in */
844 cdns3_select_ep(priv_dev, USB_DIR_IN);
845
846 writel(EP_CFG_ENABLE | EP_CFG_MAXPKTSIZE(max_packet_size),
847 ®s->ep_cfg);
848
849 writel(EP_STS_EN_SETUPEN | EP_STS_EN_TRBERREN, ®s->ep_sts_en);
850
851 cdns3_set_register_bit(®s->usb_conf, USB_CONF_U1DS | USB_CONF_U2DS);
852}
853
854/**
855 * cdns3_init_ep0 Initializes software endpoint 0 of gadget
856 * @priv_dev: extended gadget object
857 * @priv_ep: extended endpoint object
858 *
859 * Returns 0 on success else error code.
860 */
861int cdns3_init_ep0(struct cdns3_device *priv_dev,
862 struct cdns3_endpoint *priv_ep)
863{
864 sprintf(priv_ep->name, "ep0");
865
866 /* fill linux fields */
867 priv_ep->endpoint.ops = &cdns3_gadget_ep0_ops;
868 priv_ep->endpoint.maxburst = 1;
869 usb_ep_set_maxpacket_limit(&priv_ep->endpoint,
870 CDNS3_EP0_MAX_PACKET_LIMIT);
871 priv_ep->endpoint.address = 0;
872 priv_ep->endpoint.caps.type_control = 1;
873 priv_ep->endpoint.caps.dir_in = 1;
874 priv_ep->endpoint.caps.dir_out = 1;
875 priv_ep->endpoint.name = priv_ep->name;
876 priv_ep->endpoint.desc = &cdns3_gadget_ep0_desc;
877 priv_dev->gadget.ep0 = &priv_ep->endpoint;
878 priv_ep->type = USB_ENDPOINT_XFER_CONTROL;
879
880 return cdns3_allocate_trb_pool(priv_ep);
881}