Loading...
Note: File does not exist in v3.1.
1/*
2 * mtu3_gadget_ep0.c - MediaTek USB3 DRD peripheral driver ep0 handling
3 *
4 * Copyright (c) 2016 MediaTek Inc.
5 *
6 * Author: Chunfeng.Yun <chunfeng.yun@mediatek.com>
7 *
8 * This software is licensed under the terms of the GNU General Public
9 * License version 2, as published by the Free Software Foundation, and
10 * may be copied, distributed, and modified under those terms.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 */
18
19#include "mtu3.h"
20
21/* ep0 is always mtu3->in_eps[0] */
22#define next_ep0_request(mtu) next_request((mtu)->ep0)
23
24/* for high speed test mode; see USB 2.0 spec 7.1.20 */
25static const u8 mtu3_test_packet[53] = {
26 /* implicit SYNC then DATA0 to start */
27
28 /* JKJKJKJK x9 */
29 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
30 /* JJKKJJKK x8 */
31 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
32 /* JJJJKKKK x8 */
33 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
34 /* JJJJJJJKKKKKKK x8 */
35 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
36 /* JJJJJJJK x8 */
37 0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd,
38 /* JKKKKKKK x10, JK */
39 0xfc, 0x7e, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0x7e,
40 /* implicit CRC16 then EOP to end */
41};
42
43static char *decode_ep0_state(struct mtu3 *mtu)
44{
45 switch (mtu->ep0_state) {
46 case MU3D_EP0_STATE_SETUP:
47 return "SETUP";
48 case MU3D_EP0_STATE_TX:
49 return "IN";
50 case MU3D_EP0_STATE_RX:
51 return "OUT";
52 case MU3D_EP0_STATE_TX_END:
53 return "TX-END";
54 case MU3D_EP0_STATE_STALL:
55 return "STALL";
56 default:
57 return "??";
58 }
59}
60
61static void ep0_req_giveback(struct mtu3 *mtu, struct usb_request *req)
62{
63 mtu3_req_complete(mtu->ep0, req, 0);
64}
65
66static int
67forward_to_driver(struct mtu3 *mtu, const struct usb_ctrlrequest *setup)
68__releases(mtu->lock)
69__acquires(mtu->lock)
70{
71 int ret;
72
73 if (!mtu->gadget_driver)
74 return -EOPNOTSUPP;
75
76 spin_unlock(&mtu->lock);
77 ret = mtu->gadget_driver->setup(&mtu->g, setup);
78 spin_lock(&mtu->lock);
79
80 dev_dbg(mtu->dev, "%s ret %d\n", __func__, ret);
81 return ret;
82}
83
84static void ep0_write_fifo(struct mtu3_ep *mep, const u8 *src, u16 len)
85{
86 void __iomem *fifo = mep->mtu->mac_base + U3D_FIFO0;
87 u16 index = 0;
88
89 dev_dbg(mep->mtu->dev, "%s: ep%din, len=%d, buf=%p\n",
90 __func__, mep->epnum, len, src);
91
92 if (len >= 4) {
93 iowrite32_rep(fifo, src, len >> 2);
94 index = len & ~0x03;
95 }
96 if (len & 0x02) {
97 writew(*(u16 *)&src[index], fifo);
98 index += 2;
99 }
100 if (len & 0x01)
101 writeb(src[index], fifo);
102}
103
104static void ep0_read_fifo(struct mtu3_ep *mep, u8 *dst, u16 len)
105{
106 void __iomem *fifo = mep->mtu->mac_base + U3D_FIFO0;
107 u32 value;
108 u16 index = 0;
109
110 dev_dbg(mep->mtu->dev, "%s: ep%dout len=%d buf=%p\n",
111 __func__, mep->epnum, len, dst);
112
113 if (len >= 4) {
114 ioread32_rep(fifo, dst, len >> 2);
115 index = len & ~0x03;
116 }
117 if (len & 0x3) {
118 value = readl(fifo);
119 memcpy(&dst[index], &value, len & 0x3);
120 }
121
122}
123
124static void ep0_load_test_packet(struct mtu3 *mtu)
125{
126 /*
127 * because the length of test packet is less than max packet of HS ep0,
128 * write it into fifo directly.
129 */
130 ep0_write_fifo(mtu->ep0, mtu3_test_packet, sizeof(mtu3_test_packet));
131}
132
133/*
134 * A. send STALL for setup transfer without data stage:
135 * set SENDSTALL and SETUPPKTRDY at the same time;
136 * B. send STALL for other cases:
137 * set SENDSTALL only.
138 */
139static void ep0_stall_set(struct mtu3_ep *mep0, bool set, u32 pktrdy)
140{
141 struct mtu3 *mtu = mep0->mtu;
142 void __iomem *mbase = mtu->mac_base;
143 u32 csr;
144
145 /* EP0_SENTSTALL is W1C */
146 csr = mtu3_readl(mbase, U3D_EP0CSR) & EP0_W1C_BITS;
147 if (set)
148 csr |= EP0_SENDSTALL | pktrdy;
149 else
150 csr = (csr & ~EP0_SENDSTALL) | EP0_SENTSTALL;
151 mtu3_writel(mtu->mac_base, U3D_EP0CSR, csr);
152
153 mtu->ep0_state = MU3D_EP0_STATE_SETUP;
154
155 dev_dbg(mtu->dev, "ep0: %s STALL, ep0_state: %s\n",
156 set ? "SEND" : "CLEAR", decode_ep0_state(mtu));
157}
158
159static int ep0_queue(struct mtu3_ep *mep0, struct mtu3_request *mreq);
160
161static void ep0_dummy_complete(struct usb_ep *ep, struct usb_request *req)
162{}
163
164static void ep0_set_sel_complete(struct usb_ep *ep, struct usb_request *req)
165{
166 struct mtu3_request *mreq;
167 struct mtu3 *mtu;
168 struct usb_set_sel_req sel;
169
170 memcpy(&sel, req->buf, sizeof(sel));
171
172 mreq = to_mtu3_request(req);
173 mtu = mreq->mtu;
174 dev_dbg(mtu->dev, "u1sel:%d, u1pel:%d, u2sel:%d, u2pel:%d\n",
175 sel.u1_sel, sel.u1_pel, sel.u2_sel, sel.u2_pel);
176}
177
178/* queue data stage to handle 6 byte SET_SEL request */
179static int ep0_set_sel(struct mtu3 *mtu, struct usb_ctrlrequest *setup)
180{
181 int ret;
182 u16 length = le16_to_cpu(setup->wLength);
183
184 if (unlikely(length != 6)) {
185 dev_err(mtu->dev, "%s wrong wLength:%d\n",
186 __func__, length);
187 return -EINVAL;
188 }
189
190 mtu->ep0_req.mep = mtu->ep0;
191 mtu->ep0_req.request.length = 6;
192 mtu->ep0_req.request.buf = mtu->setup_buf;
193 mtu->ep0_req.request.complete = ep0_set_sel_complete;
194 ret = ep0_queue(mtu->ep0, &mtu->ep0_req);
195
196 return ret < 0 ? ret : 1;
197}
198
199static int
200ep0_get_status(struct mtu3 *mtu, const struct usb_ctrlrequest *setup)
201{
202 struct mtu3_ep *mep = NULL;
203 int handled = 1;
204 u8 result[2] = {0, 0};
205 u8 epnum = 0;
206 int is_in;
207
208 switch (setup->bRequestType & USB_RECIP_MASK) {
209 case USB_RECIP_DEVICE:
210 result[0] = mtu->is_self_powered << USB_DEVICE_SELF_POWERED;
211 result[0] |= mtu->may_wakeup << USB_DEVICE_REMOTE_WAKEUP;
212 /* superspeed only */
213 if (mtu->g.speed == USB_SPEED_SUPER) {
214 result[0] |= mtu->u1_enable << USB_DEV_STAT_U1_ENABLED;
215 result[0] |= mtu->u2_enable << USB_DEV_STAT_U2_ENABLED;
216 }
217
218 dev_dbg(mtu->dev, "%s result=%x, U1=%x, U2=%x\n", __func__,
219 result[0], mtu->u1_enable, mtu->u2_enable);
220
221 break;
222 case USB_RECIP_INTERFACE:
223 break;
224 case USB_RECIP_ENDPOINT:
225 epnum = (u8) le16_to_cpu(setup->wIndex);
226 is_in = epnum & USB_DIR_IN;
227 epnum &= USB_ENDPOINT_NUMBER_MASK;
228
229 if (epnum >= mtu->num_eps) {
230 handled = -EINVAL;
231 break;
232 }
233 if (!epnum)
234 break;
235
236 mep = (is_in ? mtu->in_eps : mtu->out_eps) + epnum;
237 if (!mep->desc) {
238 handled = -EINVAL;
239 break;
240 }
241 if (mep->flags & MTU3_EP_STALL)
242 result[0] |= 1 << USB_ENDPOINT_HALT;
243
244 break;
245 default:
246 /* class, vendor, etc ... delegate */
247 handled = 0;
248 break;
249 }
250
251 if (handled > 0) {
252 int ret;
253
254 /* prepare a data stage for GET_STATUS */
255 dev_dbg(mtu->dev, "get_status=%x\n", *(u16 *)result);
256 memcpy(mtu->setup_buf, result, sizeof(result));
257 mtu->ep0_req.mep = mtu->ep0;
258 mtu->ep0_req.request.length = 2;
259 mtu->ep0_req.request.buf = &mtu->setup_buf;
260 mtu->ep0_req.request.complete = ep0_dummy_complete;
261 ret = ep0_queue(mtu->ep0, &mtu->ep0_req);
262 if (ret < 0)
263 handled = ret;
264 }
265 return handled;
266}
267
268static int handle_test_mode(struct mtu3 *mtu, struct usb_ctrlrequest *setup)
269{
270 void __iomem *mbase = mtu->mac_base;
271 int handled = 1;
272
273 switch (le16_to_cpu(setup->wIndex) >> 8) {
274 case TEST_J:
275 dev_dbg(mtu->dev, "TEST_J\n");
276 mtu->test_mode_nr = TEST_J_MODE;
277 break;
278 case TEST_K:
279 dev_dbg(mtu->dev, "TEST_K\n");
280 mtu->test_mode_nr = TEST_K_MODE;
281 break;
282 case TEST_SE0_NAK:
283 dev_dbg(mtu->dev, "TEST_SE0_NAK\n");
284 mtu->test_mode_nr = TEST_SE0_NAK_MODE;
285 break;
286 case TEST_PACKET:
287 dev_dbg(mtu->dev, "TEST_PACKET\n");
288 mtu->test_mode_nr = TEST_PACKET_MODE;
289 break;
290 default:
291 handled = -EINVAL;
292 goto out;
293 }
294
295 mtu->test_mode = true;
296
297 /* no TX completion interrupt, and need restart platform after test */
298 if (mtu->test_mode_nr == TEST_PACKET_MODE)
299 ep0_load_test_packet(mtu);
300
301 mtu3_writel(mbase, U3D_USB2_TEST_MODE, mtu->test_mode_nr);
302
303 mtu->ep0_state = MU3D_EP0_STATE_SETUP;
304
305out:
306 return handled;
307}
308
309static int ep0_handle_feature_dev(struct mtu3 *mtu,
310 struct usb_ctrlrequest *setup, bool set)
311{
312 void __iomem *mbase = mtu->mac_base;
313 int handled = -EINVAL;
314 u32 lpc;
315
316 switch (le16_to_cpu(setup->wValue)) {
317 case USB_DEVICE_REMOTE_WAKEUP:
318 mtu->may_wakeup = !!set;
319 handled = 1;
320 break;
321 case USB_DEVICE_TEST_MODE:
322 if (!set || (mtu->g.speed != USB_SPEED_HIGH) ||
323 (le16_to_cpu(setup->wIndex) & 0xff))
324 break;
325
326 handled = handle_test_mode(mtu, setup);
327 break;
328 case USB_DEVICE_U1_ENABLE:
329 if (mtu->g.speed != USB_SPEED_SUPER ||
330 mtu->g.state != USB_STATE_CONFIGURED)
331 break;
332
333 lpc = mtu3_readl(mbase, U3D_LINK_POWER_CONTROL);
334 if (set)
335 lpc |= SW_U1_ACCEPT_ENABLE;
336 else
337 lpc &= ~SW_U1_ACCEPT_ENABLE;
338 mtu3_writel(mbase, U3D_LINK_POWER_CONTROL, lpc);
339
340 mtu->u1_enable = !!set;
341 handled = 1;
342 break;
343 case USB_DEVICE_U2_ENABLE:
344 if (mtu->g.speed != USB_SPEED_SUPER ||
345 mtu->g.state != USB_STATE_CONFIGURED)
346 break;
347
348 lpc = mtu3_readl(mbase, U3D_LINK_POWER_CONTROL);
349 if (set)
350 lpc |= SW_U2_ACCEPT_ENABLE;
351 else
352 lpc &= ~SW_U2_ACCEPT_ENABLE;
353 mtu3_writel(mbase, U3D_LINK_POWER_CONTROL, lpc);
354
355 mtu->u2_enable = !!set;
356 handled = 1;
357 break;
358 default:
359 handled = -EINVAL;
360 break;
361 }
362 return handled;
363}
364
365static int ep0_handle_feature(struct mtu3 *mtu,
366 struct usb_ctrlrequest *setup, bool set)
367{
368 struct mtu3_ep *mep;
369 int handled = -EINVAL;
370 int is_in;
371 u16 value;
372 u16 index;
373 u8 epnum;
374
375 value = le16_to_cpu(setup->wValue);
376 index = le16_to_cpu(setup->wIndex);
377
378 switch (setup->bRequestType & USB_RECIP_MASK) {
379 case USB_RECIP_DEVICE:
380 handled = ep0_handle_feature_dev(mtu, setup, set);
381 break;
382 case USB_RECIP_INTERFACE:
383 /* superspeed only */
384 if ((value == USB_INTRF_FUNC_SUSPEND)
385 && (mtu->g.speed == USB_SPEED_SUPER)) {
386 /*
387 * forward the request because function drivers
388 * should handle it
389 */
390 handled = 0;
391 }
392 break;
393 case USB_RECIP_ENDPOINT:
394 epnum = index & USB_ENDPOINT_NUMBER_MASK;
395 if (epnum == 0 || epnum >= mtu->num_eps ||
396 value != USB_ENDPOINT_HALT)
397 break;
398
399 is_in = index & USB_DIR_IN;
400 mep = (is_in ? mtu->in_eps : mtu->out_eps) + epnum;
401 if (!mep->desc)
402 break;
403
404 handled = 1;
405 /* ignore request if endpoint is wedged */
406 if (mep->wedged)
407 break;
408
409 mtu3_ep_stall_set(mep, set);
410 break;
411 default:
412 /* class, vendor, etc ... delegate */
413 handled = 0;
414 break;
415 }
416 return handled;
417}
418
419/*
420 * handle all control requests can be handled
421 * returns:
422 * negative errno - error happened
423 * zero - need delegate SETUP to gadget driver
424 * positive - already handled
425 */
426static int handle_standard_request(struct mtu3 *mtu,
427 struct usb_ctrlrequest *setup)
428{
429 void __iomem *mbase = mtu->mac_base;
430 enum usb_device_state state = mtu->g.state;
431 int handled = -EINVAL;
432 u32 dev_conf;
433 u16 value;
434
435 value = le16_to_cpu(setup->wValue);
436
437 /* the gadget driver handles everything except what we must handle */
438 switch (setup->bRequest) {
439 case USB_REQ_SET_ADDRESS:
440 /* change it after the status stage */
441 mtu->address = (u8) (value & 0x7f);
442 dev_dbg(mtu->dev, "set address to 0x%x\n", mtu->address);
443
444 dev_conf = mtu3_readl(mbase, U3D_DEVICE_CONF);
445 dev_conf &= ~DEV_ADDR_MSK;
446 dev_conf |= DEV_ADDR(mtu->address);
447 mtu3_writel(mbase, U3D_DEVICE_CONF, dev_conf);
448
449 if (mtu->address)
450 usb_gadget_set_state(&mtu->g, USB_STATE_ADDRESS);
451 else
452 usb_gadget_set_state(&mtu->g, USB_STATE_DEFAULT);
453
454 handled = 1;
455 break;
456 case USB_REQ_SET_CONFIGURATION:
457 if (state == USB_STATE_ADDRESS) {
458 usb_gadget_set_state(&mtu->g,
459 USB_STATE_CONFIGURED);
460 } else if (state == USB_STATE_CONFIGURED) {
461 /*
462 * USB2 spec sec 9.4.7, if wValue is 0 then dev
463 * is moved to addressed state
464 */
465 if (!value)
466 usb_gadget_set_state(&mtu->g,
467 USB_STATE_ADDRESS);
468 }
469 handled = 0;
470 break;
471 case USB_REQ_CLEAR_FEATURE:
472 handled = ep0_handle_feature(mtu, setup, 0);
473 break;
474 case USB_REQ_SET_FEATURE:
475 handled = ep0_handle_feature(mtu, setup, 1);
476 break;
477 case USB_REQ_GET_STATUS:
478 handled = ep0_get_status(mtu, setup);
479 break;
480 case USB_REQ_SET_SEL:
481 handled = ep0_set_sel(mtu, setup);
482 break;
483 case USB_REQ_SET_ISOCH_DELAY:
484 handled = 1;
485 break;
486 default:
487 /* delegate SET_CONFIGURATION, etc */
488 handled = 0;
489 }
490
491 return handled;
492}
493
494/* receive an data packet (OUT) */
495static void ep0_rx_state(struct mtu3 *mtu)
496{
497 struct mtu3_request *mreq;
498 struct usb_request *req;
499 void __iomem *mbase = mtu->mac_base;
500 u32 maxp;
501 u32 csr;
502 u16 count = 0;
503
504 dev_dbg(mtu->dev, "%s\n", __func__);
505
506 csr = mtu3_readl(mbase, U3D_EP0CSR) & EP0_W1C_BITS;
507 mreq = next_ep0_request(mtu);
508 req = &mreq->request;
509
510 /* read packet and ack; or stall because of gadget driver bug */
511 if (req) {
512 void *buf = req->buf + req->actual;
513 unsigned int len = req->length - req->actual;
514
515 /* read the buffer */
516 count = mtu3_readl(mbase, U3D_RXCOUNT0);
517 if (count > len) {
518 req->status = -EOVERFLOW;
519 count = len;
520 }
521 ep0_read_fifo(mtu->ep0, buf, count);
522 req->actual += count;
523 csr |= EP0_RXPKTRDY;
524
525 maxp = mtu->g.ep0->maxpacket;
526 if (count < maxp || req->actual == req->length) {
527 mtu->ep0_state = MU3D_EP0_STATE_SETUP;
528 dev_dbg(mtu->dev, "ep0 state: %s\n",
529 decode_ep0_state(mtu));
530
531 csr |= EP0_DATAEND;
532 } else {
533 req = NULL;
534 }
535 } else {
536 csr |= EP0_RXPKTRDY | EP0_SENDSTALL;
537 dev_dbg(mtu->dev, "%s: SENDSTALL\n", __func__);
538 }
539
540 mtu3_writel(mbase, U3D_EP0CSR, csr);
541
542 /* give back the request if have received all data */
543 if (req)
544 ep0_req_giveback(mtu, req);
545
546}
547
548/* transmitting to the host (IN) */
549static void ep0_tx_state(struct mtu3 *mtu)
550{
551 struct mtu3_request *mreq = next_ep0_request(mtu);
552 struct usb_request *req;
553 u32 csr;
554 u8 *src;
555 u8 count;
556 u32 maxp;
557
558 dev_dbg(mtu->dev, "%s\n", __func__);
559
560 if (!mreq)
561 return;
562
563 maxp = mtu->g.ep0->maxpacket;
564 req = &mreq->request;
565
566 /* load the data */
567 src = (u8 *)req->buf + req->actual;
568 count = min(maxp, req->length - req->actual);
569 if (count)
570 ep0_write_fifo(mtu->ep0, src, count);
571
572 dev_dbg(mtu->dev, "%s act=%d, len=%d, cnt=%d, maxp=%d zero=%d\n",
573 __func__, req->actual, req->length, count, maxp, req->zero);
574
575 req->actual += count;
576
577 if ((count < maxp)
578 || ((req->actual == req->length) && !req->zero))
579 mtu->ep0_state = MU3D_EP0_STATE_TX_END;
580
581 /* send it out, triggering a "txpktrdy cleared" irq */
582 csr = mtu3_readl(mtu->mac_base, U3D_EP0CSR) & EP0_W1C_BITS;
583 mtu3_writel(mtu->mac_base, U3D_EP0CSR, csr | EP0_TXPKTRDY);
584
585 dev_dbg(mtu->dev, "%s ep0csr=0x%x\n", __func__,
586 mtu3_readl(mtu->mac_base, U3D_EP0CSR));
587}
588
589static void ep0_read_setup(struct mtu3 *mtu, struct usb_ctrlrequest *setup)
590{
591 struct mtu3_request *mreq;
592 u32 count;
593 u32 csr;
594
595 csr = mtu3_readl(mtu->mac_base, U3D_EP0CSR) & EP0_W1C_BITS;
596 count = mtu3_readl(mtu->mac_base, U3D_RXCOUNT0);
597
598 ep0_read_fifo(mtu->ep0, (u8 *)setup, count);
599
600 dev_dbg(mtu->dev, "SETUP req%02x.%02x v%04x i%04x l%04x\n",
601 setup->bRequestType, setup->bRequest,
602 le16_to_cpu(setup->wValue), le16_to_cpu(setup->wIndex),
603 le16_to_cpu(setup->wLength));
604
605 /* clean up any leftover transfers */
606 mreq = next_ep0_request(mtu);
607 if (mreq)
608 ep0_req_giveback(mtu, &mreq->request);
609
610 if (le16_to_cpu(setup->wLength) == 0) {
611 ; /* no data stage, nothing to do */
612 } else if (setup->bRequestType & USB_DIR_IN) {
613 mtu3_writel(mtu->mac_base, U3D_EP0CSR,
614 csr | EP0_SETUPPKTRDY | EP0_DPHTX);
615 mtu->ep0_state = MU3D_EP0_STATE_TX;
616 } else {
617 mtu3_writel(mtu->mac_base, U3D_EP0CSR,
618 (csr | EP0_SETUPPKTRDY) & (~EP0_DPHTX));
619 mtu->ep0_state = MU3D_EP0_STATE_RX;
620 }
621}
622
623static int ep0_handle_setup(struct mtu3 *mtu)
624__releases(mtu->lock)
625__acquires(mtu->lock)
626{
627 struct usb_ctrlrequest setup;
628 struct mtu3_request *mreq;
629 void __iomem *mbase = mtu->mac_base;
630 int handled = 0;
631
632 ep0_read_setup(mtu, &setup);
633
634 if ((setup.bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
635 handled = handle_standard_request(mtu, &setup);
636
637 dev_dbg(mtu->dev, "handled %d, ep0_state: %s\n",
638 handled, decode_ep0_state(mtu));
639
640 if (handled < 0)
641 goto stall;
642 else if (handled > 0)
643 goto finish;
644
645 handled = forward_to_driver(mtu, &setup);
646 if (handled < 0) {
647stall:
648 dev_dbg(mtu->dev, "%s stall (%d)\n", __func__, handled);
649
650 ep0_stall_set(mtu->ep0, true,
651 le16_to_cpu(setup.wLength) ? 0 : EP0_SETUPPKTRDY);
652
653 return 0;
654 }
655
656finish:
657 if (mtu->test_mode) {
658 ; /* nothing to do */
659 } else if (le16_to_cpu(setup.wLength) == 0) { /* no data stage */
660
661 mtu3_writel(mbase, U3D_EP0CSR,
662 (mtu3_readl(mbase, U3D_EP0CSR) & EP0_W1C_BITS)
663 | EP0_SETUPPKTRDY | EP0_DATAEND);
664
665 /* complete zlp request directly */
666 mreq = next_ep0_request(mtu);
667 if (mreq && !mreq->request.length)
668 ep0_req_giveback(mtu, &mreq->request);
669 }
670
671 return 0;
672}
673
674irqreturn_t mtu3_ep0_isr(struct mtu3 *mtu)
675{
676 void __iomem *mbase = mtu->mac_base;
677 struct mtu3_request *mreq;
678 u32 int_status;
679 irqreturn_t ret = IRQ_NONE;
680 u32 csr;
681 u32 len;
682
683 int_status = mtu3_readl(mbase, U3D_EPISR);
684 int_status &= mtu3_readl(mbase, U3D_EPIER);
685 mtu3_writel(mbase, U3D_EPISR, int_status); /* W1C */
686
687 /* only handle ep0's */
688 if (!(int_status & EP0ISR))
689 return IRQ_NONE;
690
691 csr = mtu3_readl(mbase, U3D_EP0CSR);
692
693 dev_dbg(mtu->dev, "%s csr=0x%x\n", __func__, csr);
694
695 /* we sent a stall.. need to clear it now.. */
696 if (csr & EP0_SENTSTALL) {
697 ep0_stall_set(mtu->ep0, false, 0);
698 csr = mtu3_readl(mbase, U3D_EP0CSR);
699 ret = IRQ_HANDLED;
700 }
701 dev_dbg(mtu->dev, "ep0_state: %s\n", decode_ep0_state(mtu));
702
703 switch (mtu->ep0_state) {
704 case MU3D_EP0_STATE_TX:
705 /* irq on clearing txpktrdy */
706 if ((csr & EP0_FIFOFULL) == 0) {
707 ep0_tx_state(mtu);
708 ret = IRQ_HANDLED;
709 }
710 break;
711 case MU3D_EP0_STATE_RX:
712 /* irq on set rxpktrdy */
713 if (csr & EP0_RXPKTRDY) {
714 ep0_rx_state(mtu);
715 ret = IRQ_HANDLED;
716 }
717 break;
718 case MU3D_EP0_STATE_TX_END:
719 mtu3_writel(mbase, U3D_EP0CSR,
720 (csr & EP0_W1C_BITS) | EP0_DATAEND);
721
722 mreq = next_ep0_request(mtu);
723 if (mreq)
724 ep0_req_giveback(mtu, &mreq->request);
725
726 mtu->ep0_state = MU3D_EP0_STATE_SETUP;
727 ret = IRQ_HANDLED;
728 dev_dbg(mtu->dev, "ep0_state: %s\n", decode_ep0_state(mtu));
729 break;
730 case MU3D_EP0_STATE_SETUP:
731 if (!(csr & EP0_SETUPPKTRDY))
732 break;
733
734 len = mtu3_readl(mbase, U3D_RXCOUNT0);
735 if (len != 8) {
736 dev_err(mtu->dev, "SETUP packet len %d != 8 ?\n", len);
737 break;
738 }
739
740 ep0_handle_setup(mtu);
741 ret = IRQ_HANDLED;
742 break;
743 default:
744 /* can't happen */
745 ep0_stall_set(mtu->ep0, true, 0);
746 WARN_ON(1);
747 break;
748 }
749
750 return ret;
751}
752
753
754static int mtu3_ep0_enable(struct usb_ep *ep,
755 const struct usb_endpoint_descriptor *desc)
756{
757 /* always enabled */
758 return -EINVAL;
759}
760
761static int mtu3_ep0_disable(struct usb_ep *ep)
762{
763 /* always enabled */
764 return -EINVAL;
765}
766
767static int ep0_queue(struct mtu3_ep *mep, struct mtu3_request *mreq)
768{
769 struct mtu3 *mtu = mep->mtu;
770
771 mreq->mtu = mtu;
772 mreq->request.actual = 0;
773 mreq->request.status = -EINPROGRESS;
774
775 dev_dbg(mtu->dev, "%s %s (ep0_state: %s), len#%d\n", __func__,
776 mep->name, decode_ep0_state(mtu), mreq->request.length);
777
778 if (!list_empty(&mep->req_list))
779 return -EBUSY;
780
781 switch (mtu->ep0_state) {
782 case MU3D_EP0_STATE_SETUP:
783 case MU3D_EP0_STATE_RX: /* control-OUT data */
784 case MU3D_EP0_STATE_TX: /* control-IN data */
785 break;
786 default:
787 dev_err(mtu->dev, "%s, error in ep0 state %s\n", __func__,
788 decode_ep0_state(mtu));
789 return -EINVAL;
790 }
791
792 list_add_tail(&mreq->list, &mep->req_list);
793
794 /* sequence #1, IN ... start writing the data */
795 if (mtu->ep0_state == MU3D_EP0_STATE_TX)
796 ep0_tx_state(mtu);
797
798 return 0;
799}
800
801static int mtu3_ep0_queue(struct usb_ep *ep,
802 struct usb_request *req, gfp_t gfp)
803{
804 struct mtu3_ep *mep;
805 struct mtu3_request *mreq;
806 struct mtu3 *mtu;
807 unsigned long flags;
808 int ret = 0;
809
810 if (!ep || !req)
811 return -EINVAL;
812
813 mep = to_mtu3_ep(ep);
814 mtu = mep->mtu;
815 mreq = to_mtu3_request(req);
816
817 spin_lock_irqsave(&mtu->lock, flags);
818 ret = ep0_queue(mep, mreq);
819 spin_unlock_irqrestore(&mtu->lock, flags);
820 return ret;
821}
822
823static int mtu3_ep0_dequeue(struct usb_ep *ep, struct usb_request *req)
824{
825 /* we just won't support this */
826 return -EINVAL;
827}
828
829static int mtu3_ep0_halt(struct usb_ep *ep, int value)
830{
831 struct mtu3_ep *mep;
832 struct mtu3 *mtu;
833 unsigned long flags;
834 int ret = 0;
835
836 if (!ep || !value)
837 return -EINVAL;
838
839 mep = to_mtu3_ep(ep);
840 mtu = mep->mtu;
841
842 dev_dbg(mtu->dev, "%s\n", __func__);
843
844 spin_lock_irqsave(&mtu->lock, flags);
845
846 if (!list_empty(&mep->req_list)) {
847 ret = -EBUSY;
848 goto cleanup;
849 }
850
851 switch (mtu->ep0_state) {
852 /*
853 * stalls are usually issued after parsing SETUP packet, either
854 * directly in irq context from setup() or else later.
855 */
856 case MU3D_EP0_STATE_TX:
857 case MU3D_EP0_STATE_TX_END:
858 case MU3D_EP0_STATE_RX:
859 case MU3D_EP0_STATE_SETUP:
860 ep0_stall_set(mtu->ep0, true, 0);
861 break;
862 default:
863 dev_dbg(mtu->dev, "ep0 can't halt in state %s\n",
864 decode_ep0_state(mtu));
865 ret = -EINVAL;
866 }
867
868cleanup:
869 spin_unlock_irqrestore(&mtu->lock, flags);
870 return ret;
871}
872
873const struct usb_ep_ops mtu3_ep0_ops = {
874 .enable = mtu3_ep0_enable,
875 .disable = mtu3_ep0_disable,
876 .alloc_request = mtu3_alloc_request,
877 .free_request = mtu3_free_request,
878 .queue = mtu3_ep0_queue,
879 .dequeue = mtu3_ep0_dequeue,
880 .set_halt = mtu3_ep0_halt,
881};