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