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