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