drivers/usb/musb/musb_udc.c

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