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