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