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