1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2009 Wind River Systems, Inc.
4 * Tom Rix <Tom.Rix@windriver.com>
5 *
6 * This file is a rewrite of the usb device part of
7 * repository git.omapzoom.org/repo/u-boot.git, branch master,
8 * file cpu/omap3/fastboot.c
9 *
10 * This is the unique part of its copyright :
11 *
12 * -------------------------------------------------------------------------
13 *
14 * (C) Copyright 2008 - 2009
15 * Windriver, <www.windriver.com>
16 * Tom Rix <Tom.Rix@windriver.com>
17 *
18 * -------------------------------------------------------------------------
19 *
20 * The details of connecting the device to the uboot usb device subsystem
21 * came from the old omap3 repository www.sakoman.net/u-boot-omap3.git,
22 * branch omap3-dev-usb, file drivers/usb/usbdcore_musb.c
23 *
24 * This is the unique part of its copyright :
25 *
26 * -------------------------------------------------------------------------
27 *
28 * (C) Copyright 2008 Texas Instruments Incorporated.
29 *
30 * Based on
31 * u-boot OMAP1510 USB drivers (drivers/usbdcore_omap1510.c)
32 * twl4030 init based on linux (drivers/i2c/chips/twl4030_usb.c)
33 *
34 * Author: Diego Dompe (diego.dompe@ridgerun.com)
35 * Atin Malaviya (atin.malaviya@gmail.com)
36 *
37 * -------------------------------------------------------------------------
38 */
39
40 #include <common.h>
41 #include <hang.h>
42 #include <serial.h>
43 #include <usbdevice.h>
44 #include <linux/delay.h>
45 #include <usb/udc.h>
46 #include "../gadget/ep0.h"
47 #include "musb_core.h"
48 #if defined(CONFIG_USB_OMAP3)
49 #include "omap3.h"
50 #elif defined(CONFIG_USB_AM35X)
51 #include "am35x.h"
52 #endif
53
54 /* Define MUSB_DEBUG for debugging */
55 /* #define MUSB_DEBUG */
56 #include "musb_debug.h"
57
58 #define MAX_ENDPOINT 15
59
60 #define GET_ENDPOINT(dev,ep) \
61 (((struct usb_device_instance *)(dev))->bus->endpoint_array + ep)
62
63 #define SET_EP0_STATE(s) \
64 do { \
65 if ((0 <= (s)) && (SET_ADDRESS >= (s))) { \
66 if ((s) != ep0_state) { \
67 if ((debug_setup) && (debug_level > 1)) \
68 serial_printf("INFO : Changing state " \
69 "from %s to %s in %s at " \
70 "line %d\n", \
71 ep0_state_strings[ep0_state],\
72 ep0_state_strings[s], \
73 __PRETTY_FUNCTION__, \
74 __LINE__); \
75 ep0_state = s; \
76 } \
77 } else { \
78 if (debug_level > 0) \
79 serial_printf("Error at %s %d with setting " \
80 "state %d is invalid\n", \
81 __PRETTY_FUNCTION__, __LINE__, s); \
82 } \
83 } while (0)
84
85 /* static implies these initialized to 0 or NULL */
86 static int debug_setup;
87 static int debug_level;
88 static struct musb_epinfo epinfo[MAX_ENDPOINT * 2 + 2];
89 static enum ep0_state_enum {
90 IDLE = 0,
91 TX,
92 RX,
93 SET_ADDRESS
94 } ep0_state = IDLE;
95 static char *ep0_state_strings[4] = {
96 "IDLE",
97 "TX",
98 "RX",
99 "SET_ADDRESS",
100 };
101
102 static struct urb *ep0_urb;
103 struct usb_endpoint_instance *ep0_endpoint;
104 static struct usb_device_instance *udc_device;
105 static int enabled;
106
107 static u16 pending_intrrx;
108
109 #ifdef MUSB_DEBUG
musb_db_regs(void)110 static void musb_db_regs(void)
111 {
112 u8 b;
113 u16 w;
114
115 b = readb(&musbr->faddr);
116 serial_printf("\tfaddr 0x%2.2x\n", b);
117
118 b = readb(&musbr->power);
119 musb_print_pwr(b);
120
121 w = readw(&musbr->ep[0].ep0.csr0);
122 musb_print_csr0(w);
123
124 b = readb(&musbr->devctl);
125 musb_print_devctl(b);
126
127 b = readb(&musbr->ep[0].ep0.configdata);
128 musb_print_config(b);
129
130 w = readw(&musbr->frame);
131 serial_printf("\tframe 0x%4.4x\n", w);
132
133 b = readb(&musbr->index);
134 serial_printf("\tindex 0x%2.2x\n", b);
135
136 w = readw(&musbr->ep[1].epN.rxmaxp);
137 musb_print_rxmaxp(w);
138
139 w = readw(&musbr->ep[1].epN.rxcsr);
140 musb_print_rxcsr(w);
141
142 w = readw(&musbr->ep[1].epN.txmaxp);
143 musb_print_txmaxp(w);
144
145 w = readw(&musbr->ep[1].epN.txcsr);
146 musb_print_txcsr(w);
147 }
148 #else
149 #define musb_db_regs()
150 #endif /* DEBUG_MUSB */
151
musb_peri_softconnect(void)152 static void musb_peri_softconnect(void)
153 {
154 u8 power, devctl;
155
156 /* Power off MUSB */
157 power = readb(&musbr->power);
158 power &= ~MUSB_POWER_SOFTCONN;
159 writeb(power, &musbr->power);
160
161 /* Read intr to clear */
162 readb(&musbr->intrusb);
163 readw(&musbr->intrrx);
164 readw(&musbr->intrtx);
165
166 udelay(1000 * 1000); /* 1 sec */
167
168 /* Power on MUSB */
169 power = readb(&musbr->power);
170 power |= MUSB_POWER_SOFTCONN;
171 /*
172 * The usb device interface is usb 1.1
173 * Disable 2.0 high speed by clearring the hsenable bit.
174 */
175 power &= ~MUSB_POWER_HSENAB;
176 writeb(power, &musbr->power);
177
178 /* Check if device is in b-peripheral mode */
179 devctl = readb(&musbr->devctl);
180 if (!(devctl & MUSB_DEVCTL_BDEVICE) ||
181 (devctl & MUSB_DEVCTL_HM)) {
182 serial_printf("ERROR : Unsupport USB mode\n");
183 serial_printf("Check that mini-B USB cable is attached "
184 "to the device\n");
185 }
186
187 if (debug_setup && (debug_level > 1))
188 musb_db_regs();
189 }
190
musb_peri_reset(void)191 static void musb_peri_reset(void)
192 {
193 if ((debug_setup) && (debug_level > 1))
194 serial_printf("INFO : %s reset\n", __PRETTY_FUNCTION__);
195
196 if (ep0_endpoint)
197 ep0_endpoint->endpoint_address = 0xff;
198
199 /* Sync sw and hw addresses */
200 writeb(udc_device->address, &musbr->faddr);
201
202 SET_EP0_STATE(IDLE);
203 }
204
musb_peri_resume(void)205 static void musb_peri_resume(void)
206 {
207 /* noop */
208 }
209
musb_peri_ep0_stall(void)210 static void musb_peri_ep0_stall(void)
211 {
212 u16 csr0;
213
214 csr0 = readw(&musbr->ep[0].ep0.csr0);
215 csr0 |= MUSB_CSR0_P_SENDSTALL;
216 writew(csr0, &musbr->ep[0].ep0.csr0);
217 if ((debug_setup) && (debug_level > 1))
218 serial_printf("INFO : %s stall\n", __PRETTY_FUNCTION__);
219 }
220
musb_peri_ep0_ack_req(void)221 static void musb_peri_ep0_ack_req(void)
222 {
223 u16 csr0;
224
225 csr0 = readw(&musbr->ep[0].ep0.csr0);
226 csr0 |= MUSB_CSR0_P_SVDRXPKTRDY;
227 writew(csr0, &musbr->ep[0].ep0.csr0);
228 }
229
musb_ep0_tx_ready(void)230 static void musb_ep0_tx_ready(void)
231 {
232 u16 csr0;
233
234 csr0 = readw(&musbr->ep[0].ep0.csr0);
235 csr0 |= MUSB_CSR0_TXPKTRDY;
236 writew(csr0, &musbr->ep[0].ep0.csr0);
237 }
238
musb_ep0_tx_ready_and_last(void)239 static void musb_ep0_tx_ready_and_last(void)
240 {
241 u16 csr0;
242
243 csr0 = readw(&musbr->ep[0].ep0.csr0);
244 csr0 |= (MUSB_CSR0_TXPKTRDY | MUSB_CSR0_P_DATAEND);
245 writew(csr0, &musbr->ep[0].ep0.csr0);
246 }
247
musb_peri_ep0_last(void)248 static void musb_peri_ep0_last(void)
249 {
250 u16 csr0;
251
252 csr0 = readw(&musbr->ep[0].ep0.csr0);
253 csr0 |= MUSB_CSR0_P_DATAEND;
254 writew(csr0, &musbr->ep[0].ep0.csr0);
255 }
256
musb_peri_ep0_set_address(void)257 static void musb_peri_ep0_set_address(void)
258 {
259 u8 faddr;
260 writeb(udc_device->address, &musbr->faddr);
261
262 /* Verify */
263 faddr = readb(&musbr->faddr);
264 if (udc_device->address == faddr) {
265 SET_EP0_STATE(IDLE);
266 usbd_device_event_irq(udc_device, DEVICE_ADDRESS_ASSIGNED, 0);
267 if ((debug_setup) && (debug_level > 1))
268 serial_printf("INFO : %s Address set to %d\n",
269 __PRETTY_FUNCTION__, udc_device->address);
270 } else {
271 if (debug_level > 0)
272 serial_printf("ERROR : %s Address missmatch "
273 "sw %d vs hw %d\n",
274 __PRETTY_FUNCTION__,
275 udc_device->address, faddr);
276 }
277 }
278
musb_peri_rx_ack(unsigned int ep)279 static void musb_peri_rx_ack(unsigned int ep)
280 {
281 u16 peri_rxcsr;
282
283 peri_rxcsr = readw(&musbr->ep[ep].epN.rxcsr);
284 peri_rxcsr &= ~MUSB_RXCSR_RXPKTRDY;
285 writew(peri_rxcsr, &musbr->ep[ep].epN.rxcsr);
286 }
287
musb_peri_tx_ready(unsigned int ep)288 static void musb_peri_tx_ready(unsigned int ep)
289 {
290 u16 peri_txcsr;
291
292 peri_txcsr = readw(&musbr->ep[ep].epN.txcsr);
293 peri_txcsr |= MUSB_TXCSR_TXPKTRDY;
294 writew(peri_txcsr, &musbr->ep[ep].epN.txcsr);
295 }
296
musb_peri_ep0_zero_data_request(int err)297 static void musb_peri_ep0_zero_data_request(int err)
298 {
299 musb_peri_ep0_ack_req();
300
301 if (err) {
302 musb_peri_ep0_stall();
303 SET_EP0_STATE(IDLE);
304 } else {
305
306 musb_peri_ep0_last();
307
308 /* USBD state */
309 switch (ep0_urb->device_request.bRequest) {
310 case USB_REQ_SET_ADDRESS:
311 if ((debug_setup) && (debug_level > 1))
312 serial_printf("INFO : %s received set "
313 "address\n", __PRETTY_FUNCTION__);
314 break;
315
316 case USB_REQ_SET_CONFIGURATION:
317 if ((debug_setup) && (debug_level > 1))
318 serial_printf("INFO : %s Configured\n",
319 __PRETTY_FUNCTION__);
320 usbd_device_event_irq(udc_device, DEVICE_CONFIGURED, 0);
321 break;
322 }
323
324 /* EP0 state */
325 if (USB_REQ_SET_ADDRESS == ep0_urb->device_request.bRequest) {
326 SET_EP0_STATE(SET_ADDRESS);
327 } else {
328 SET_EP0_STATE(IDLE);
329 }
330 }
331 }
332
musb_peri_ep0_rx_data_request(void)333 static void musb_peri_ep0_rx_data_request(void)
334 {
335 /*
336 * This is the completion of the data OUT / RX
337 *
338 * Host is sending data to ep0 that is not
339 * part of setup. This comes from the cdc_recv_setup
340 * op that is device specific.
341 *
342 */
343 musb_peri_ep0_ack_req();
344
345 ep0_endpoint->rcv_urb = ep0_urb;
346 ep0_urb->actual_length = 0;
347 SET_EP0_STATE(RX);
348 }
349
musb_peri_ep0_tx_data_request(int err)350 static void musb_peri_ep0_tx_data_request(int err)
351 {
352 if (err) {
353 musb_peri_ep0_stall();
354 SET_EP0_STATE(IDLE);
355 } else {
356 musb_peri_ep0_ack_req();
357
358 ep0_endpoint->tx_urb = ep0_urb;
359 ep0_endpoint->sent = 0;
360 SET_EP0_STATE(TX);
361 }
362 }
363
musb_peri_ep0_idle(void)364 static void musb_peri_ep0_idle(void)
365 {
366 u16 count0;
367 int err;
368 u16 csr0;
369
370 /*
371 * Verify addresses
372 * A lot of confusion can be caused if the address
373 * in software, udc layer, does not agree with the
374 * hardware. Since the setting of the hardware address
375 * must be set after the set address request, the
376 * usb state machine is out of sync for a few frame.
377 * It is a good idea to run this check when changes
378 * are made to the state machine.
379 */
380 if ((debug_level > 0) &&
381 (ep0_state != SET_ADDRESS)) {
382 u8 faddr;
383
384 faddr = readb(&musbr->faddr);
385 if (udc_device->address != faddr) {
386 serial_printf("ERROR : %s addresses do not"
387 "match sw %d vs hw %d\n",
388 __PRETTY_FUNCTION__,
389 udc_device->address, faddr);
390 udelay(1000 * 1000);
391 hang();
392 }
393 }
394
395 csr0 = readw(&musbr->ep[0].ep0.csr0);
396
397 if (!(MUSB_CSR0_RXPKTRDY & csr0))
398 goto end;
399
400 count0 = readw(&musbr->ep[0].ep0.count0);
401 if (count0 == 0)
402 goto end;
403
404 if (count0 != 8) {
405 if ((debug_setup) && (debug_level > 1))
406 serial_printf("WARN : %s SETUP incorrect size %d\n",
407 __PRETTY_FUNCTION__, count0);
408 musb_peri_ep0_stall();
409 goto end;
410 }
411
412 read_fifo(0, count0, &ep0_urb->device_request);
413
414 if (debug_level > 2)
415 print_usb_device_request(&ep0_urb->device_request);
416
417 if (ep0_urb->device_request.wLength == 0) {
418 err = ep0_recv_setup(ep0_urb);
419
420 /* Zero data request */
421 musb_peri_ep0_zero_data_request(err);
422 } else {
423 /* Is data coming or going ? */
424 u8 reqType = ep0_urb->device_request.bmRequestType;
425
426 if (USB_REQ_DEVICE2HOST == (reqType & USB_REQ_DIRECTION_MASK)) {
427 err = ep0_recv_setup(ep0_urb);
428 /* Device to host */
429 musb_peri_ep0_tx_data_request(err);
430 } else {
431 /*
432 * Host to device
433 *
434 * The RX routine will call ep0_recv_setup
435 * when the data packet has arrived.
436 */
437 musb_peri_ep0_rx_data_request();
438 }
439 }
440
441 end:
442 return;
443 }
444
musb_peri_ep0_rx(void)445 static void musb_peri_ep0_rx(void)
446 {
447 /*
448 * This is the completion of the data OUT / RX
449 *
450 * Host is sending data to ep0 that is not
451 * part of setup. This comes from the cdc_recv_setup
452 * op that is device specific.
453 *
454 * Pass the data back to driver ep0_recv_setup which
455 * should give the cdc_recv_setup the chance to handle
456 * the rx
457 */
458 u16 csr0;
459 u16 count0;
460
461 if (debug_level > 3) {
462 if (0 != ep0_urb->actual_length) {
463 serial_printf("%s finished ? %d of %d\n",
464 __PRETTY_FUNCTION__,
465 ep0_urb->actual_length,
466 ep0_urb->device_request.wLength);
467 }
468 }
469
470 if (ep0_urb->device_request.wLength == ep0_urb->actual_length) {
471 musb_peri_ep0_last();
472 SET_EP0_STATE(IDLE);
473 ep0_recv_setup(ep0_urb);
474 return;
475 }
476
477 csr0 = readw(&musbr->ep[0].ep0.csr0);
478 if (!(MUSB_CSR0_RXPKTRDY & csr0))
479 return;
480
481 count0 = readw(&musbr->ep[0].ep0.count0);
482
483 if (count0) {
484 struct usb_endpoint_instance *endpoint;
485 u32 length;
486 u8 *data;
487
488 endpoint = ep0_endpoint;
489 if (endpoint && endpoint->rcv_urb) {
490 struct urb *urb = endpoint->rcv_urb;
491 unsigned int remaining_space = urb->buffer_length -
492 urb->actual_length;
493
494 if (remaining_space) {
495 int urb_bad = 0; /* urb is good */
496
497 if (count0 > remaining_space)
498 length = remaining_space;
499 else
500 length = count0;
501
502 data = (u8 *) urb->buffer_data;
503 data += urb->actual_length;
504
505 /* The common musb fifo reader */
506 read_fifo(0, length, data);
507
508 musb_peri_ep0_ack_req();
509
510 /*
511 * urb's actual_length is updated in
512 * usbd_rcv_complete
513 */
514 usbd_rcv_complete(endpoint, length, urb_bad);
515
516 } else {
517 if (debug_level > 0)
518 serial_printf("ERROR : %s no space in "
519 "rcv buffer\n",
520 __PRETTY_FUNCTION__);
521 }
522 } else {
523 if (debug_level > 0)
524 serial_printf("ERROR : %s problem with "
525 "endpoint\n",
526 __PRETTY_FUNCTION__);
527 }
528 } else {
529 if (debug_level > 0)
530 serial_printf("ERROR : %s with nothing to do\n",
531 __PRETTY_FUNCTION__);
532 }
533 }
534
musb_peri_ep0_tx(void)535 static void musb_peri_ep0_tx(void)
536 {
537 u16 csr0;
538 int transfer_size = 0;
539 unsigned int p, pm;
540
541 csr0 = readw(&musbr->ep[0].ep0.csr0);
542
543 /* Check for pending tx */
544 if (csr0 & MUSB_CSR0_TXPKTRDY)
545 goto end;
546
547 /* Check if this is the last packet sent */
548 if (ep0_endpoint->sent >= ep0_urb->actual_length) {
549 SET_EP0_STATE(IDLE);
550 goto end;
551 }
552
553 transfer_size = ep0_urb->actual_length - ep0_endpoint->sent;
554 /* Is the transfer size negative ? */
555 if (transfer_size <= 0) {
556 if (debug_level > 0)
557 serial_printf("ERROR : %s problem with the"
558 " transfer size %d\n",
559 __PRETTY_FUNCTION__,
560 transfer_size);
561 SET_EP0_STATE(IDLE);
562 goto end;
563 }
564
565 /* Truncate large transfers to the fifo size */
566 if (transfer_size > ep0_endpoint->tx_packetSize)
567 transfer_size = ep0_endpoint->tx_packetSize;
568
569 write_fifo(0, transfer_size, &ep0_urb->buffer[ep0_endpoint->sent]);
570 ep0_endpoint->sent += transfer_size;
571
572 /* Done or more to send ? */
573 if (ep0_endpoint->sent >= ep0_urb->actual_length)
574 musb_ep0_tx_ready_and_last();
575 else
576 musb_ep0_tx_ready();
577
578 /* Wait a bit */
579 pm = 10;
580 for (p = 0; p < pm; p++) {
581 csr0 = readw(&musbr->ep[0].ep0.csr0);
582 if (!(csr0 & MUSB_CSR0_TXPKTRDY))
583 break;
584
585 /* Double the delay. */
586 udelay(1 << pm);
587 }
588
589 if ((ep0_endpoint->sent >= ep0_urb->actual_length) && (p < pm))
590 SET_EP0_STATE(IDLE);
591
592 end:
593 return;
594 }
595
musb_peri_ep0(void)596 static void musb_peri_ep0(void)
597 {
598 u16 csr0;
599
600 if (SET_ADDRESS == ep0_state)
601 return;
602
603 csr0 = readw(&musbr->ep[0].ep0.csr0);
604
605 /* Error conditions */
606 if (MUSB_CSR0_P_SENTSTALL & csr0) {
607 csr0 &= ~MUSB_CSR0_P_SENTSTALL;
608 writew(csr0, &musbr->ep[0].ep0.csr0);
609 SET_EP0_STATE(IDLE);
610 }
611 if (MUSB_CSR0_P_SETUPEND & csr0) {
612 csr0 |= MUSB_CSR0_P_SVDSETUPEND;
613 writew(csr0, &musbr->ep[0].ep0.csr0);
614 SET_EP0_STATE(IDLE);
615 if ((debug_setup) && (debug_level > 1))
616 serial_printf("WARN: %s SETUPEND\n",
617 __PRETTY_FUNCTION__);
618 }
619
620 /* Normal states */
621 if (IDLE == ep0_state)
622 musb_peri_ep0_idle();
623
624 if (TX == ep0_state)
625 musb_peri_ep0_tx();
626
627 if (RX == ep0_state)
628 musb_peri_ep0_rx();
629 }
630
musb_peri_rx_ep(unsigned int ep)631 static void musb_peri_rx_ep(unsigned int ep)
632 {
633 u16 peri_rxcount;
634 u16 peri_rxcsr = readw(&musbr->ep[ep].epN.rxcsr);
635
636 if (!(peri_rxcsr & MUSB_RXCSR_RXPKTRDY)) {
637 if (debug_level > 0)
638 serial_printf("ERROR : %s %d without MUSB_RXCSR_RXPKTRDY set\n",
639 __PRETTY_FUNCTION__, ep);
640 return;
641 }
642
643 peri_rxcount = readw(&musbr->ep[ep].epN.rxcount);
644 if (peri_rxcount) {
645 struct usb_endpoint_instance *endpoint;
646 u32 length;
647 u8 *data;
648
649 endpoint = GET_ENDPOINT(udc_device, ep);
650 if (endpoint && endpoint->rcv_urb) {
651 struct urb *urb = endpoint->rcv_urb;
652 unsigned int remaining_space = urb->buffer_length -
653 urb->actual_length;
654
655 if (remaining_space) {
656 int urb_bad = 0; /* urb is good */
657
658 if (peri_rxcount > remaining_space)
659 length = remaining_space;
660 else
661 length = peri_rxcount;
662
663 data = (u8 *) urb->buffer_data;
664 data += urb->actual_length;
665
666 /* The common musb fifo reader */
667 read_fifo(ep, length, data);
668
669 if (length == peri_rxcount)
670 musb_peri_rx_ack(ep);
671 else
672 pending_intrrx |= (1 << ep);
673
674 /*
675 * urb's actual_length is updated in
676 * usbd_rcv_complete
677 */
678 usbd_rcv_complete(endpoint, length, urb_bad);
679
680 } else {
681 if (debug_level > 0)
682 serial_printf("ERROR : %s %d no space "
683 "in rcv buffer\n",
684 __PRETTY_FUNCTION__, ep);
685
686 pending_intrrx |= (1 << ep);
687 }
688 } else {
689 if (debug_level > 0)
690 serial_printf("ERROR : %s %d problem with "
691 "endpoint\n",
692 __PRETTY_FUNCTION__, ep);
693
694 pending_intrrx |= (1 << ep);
695 }
696
697 } else {
698 if (debug_level > 0)
699 serial_printf("ERROR : %s %d with nothing to do\n",
700 __PRETTY_FUNCTION__, ep);
701
702 musb_peri_rx_ack(ep);
703 }
704 }
705
musb_peri_rx(u16 intr)706 static void musb_peri_rx(u16 intr)
707 {
708 unsigned int ep;
709
710 /* First bit is reserved and does not indicate interrupt for EP0 */
711
712 for (ep = 1; ep < 16; ep++) {
713 if ((1 << ep) & intr)
714 musb_peri_rx_ep(ep);
715 }
716 }
717
musb_peri_tx(u16 intr)718 static void musb_peri_tx(u16 intr)
719 {
720 unsigned int ep;
721
722 /* Check for EP0: first bit indicates interrupt for both RX and TX */
723 if (0x01 & intr)
724 musb_peri_ep0();
725
726 for (ep = 1; ep < 16; ep++) {
727 if ((1 << ep) & intr)
728 udc_endpoint_write(GET_ENDPOINT(udc_device, ep));
729 }
730 }
731
udc_irq(void)732 void udc_irq(void)
733 {
734 /* This is a high freq called function */
735 if (enabled) {
736 u8 intrusb;
737
738 intrusb = readb(&musbr->intrusb);
739
740 /*
741 * See drivers/usb/gadget/mpc8xx_udc.c for
742 * state diagram going from detached through
743 * configuration.
744 */
745 if (MUSB_INTR_RESUME & intrusb) {
746 usbd_device_event_irq(udc_device,
747 DEVICE_BUS_ACTIVITY, 0);
748 musb_peri_resume();
749 }
750
751 if (MUSB_INTR_RESET & intrusb) {
752 usbd_device_event_irq(udc_device, DEVICE_RESET, 0);
753 musb_peri_reset();
754 }
755
756 if (MUSB_INTR_DISCONNECT & intrusb) {
757 /* cable unplugged from hub/host */
758 usbd_device_event_irq(udc_device, DEVICE_RESET, 0);
759 musb_peri_reset();
760 usbd_device_event_irq(udc_device, DEVICE_HUB_RESET, 0);
761 }
762
763 if (MUSB_INTR_SOF & intrusb) {
764 usbd_device_event_irq(udc_device,
765 DEVICE_BUS_ACTIVITY, 0);
766 musb_peri_resume();
767 }
768
769 if (MUSB_INTR_SUSPEND & intrusb) {
770 usbd_device_event_irq(udc_device,
771 DEVICE_BUS_INACTIVE, 0);
772 }
773
774 if (ep0_state != SET_ADDRESS) {
775 u16 intrrx, intrtx;
776
777 intrrx = readw(&musbr->intrrx);
778 intrtx = readw(&musbr->intrtx);
779
780 intrrx |= pending_intrrx;
781 pending_intrrx = 0;
782
783 if (intrrx)
784 musb_peri_rx(intrrx);
785
786 if (intrtx)
787 musb_peri_tx(intrtx);
788 } else {
789 if (readw(&musbr->intrtx) & 0x1) {
790 u8 faddr;
791 faddr = readb(&musbr->faddr);
792 /*
793 * Setting of the address can fail.
794 * Normally it succeeds the second time.
795 */
796 if (udc_device->address != faddr)
797 musb_peri_ep0_set_address();
798 }
799 }
800 }
801 }
802
udc_set_nak(int ep_num)803 void udc_set_nak(int ep_num)
804 {
805 /* noop */
806 }
807
udc_unset_nak(int ep_num)808 void udc_unset_nak(int ep_num)
809 {
810 /* noop */
811 }
812
udc_endpoint_write(struct usb_endpoint_instance * endpoint)813 int udc_endpoint_write(struct usb_endpoint_instance *endpoint)
814 {
815 int ret = 0;
816
817 /* Transmit only if the hardware is available */
818 if (endpoint->tx_urb && endpoint->state == 0) {
819 unsigned int ep = endpoint->endpoint_address &
820 USB_ENDPOINT_NUMBER_MASK;
821
822 u16 peri_txcsr = readw(&musbr->ep[ep].epN.txcsr);
823
824 /* Error conditions */
825 if (peri_txcsr & MUSB_TXCSR_P_UNDERRUN) {
826 peri_txcsr &= ~MUSB_TXCSR_P_UNDERRUN;
827 writew(peri_txcsr, &musbr->ep[ep].epN.txcsr);
828 }
829
830 if (debug_level > 1)
831 musb_print_txcsr(peri_txcsr);
832
833 /* Check if a packet is waiting to be sent */
834 if (!(peri_txcsr & MUSB_TXCSR_TXPKTRDY)) {
835 u32 length;
836 u8 *data;
837 struct urb *urb = endpoint->tx_urb;
838 unsigned int remaining_packet = urb->actual_length -
839 endpoint->sent;
840
841 if (endpoint->tx_packetSize < remaining_packet)
842 length = endpoint->tx_packetSize;
843 else
844 length = remaining_packet;
845
846 data = (u8 *) urb->buffer;
847 data += endpoint->sent;
848
849 /* common musb fifo function */
850 write_fifo(ep, length, data);
851
852 musb_peri_tx_ready(ep);
853
854 endpoint->last = length;
855 /* usbd_tx_complete will take care of updating 'sent' */
856 usbd_tx_complete(endpoint);
857 }
858 } else {
859 if (debug_level > 0)
860 serial_printf("ERROR : %s Problem with urb %p "
861 "or ep state %d\n",
862 __PRETTY_FUNCTION__,
863 endpoint->tx_urb, endpoint->state);
864 }
865
866 return ret;
867 }
868
udc_setup_ep(struct usb_device_instance * device,unsigned int id,struct usb_endpoint_instance * endpoint)869 void udc_setup_ep(struct usb_device_instance *device, unsigned int id,
870 struct usb_endpoint_instance *endpoint)
871 {
872 if (0 == id) {
873 /* EP0 */
874 ep0_endpoint = endpoint;
875 ep0_endpoint->endpoint_address = 0xff;
876 ep0_urb = usbd_alloc_urb(device, endpoint);
877 } else if (MAX_ENDPOINT >= id) {
878 epinfo[(id * 2) + 0].epsize = endpoint->rcv_packetSize;
879 epinfo[(id * 2) + 1].epsize = endpoint->tx_packetSize;
880 musb_configure_ep(&epinfo[0], ARRAY_SIZE(epinfo));
881 } else {
882 if (debug_level > 0)
883 serial_printf("ERROR : %s endpoint request %d "
884 "exceeds maximum %d\n",
885 __PRETTY_FUNCTION__, id, MAX_ENDPOINT);
886 }
887 }
888
udc_connect(void)889 void udc_connect(void)
890 {
891 /* noop */
892 }
893
udc_disconnect(void)894 void udc_disconnect(void)
895 {
896 /* noop */
897 }
898
udc_enable(struct usb_device_instance * device)899 void udc_enable(struct usb_device_instance *device)
900 {
901 /* Save the device structure pointer */
902 udc_device = device;
903
904 enabled = 1;
905 }
906
udc_disable(void)907 void udc_disable(void)
908 {
909 enabled = 0;
910 }
911
udc_startup_events(struct usb_device_instance * device)912 void udc_startup_events(struct usb_device_instance *device)
913 {
914 /* The DEVICE_INIT event puts the USB device in the state STATE_INIT. */
915 usbd_device_event_irq(device, DEVICE_INIT, 0);
916
917 /*
918 * The DEVICE_CREATE event puts the USB device in the state
919 * STATE_ATTACHED.
920 */
921 usbd_device_event_irq(device, DEVICE_CREATE, 0);
922
923 /* Resets the address to 0 */
924 usbd_device_event_irq(device, DEVICE_RESET, 0);
925
926 udc_enable(device);
927 }
928
udc_init(void)929 int udc_init(void)
930 {
931 int ret;
932 int ep_loop;
933
934 ret = musb_platform_init();
935 if (ret < 0)
936 goto end;
937
938 /* Configure all the endpoint FIFO's and start usb controller */
939 musbr = musb_cfg.regs;
940
941 /* Initialize the endpoints */
942 for (ep_loop = 0; ep_loop <= MAX_ENDPOINT * 2; ep_loop++) {
943 epinfo[ep_loop].epnum = (ep_loop / 2) + 1;
944 epinfo[ep_loop].epdir = ep_loop % 2; /* OUT, IN */
945 epinfo[ep_loop].epsize = 0;
946 }
947
948 musb_peri_softconnect();
949
950 ret = 0;
951 end:
952
953 return ret;
954 }
955