firmware/target/arm/as3525/usb-drv-as3525.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright © 2010 Tobias Diedrich
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include "system.h"
  23 #include "usb.h"
  24 #include "usb_drv.h"
  25 #include "as3525.h"
  26 #include "clock-target.h"
  27 #include "ascodec.h"
  28 #include "as3514.h"
  29 #include <stdbool.h>
  30 #include "panic.h"
  31 /*#define LOGF_ENABLE*/
  32 #include "logf.h"
  33 #include "usb_ch9.h"
  34 #include "usb_core.h"
  35 #include "string.h"
  36
  37 #if defined(USE_ROCKBOX_USB)
  38
  39 #include "usb-drv-as3525.h"
  40
  41 static struct usb_endpoint endpoints[USB_NUM_EPS][2];
  42 static int got_set_configuration = 0;
  43
  44 /*
  45  * dma/setup descriptors and buffers should avoid sharing
  46  * a cacheline with other data.
  47  * dmadescs may share with each other, since we only access them uncached.
  48  */
  49 static struct usb_dev_dma_desc dmadescs[USB_NUM_EPS][2] __attribute__((aligned(32)));
  50 /* reuse unused EP2 OUT descriptor here */
  51 static struct usb_dev_setup_buf *setup_desc = (void*)&dmadescs[2][1];
  52
  53 #if AS3525_MCLK_SEL != AS3525_CLK_PLLB
  54 static inline void usb_enable_pll(void)
  55 {
  56     CGU_COUNTB = CGU_LOCK_CNT;
  57     CGU_PLLB = AS3525_PLLB_SETTING;
  58     CGU_PLLBSUP = 0;                       /* enable PLLB */
  59     while(!(CGU_INTCTRL & CGU_PLLB_LOCK)); /* wait until PLLB is locked */
  60 }
  61
  62 static inline void usb_disable_pll(void)
  63 {
  64     CGU_PLLBSUP = CGU_PLL_POWERDOWN;
  65 }
  66 #else
  67 static inline void usb_enable_pll(void)
  68 {
  69 }
  70
  71 static inline void usb_disable_pll(void)
  72 {
  73 }
  74 #endif /* AS3525_MCLK_SEL != AS3525_CLK_PLLB */
  75
  76 void usb_attach(void)
  77 {
  78     usb_enable(true);
  79 }
  80
  81 static void usb_tick(void);
  82
  83 static void usb_phy_on(void)
  84 {
  85     /* PHY clock */
  86     CGU_USB = 1<<5 /* enable */
  87         | (CLK_DIV(AS3525_PLLB_FREQ, 48000000) / 2) << 2
  88         | 2; /* source = PLLB */
  89
  90     /* UVDD on */
  91     ascodec_write(AS3515_USB_UTIL, ascodec_read(AS3515_USB_UTIL) | (1<<4));
  92     mdelay(100);
  93
  94     /* reset */
  95     CCU_SRC = CCU_SRC_USB_AHB_EN|CCU_SRC_USB_PHY_EN;
  96     CCU_SRL = CCU_SRL_MAGIC_NUMBER;
  97     mdelay(1);
  98     CCU_SRC = CCU_SRC_USB_AHB_EN;
  99     mdelay(1);
 100     CCU_SRC = CCU_SRL = 0;
 101
 102     USB_GPIO_CSR = USB_GPIO_TX_ENABLE_N
 103                  | USB_GPIO_TX_BIT_STUFF_EN
 104                  | USB_GPIO_XO_ON
 105                  | USB_GPIO_CLK_SEL10; /* 0x06180000; */
 106 }
 107
 108 static void usb_phy_suspend(void)
 109 {
 110     USB_GPIO_CSR |= USB_GPIO_ASESSVLD_EXT |
 111                     USB_GPIO_BSESSVLD_EXT |
 112                     USB_GPIO_VBUS_VLD_EXT;
 113     mdelay(3);
 114     USB_GPIO_CSR |= USB_GPIO_VBUS_VLD_EXT_SEL;
 115     mdelay(10);
 116 }
 117
 118 static void usb_phy_resume(void)
 119 {
 120     USB_GPIO_CSR &= ~(USB_GPIO_ASESSVLD_EXT |
 121                       USB_GPIO_BSESSVLD_EXT |
 122                       USB_GPIO_VBUS_VLD_EXT);
 123     mdelay(3);
 124     USB_GPIO_CSR &= ~USB_GPIO_VBUS_VLD_EXT_SEL;
 125     mdelay(10);
 126 }
 127
 128 static void setup_desc_init(struct usb_dev_setup_buf *desc)
 129 {
 130     struct usb_dev_setup_buf *uc_desc = AS3525_UNCACHED_ADDR(desc);
 131
 132     uc_desc->status = USB_DMA_DESC_BS_HST_RDY;
 133     uc_desc->resv   = 0xffffffff;
 134     uc_desc->data1  = 0xffffffff;
 135     uc_desc->data2  = 0xffffffff;
 136 }
 137
 138 static void dma_desc_init(int ep, int dir)
 139 {
 140     struct usb_dev_dma_desc *desc = &dmadescs[ep][dir];
 141     struct usb_dev_dma_desc *uc_desc = AS3525_UNCACHED_ADDR(desc);
 142
 143     endpoints[ep][dir].uc_desc = uc_desc;
 144
 145     uc_desc->status    = USB_DMA_DESC_BS_DMA_DONE | \
 146                          USB_DMA_DESC_LAST | \
 147                          USB_DMA_DESC_ZERO_LEN;
 148     uc_desc->resv      = 0xffffffff;
 149     uc_desc->data_ptr  = 0;
 150     uc_desc->next_desc = 0;
 151 }
 152
 153 static void reset_endpoints(int init)
 154 {
 155     int i;
 156
 157     /*
 158      * OUT EP 2 is an alias for OUT EP 0 on this HW!
 159      *
 160      * Resonates with "3 bidirectional- plus 1 in-endpoints in device mode"
 161      * from the datasheet, but why ep2 and not ep3?
 162      *
 163      * Reserve it here so we will skip over it in request_endpoint().
 164      */
 165     endpoints[2][1].state |= EP_STATE_ALLOCATED;
 166
 167     for(i = 0; i < USB_NUM_EPS; i++) {
 168         /*
 169          * MPS sizes depending on speed:
 170          * LS: 8 (control), no bulk available
 171          * FS: 64 (control), 64 (bulk)
 172          * HS: 64 (control), 512 (bulk)
 173          *
 174          * We don't need to handle LS since there is no low-speed only
 175          * host AFAIK.
 176          */
 177         int mps = i == 0 ? 64 : (usb_drv_port_speed() ? 512 : 64);
 178
 179         if (init) {
 180             if (endpoints[i][0].state & EP_STATE_BUSY) {
 181                 if (endpoints[i][0].state & EP_STATE_ASYNC) {
 182                     endpoints[i][0].rc = -1;
 183                     wakeup_signal(&endpoints[i][0].complete);
 184                 } else {
 185                     usb_core_transfer_complete(i, USB_DIR_IN, -1, 0);
 186                 }
 187             }
 188             endpoints[i][0].state = 0;
 189             wakeup_init(&endpoints[i][0].complete);
 190
 191             if (i != 2) { /* Skip the OUT EP0 alias */
 192                 if (endpoints[i][1].state & EP_STATE_BUSY)
 193                     usb_core_transfer_complete(i, USB_DIR_OUT, -1, 0);
 194                 endpoints[i][1].state = 0;
 195                 wakeup_init(&endpoints[i][1].complete);
 196                 USB_OEP_SUP_PTR(i)    = 0;
 197             }
 198         }
 199
 200         dma_desc_init(i, 0);
 201         USB_IEP_CTRL    (i) = USB_EP_CTRL_FLUSH|USB_EP_CTRL_SNAK;
 202         USB_IEP_MPS     (i) = mps; /* in bytes */
 203         /* We don't care about the 'IN token received' event */
 204         USB_IEP_STS_MASK(i) = USB_EP_STAT_IN; /* OF: 0x840 */
 205         USB_IEP_TXFSIZE (i) = mps/2; /* in dwords => mps*2 bytes */
 206         USB_IEP_STS     (i) = 0xffffffff; /* clear status */
 207         USB_IEP_DESC_PTR(i) = 0;
 208
 209         if (i != 2) { /* Skip the OUT EP0 alias */
 210             dma_desc_init(i, 1);
 211             USB_OEP_CTRL    (i) = USB_EP_CTRL_FLUSH|USB_EP_CTRL_SNAK;
 212             USB_OEP_MPS     (i) = (mps/2 << 16) | mps;
 213             USB_OEP_STS_MASK(i) = USB_EP_STAT_BNA; /* OF: 0x1800 */
 214             USB_OEP_RXFR    (i) = 0;      /* Always 0 in OF trace? */
 215             USB_OEP_STS     (i) = 0xffffffff; /* clear status */
 216             USB_OEP_DESC_PTR(i) = 0;
 217         }
 218     }
 219
 220     setup_desc_init(setup_desc);
 221     USB_OEP_SUP_PTR(0)    = (int)setup_desc;
 222 }
 223
 224 void usb_drv_init(void)
 225 {
 226     logf("usb_drv_init() !!!!\n");
 227
 228     usb_enable_pll();
 229
 230     /* we have external power, so boost cpu */
 231     cpu_boost(1);
 232
 233     /* length regulator: normal operation */
 234     ascodec_write(AS3514_CVDD_DCDC3, ascodec_read(AS3514_CVDD_DCDC3) | 1<<2);
 235
 236     /* AHB part */
 237     CGU_PERI |= CGU_USB_CLOCK_ENABLE;
 238
 239     /* reset AHB */
 240     CCU_SRC = CCU_SRC_USB_AHB_EN;
 241     CCU_SRL = CCU_SRL_MAGIC_NUMBER;
 242     mdelay(1);
 243     CCU_SRC = CCU_SRL = 0;
 244
 245     USB_GPIO_CSR = USB_GPIO_TX_ENABLE_N
 246                  | USB_GPIO_TX_BIT_STUFF_EN
 247                  | USB_GPIO_XO_ON
 248                  | USB_GPIO_CLK_SEL10; /* 0x06180000; */
 249
 250     /* bug workaround according to linux patch */
 251     USB_DEV_CFG = (USB_DEV_CFG & ~3) | 1; /* full speed */
 252
 253     /* enable soft disconnect */
 254     USB_DEV_CTRL |= USB_DEV_CTRL_SOFT_DISCONN;
 255
 256     usb_phy_on();
 257     usb_phy_suspend();
 258     USB_DEV_CTRL |= USB_DEV_CTRL_SOFT_DISCONN;
 259
 260     /* We don't care about SVC or SOF events */
 261     /* Right now we don't handle suspend, so mask those too */
 262     USB_DEV_INTR_MASK = USB_DEV_INTR_SVC |
 263                         USB_DEV_INTR_SOF |
 264                         USB_DEV_INTR_USB_SUSPEND |
 265                         USB_DEV_INTR_EARLY_SUSPEND;
 266
 267     USB_DEV_CFG = USB_DEV_CFG_STAT_ACK      |
 268                   USB_DEV_CFG_UNI_DIR       |
 269                   USB_DEV_CFG_PI_16BIT      |
 270                   USB_DEV_CFG_HS            |
 271                   USB_DEV_CFG_SELF_POWERED  |
 272                   USB_DEV_CFG_CSR_PRG       |
 273                   USB_DEV_CFG_PHY_ERR_DETECT;
 274
 275     USB_DEV_CTRL = USB_DEV_CTRL_DESC_UPDATE  |
 276                    USB_DEV_CTRL_THRES_ENABLE |
 277                    USB_DEV_CTRL_BURST_ENABLE |
 278                    USB_DEV_CTRL_BLEN_8DWORDS |
 279                    USB_DEV_CTRL_TLEN_8THMAXSIZE;
 280
 281     USB_DEV_EP_INTR_MASK &= ~((1<<0) | (1<<16));    /* ep 0 */
 282
 283     reset_endpoints(1);
 284
 285     /* clear pending interrupts */
 286     USB_DEV_EP_INTR = 0xffffffff;
 287     USB_DEV_INTR    = 0xffffffff;
 288
 289     VIC_INT_ENABLE = INTERRUPT_USB;
 290
 291     usb_phy_resume();
 292     USB_DEV_CTRL &= ~USB_DEV_CTRL_SOFT_DISCONN;
 293
 294     USB_GPIO_CSR = USB_GPIO_TX_ENABLE_N
 295                  | USB_GPIO_TX_BIT_STUFF_EN
 296                  | USB_GPIO_XO_ON
 297                  | USB_GPIO_HS_INTR
 298                  | USB_GPIO_CLK_SEL10; /* 0x06180000; */
 299
 300     tick_add_task(usb_tick);
 301 }
 302
 303 void usb_drv_exit(void)
 304 {
 305     tick_remove_task(usb_tick);
 306     USB_DEV_CTRL |= (1<<10); /* soft disconnect */
 307     usb_phy_suspend();
 308     /*
 309      * mask all interrupts _before_ writing to VIC_INT_EN_CLEAR,
 310      * or else the core might latch the interrupt while
 311      * the write ot VIC_INT_EN_CLEAR is in the pipeline and
 312      * so cause a fake spurious interrupt.
 313      */
 314     USB_DEV_EP_INTR_MASK = 0xffffffff;
 315     USB_DEV_INTR_MASK    = 0xffffffff;
 316     VIC_INT_EN_CLEAR = INTERRUPT_USB;
 317     CGU_USB &= ~(1<<5);
 318     CGU_PERI &= ~CGU_USB_CLOCK_ENABLE;
 319     /* Disable UVDD generating LDO */
 320     ascodec_write(AS3515_USB_UTIL, ascodec_read(AS3515_USB_UTIL) & ~(1<<4));
 321     usb_disable_pll();
 322     cpu_boost(0);
 323     logf("usb_drv_exit() !!!!\n");
 324 }
 325
 326 int usb_drv_port_speed(void)
 327 {
 328     return (USB_DEV_STS & USB_DEV_STS_MASK_SPD) ? 0 : 1;
 329 }
 330
 331 int usb_drv_request_endpoint(int type, int dir)
 332 {
 333     int d = dir == USB_DIR_IN ? 0 : 1;
 334     int i = 1; /* skip the control EP */
 335
 336     for(; i < USB_NUM_EPS; i++) {
 337         if (endpoints[i][d].state & EP_STATE_ALLOCATED)
 338             continue;
 339
 340         endpoints[i][d].state |= EP_STATE_ALLOCATED;
 341
 342         if (dir == USB_DIR_IN) {
 343             USB_IEP_CTRL(i) = USB_EP_CTRL_FLUSH |
 344                               USB_EP_CTRL_SNAK  |
 345                               USB_EP_CTRL_ACT   |
 346                               (type << 4);
 347             USB_DEV_EP_INTR_MASK &= ~(1<<i);
 348         } else {
 349             USB_OEP_CTRL(i) = USB_EP_CTRL_FLUSH |
 350                               USB_EP_CTRL_SNAK  |
 351                               USB_EP_CTRL_ACT   |
 352                               (type << 4);
 353             USB_DEV_EP_INTR_MASK &= ~(1<<(16+i));
 354         }
 355         /* logf("usb_drv_request_endpoint(%d, %d): returning %02x\n", type, dir, i | dir); */
 356         return i | dir;
 357     }
 358
 359     logf("usb_drv_request_endpoint(%d, %d): no free endpoint found\n", type, dir);
 360     return -1;
 361 }
 362
 363 void usb_drv_release_endpoint(int ep)
 364 {
 365     int i = ep & 0x7f;
 366     int d = ep & USB_DIR_IN ? 0 : 1;
 367
 368     if (i >= USB_NUM_EPS)
 369         return;
 370     /*
 371      * Check for control EP and ignore it.
 372      * Unfortunately the usb core calls
 373      * usb_drv_release_endpoint() for ep=0..(USB_NUM_ENDPOINTS-1),
 374      * but doesn't request a new control EP after that...
 375      */
 376     if (i == 0 || /* Don't mask control EP */
 377         (i == 2 && d == 1)) /* See reset_endpoints(), EP2_OUT == EP0_OUT */
 378         return;
 379
 380     if (!(endpoints[i][d].state & EP_STATE_ALLOCATED))
 381         return;
 382
 383     /* logf("usb_drv_release_endpoint(%d, %d)\n", i, d); */
 384     endpoints[i][d].state = 0;
 385     USB_DEV_EP_INTR_MASK |= (1<<(16*d+i));
 386     USB_EP_CTRL(i, !d) = USB_EP_CTRL_FLUSH | USB_EP_CTRL_SNAK;
 387 }
 388
 389 void usb_drv_cancel_all_transfers(void)
 390 {
 391     logf("usb_drv_cancel_all_transfers()\n");
 392     return;
 393
 394     int flags = disable_irq_save();
 395     reset_endpoints(0);
 396     restore_irq(flags);
 397 }
 398
 399 int usb_drv_recv(int ep, void *ptr, int len)
 400 {
 401     struct usb_dev_dma_desc *uc_desc = endpoints[ep][1].uc_desc;
 402
 403     ep &= 0x7f;
 404     logf("usb_drv_recv(%d,%x,%d)\n", ep, (int)ptr, len);
 405
 406     if (len > USB_DMA_DESC_RXTX_BYTES)
 407         panicf("usb_recv: len=%d > %d", len, USB_DMA_DESC_RXTX_BYTES);
 408
 409     if ((int)ptr & 31) {
 410         logf("addr %08x not aligned!\n", (int)ptr);
 411     }
 412
 413     endpoints[ep][1].state |= EP_STATE_BUSY;
 414     endpoints[ep][1].len = len;
 415     endpoints[ep][1].rc  = -1;
 416     endpoints[ep][1].buf = ptr;
 417
 418     /* remove data buffer from cache */
 419     invalidate_dcache_range(ptr, len);
 420
 421     /* DMA setup */
 422     uc_desc->status    = USB_DMA_DESC_BS_HST_RDY |
 423                          USB_DMA_DESC_LAST |
 424                          len;
 425     if (len == 0) {
 426         uc_desc->status   |= USB_DMA_DESC_ZERO_LEN;
 427         uc_desc->data_ptr  = 0;
 428     } else {
 429         uc_desc->data_ptr  = ptr;
 430     }
 431     USB_OEP_DESC_PTR(ep) = (int)&dmadescs[ep][1];
 432     USB_OEP_STS(ep)      = USB_EP_STAT_OUT_RCVD; /* clear status */
 433
 434     /* Make sure receive DMA is on */
 435     if (!(USB_DEV_CTRL & USB_DEV_CTRL_RDE)){
 436         logf("enabling receive DMA\n");
 437         USB_DEV_CTRL |= USB_DEV_CTRL_RDE;
 438         if (!(USB_DEV_CTRL & USB_DEV_CTRL_RDE))
 439             logf("failed to enable!\n");
 440     }
 441
 442     USB_OEP_CTRL(ep)    |= USB_EP_CTRL_CNAK; /* Go! */
 443
 444     if (USB_OEP_CTRL(ep) & USB_EP_CTRL_NAK) {
 445         int i = 0;
 446         while (USB_OEP_CTRL(ep) & USB_EP_CTRL_NAK) {
 447             USB_OEP_CTRL(ep)    |= USB_EP_CTRL_CNAK; /* Go! */
 448             i++;
 449         }
 450         logf("ep%d CNAK needed %d retries CTRL=%x\n", ep, i, (int)USB_OEP_CTRL(ep));
 451     }
 452
 453     return 0;
 454 }
 455
 456 #if defined(LOGF_ENABLE)
 457 static char hexbuf[1025];
 458 static char hextab[16] = "0123456789abcdef";
 459
 460 char *make_hex(char *data, int len)
 461 {
 462     int i;
 463     if (!((int)data & 0x40000000))
 464         data = AS3525_UNCACHED_ADDR(data); /* don't pollute the cache */
 465
 466     if (len > 512)
 467         len = 512;
 468
 469     for (i=0; i<len; i++) {
 470         hexbuf[2*i  ] = hextab[(unsigned char)data[i] >> 4 ];
 471         hexbuf[2*i+1] = hextab[(unsigned char)data[i] & 0xf];
 472     }
 473     hexbuf[2*i] = 0;
 474
 475     return hexbuf;
 476 }
 477 #endif
 478
 479 void ep_send(int ep, void *ptr, int len)
 480 {
 481     struct usb_dev_dma_desc *uc_desc = endpoints[ep][0].uc_desc;
 482
 483     endpoints[ep][0].state |= EP_STATE_BUSY;
 484     endpoints[ep][0].len = len;
 485     endpoints[ep][0].rc = -1;
 486
 487     /* Make sure data is committed to memory */
 488     clean_dcache_range(ptr, len);
 489
 490     logf("xx%s\n", make_hex(ptr, len));
 491
 492     uc_desc->status    = USB_DMA_DESC_BS_HST_RDY |
 493                          USB_DMA_DESC_LAST |
 494                          len;
 495     if (len == 0)
 496         uc_desc->status |= USB_DMA_DESC_ZERO_LEN;
 497
 498     uc_desc->data_ptr  = ptr;
 499
 500     USB_IEP_DESC_PTR(ep) = (int)&dmadescs[ep][0];
 501     USB_IEP_STS(ep)      = 0xffffffff; /* clear status */
 502     /* start transfer */
 503     USB_IEP_CTRL(ep)     |= USB_EP_CTRL_CNAK | USB_EP_CTRL_PD;
 504     /* HW automatically sets NAK bit later */
 505 }
 506
 507 int usb_drv_send(int ep, void *ptr, int len)
 508 {
 509     logf("usb_drv_send(%d,%x,%d): ", ep, (int)ptr, len);
 510
 511     ep &= 0x7f;
 512
 513     if (ep == 0 && got_set_configuration) {
 514         got_set_configuration = 0;
 515         if (len != 0)
 516             panicf("usb_drv_send: GSC, but len!=0");
 517         /* Tell the HW we handled the request */
 518         USB_DEV_CTRL |= USB_DEV_CTRL_APCSR_DONE;
 519         return 0;
 520     }
 521
 522     ep_send(ep, ptr, len);
 523     while (endpoints[ep][0].state & EP_STATE_BUSY)
 524         wakeup_wait(&endpoints[ep][0].complete, TIMEOUT_BLOCK);
 525
 526     return endpoints[ep][0].rc;
 527 }
 528
 529 int usb_drv_send_nonblocking(int ep, void *ptr, int len)
 530 {
 531     logf("usb_drv_send_nonblocking(%d,%x,%d): ", ep, (int)ptr, len);
 532     ep &= 0x7f;
 533     endpoints[ep][0].state |= EP_STATE_ASYNC;
 534     ep_send(ep, ptr, len);
 535     return 0;
 536 }
 537
 538 static void handle_in_ep(int ep)
 539 {
 540     int ep_sts = USB_IEP_STS(ep) & ~USB_IEP_STS_MASK(ep);
 541
 542     if (ep > 3)
 543         panicf("in_ep > 3?!");
 544
 545     USB_IEP_STS(ep) = ep_sts; /* ack */
 546
 547     if (ep_sts & USB_EP_STAT_BNA) { /* Buffer was not set up */
 548         int ctrl = USB_IEP_CTRL(ep);
 549         logf("ep%d IN, status %x ctrl %x (BNA)\n", ep, ep_sts, ctrl);
 550         panicf("ep%d IN 0x%x 0x%x (BNA)", ep, ep_sts, ctrl);
 551     }
 552
 553     if (ep_sts & USB_EP_STAT_TDC) {
 554         endpoints[ep][0].state &= ~EP_STATE_BUSY;
 555         endpoints[ep][0].rc = 0;
 556         logf("EP%d %x %stx done len %x stat %08x\n",
 557              ep, ep_sts, endpoints[ep][0].state & EP_STATE_ASYNC ? "async " :"",
 558              endpoints[ep][0].len,
 559              endpoints[ep][0].uc_desc->status);
 560         if (endpoints[ep][0].state & EP_STATE_ASYNC) {
 561             endpoints[ep][0].state &= ~EP_STATE_ASYNC;
 562             usb_core_transfer_complete(ep, USB_DIR_IN, 0, endpoints[ep][0].len);
 563         } else {
 564             wakeup_signal(&endpoints[ep][0].complete);
 565         }
 566         ep_sts &= ~USB_EP_STAT_TDC;
 567     }
 568
 569     if (ep_sts) {
 570         logf("ep%d IN, hwstat %lx, epstat %x\n", ep, USB_IEP_STS(ep), endpoints[ep][0].state);
 571         panicf("ep%d IN 0x%x", ep, ep_sts);
 572     }
 573 }
 574
 575 static void handle_out_ep(int ep)
 576 {
 577     struct usb_ctrlrequest *req = (void*)AS3525_UNCACHED_ADDR(&setup_desc->data1);
 578     int ep_sts = USB_OEP_STS(ep) & ~USB_OEP_STS_MASK(ep);
 579
 580     if (ep > 3)
 581         panicf("out_ep > 3!?");
 582
 583     USB_OEP_STS(ep) = ep_sts; /* ACK */
 584
 585     if (ep_sts & USB_EP_STAT_BNA) { /* Buffer was not set up */
 586         int ctrl = USB_OEP_CTRL(ep);
 587         logf("ep%d OUT, status %x ctrl %x (BNA)\n", ep, ep_sts, ctrl);
 588         panicf("ep%d OUT 0x%x 0x%x (BNA)", ep, ep_sts, ctrl);
 589         ep_sts &= ~USB_EP_STAT_BNA;
 590     }
 591
 592     if (ep_sts & USB_EP_STAT_OUT_RCVD) {
 593         struct usb_dev_dma_desc *uc_desc = endpoints[ep][1].uc_desc;
 594         int dma_sts = uc_desc->status;
 595         int dma_len = dma_sts & 0xffff;
 596
 597         if (!(dma_sts & USB_DMA_DESC_ZERO_LEN)) {
 598              logf("EP%d OUT token, st:%08x len:%d frm:%x data=%s epstate=%d\n",
 599                  ep, dma_sts & 0xf8000000, dma_len, (dma_sts >> 16) & 0x7ff,
 600                  make_hex(uc_desc->data_ptr, dma_len), endpoints[ep][1].state);
 601              /*
 602               * If parts of the just dmaed range are in cache, dump them now.
 603               */
 604              dump_dcache_range(uc_desc->data_ptr, dma_len);
 605         } else{
 606              logf("EP%d OUT token, st:%08x frm:%x (no data)\n", ep,
 607                  dma_sts & 0xf8000000, (dma_sts >> 16) & 0x7ff);
 608         }
 609
 610         if (endpoints[ep][1].state & EP_STATE_BUSY) {
 611             endpoints[ep][1].state &= ~EP_STATE_BUSY;
 612             endpoints[ep][1].rc = 0;
 613             usb_core_transfer_complete(ep, USB_DIR_OUT, 0, dma_len);
 614         } else {
 615             logf("EP%d OUT, but no one was listening?\n", ep);
 616         }
 617
 618         USB_OEP_CTRL(ep) |= USB_EP_CTRL_SNAK; /* make sure NAK is set */
 619         ep_sts &= ~USB_EP_STAT_OUT_RCVD;
 620     }
 621
 622     if (ep_sts & USB_EP_STAT_SETUP_RCVD) {
 623         static struct usb_ctrlrequest req_copy;
 624
 625         req_copy = *req;
 626         logf("t%ld:got SETUP packet: %s type=%d req=%d val=%d ind=%d len=%d\n",
 627              current_tick,
 628              make_hex((void*)req, 8),
 629              req->bRequestType,
 630              req->bRequest,
 631              req->wValue,
 632              req->wIndex,
 633              req->wLength);
 634
 635         usb_core_control_request(&req_copy);
 636         setup_desc_init(setup_desc);
 637
 638         ep_sts &= ~USB_EP_STAT_SETUP_RCVD;
 639     }
 640
 641     if (ep_sts) {
 642         logf("ep%d OUT, status %x\n", ep, ep_sts);
 643         panicf("ep%d OUT 0x%x", ep, ep_sts);
 644     }
 645
 646 #if 0
 647     /* HW automatically disables RDE, re-enable it */
 648     /* THEORY: Because we only set up one DMA buffer... */
 649     USB_DEV_CTRL |= USB_DEV_CTRL_RDE;
 650 #endif
 651
 652     if (!(USB_DEV_CTRL & USB_DEV_CTRL_RDE)){
 653         logf("receive DMA is disabled!\n");
 654         //USB_DEV_CTRL |= USB_DEV_CTRL_RDE;
 655     }
 656 }
 657
 658 /*
 659  * This is a simplified version of the timer based RDE enable from
 660  * the Linux amd5536udc.c driver.
 661  * We need this because of the following hw issue:
 662  * The usb_storage buffer is 63KB, but Linux sends 120KB.
 663  * We get the first part, but upon re-enabling receive dma we
 664  * get a 'buffer not available' error from the hardware, since
 665  * we haven't gotten the next usb_drv_recv() from the stack yet.
 666  * It seems the NAK bit is ignored here and the HW tries to dma
 667  * the incoming data anyway.
 668  * In theory I think the BNA error should be recoverable, but
 669  * I haven't figured out how to do that yet and this approach seems
 670  * to work for now.
 671  */
 672 static void usb_tick(void)
 673 {
 674     static int rde_timer = 0;
 675     static int rde_fails = 0;
 676
 677     if (USB_DEV_CTRL & USB_DEV_CTRL_RDE)
 678         return;
 679
 680     if (!(USB_DEV_STS & USB_DEV_STS_RXF_EMPTY)) {
 681         if (rde_timer == 0)
 682             logf("usb_tick: fifo got filled\n");
 683         rde_timer++;
 684     }
 685
 686     if (rde_timer > 2) {
 687         logf("usb_tick: re-enabling RDE\n");
 688         USB_DEV_CTRL |= USB_DEV_CTRL_RDE;
 689         rde_timer = 0;
 690         if (USB_DEV_CTRL & USB_DEV_CTRL_RDE) {
 691             rde_fails = 0;
 692         } else {
 693             rde_fails++;
 694             if (rde_fails > 3)
 695                 panicf("usb_tick: failed to set RDE");
 696         }
 697     }
 698 }
 699
 700 /* interrupt service routine */
 701 void INT_USB(void)
 702 {
 703     int ep = USB_DEV_EP_INTR & ~USB_DEV_EP_INTR_MASK;
 704     int intr = USB_DEV_INTR & ~USB_DEV_INTR_MASK;
 705
 706     /* ACK interrupt sources */
 707     USB_DEV_EP_INTR = ep;
 708     USB_DEV_INTR = intr;
 709
 710     /* Handle endpoint interrupts */
 711     while (ep) {
 712         int onebit = 31-__builtin_clz(ep);
 713
 714         if (onebit < 16) handle_in_ep(onebit);
 715         else handle_out_ep(onebit-16);
 716
 717         ep &= ~(1 << onebit);
 718     }
 719
 720     /* Handle general device interrupts */
 721     if (intr) {
 722         if (intr & USB_DEV_INTR_SET_INTERFACE) {/* SET_INTERFACE received */
 723             logf("set interface\n");
 724             panicf("set interface");
 725             intr &= ~USB_DEV_INTR_SET_INTERFACE;
 726         }
 727         if (intr & USB_DEV_INTR_SET_CONFIG) {/* SET_CONFIGURATION received */
 728             /*
 729              * This is handled in HW, we have to fake a request here
 730              * for usb_core.
 731              */
 732             static struct usb_ctrlrequest set_config = {
 733             bRequestType: USB_TYPE_STANDARD | USB_RECIP_DEVICE,
 734             bRequest: USB_REQ_SET_CONFIGURATION,
 735             wValue: 0,
 736             wIndex: 0,
 737             wLength: 0,
 738             };
 739
 740             logf("set config\n");
 741             got_set_configuration = 1;
 742
 743             set_config.wValue = USB_DEV_STS & USB_DEV_STS_MASK_CFG;
 744             usb_core_control_request(&set_config);
 745             intr &= ~USB_DEV_INTR_SET_CONFIG;
 746         }
 747         if (intr & USB_DEV_INTR_EARLY_SUSPEND) {/* idle >3ms detected */
 748             logf("usb idle\n");
 749             intr &= ~USB_DEV_INTR_EARLY_SUSPEND;
 750         }
 751         if (intr & USB_DEV_INTR_USB_RESET) {/* usb reset from host? */
 752             logf("usb reset\n");
 753             reset_endpoints(1);
 754             usb_core_bus_reset();
 755             intr &= ~USB_DEV_INTR_USB_RESET;
 756         }
 757         if (intr & USB_DEV_INTR_USB_SUSPEND) {/* suspend req from host? */
 758             logf("usb suspend\n");
 759             intr &= ~USB_DEV_INTR_USB_SUSPEND;
 760         }
 761         if (intr & USB_DEV_INTR_SOF) {/* sof received */
 762             logf("sof\n");
 763             intr &= ~USB_DEV_INTR_SOF;
 764         }
 765         if (intr & USB_DEV_INTR_SVC) {/* device status changed */
 766             logf("svc: %08x otg: %08x\n", (int)USB_DEV_STS, (int)USB_OTG_CSR);
 767             intr &= ~USB_DEV_INTR_SVC;
 768         }
 769         if (intr & USB_DEV_INTR_ENUM_DONE) {/* speed enumeration complete */
 770             int spd = USB_DEV_STS & USB_DEV_STS_MASK_SPD;  /* Enumerated Speed */
 771
 772             logf("speed enum complete: ");
 773             if (spd == USB_DEV_STS_SPD_HS) logf("hs\n");
 774             if (spd == USB_DEV_STS_SPD_FS) logf("fs\n");
 775             if (spd == USB_DEV_STS_SPD_LS) logf("ls\n");
 776
 777             USB_PHY_EP0_INFO = 0x00200000       |
 778                                USB_CSR_DIR_OUT  |
 779                                USB_CSR_TYPE_CTL;
 780             USB_PHY_EP1_INFO = 0x00200000       |
 781                                USB_CSR_DIR_IN   |
 782                                USB_CSR_TYPE_CTL;
 783             USB_PHY_EP2_INFO = 0x00200001       |
 784                                USB_CSR_DIR_IN   |
 785                                USB_CSR_TYPE_BULK;
 786             USB_PHY_EP3_INFO = 0x00200001       |
 787                                USB_CSR_DIR_IN   |
 788                                USB_CSR_TYPE_BULK;
 789             USB_DEV_CTRL |= USB_DEV_CTRL_APCSR_DONE;
 790             USB_IEP_CTRL(0) |= USB_EP_CTRL_ACT;
 791             USB_OEP_CTRL(0) |= USB_EP_CTRL_ACT;
 792             intr &= ~USB_DEV_INTR_ENUM_DONE;
 793         }
 794         if (intr & USB_DEV_INTR_MYSTERY) {
 795             logf("got mystery dev intr\n");
 796             USB_DEV_INTR_MASK |= USB_DEV_INTR_MYSTERY;
 797             intr &= ~USB_DEV_INTR_MYSTERY;
 798         }
 799         if (intr) {
 800             logf("usb devirq 0x%x", intr);
 801             panicf("usb devirq 0x%x", intr);
 802         }
 803     }
 804 }
 805
 806 /* (not essential? , not implemented in usb-tcc.c) */
 807 void usb_drv_set_test_mode(int mode)
 808 {
 809     (void)mode;
 810 }
 811
 812 /* handled internally by controller */
 813 void usb_drv_set_address(int address)
 814 {
 815     (void)address;
 816 }
 817
 818 void usb_drv_stall(int ep, bool stall, bool in)
 819 {
 820    if (stall) USB_EP_CTRL(ep, in) |= USB_EP_CTRL_STALL;
 821    else USB_EP_CTRL(ep, in) &= ~USB_EP_CTRL_STALL;
 822 }
 823
 824 bool usb_drv_stalled(int ep, bool in)
 825 {
 826     return USB_EP_CTRL(ep, in) & USB_EP_CTRL_STALL;
 827 }
 828
 829 #else
 830
 831 void usb_attach(void)
 832 {
 833 }
 834
 835 void usb_drv_init(void)
 836 {
 837 }
 838
 839 void usb_drv_exit(void)
 840 {
 841 }
 842
 843 int usb_drv_port_speed(void)
 844 {
 845     return 0;
 846 }
 847
 848 int usb_drv_request_endpoint(int type, int dir)
 849 {
 850     (void)type;
 851     (void)dir;
 852
 853     return -1;
 854 }
 855
 856 void usb_drv_release_endpoint(int ep)
 857 {
 858     (void)ep;
 859 }
 860
 861 void usb_drv_cancel_all_transfers(void)
 862 {
 863 }
 864
 865 void usb_drv_set_test_mode(int mode)
 866 {
 867     (void)mode;
 868 }
 869
 870 void usb_drv_set_address(int address)
 871 {
 872     (void)address;
 873 }
 874
 875 int usb_drv_recv(int ep, void *ptr, int len)
 876 {
 877     (void)ep;
 878     (void)ptr;
 879     (void)len;
 880
 881     return -1;
 882 }
 883
 884 int usb_drv_send(int ep, void *ptr, int len)
 885 {
 886     (void)ep;
 887     (void)ptr;
 888     (void)len;
 889
 890     return -1;
 891 }
 892
 893 int usb_drv_send_nonblocking(int ep, void *ptr, int len)
 894 {
 895     (void)ep;
 896     (void)ptr;
 897     (void)len;
 898
 899     return -1;
 900 }
 901
 902 void usb_drv_stall(int ep, bool stall, bool in)
 903 {
 904     (void)ep;
 905     (void)stall;
 906     (void)in;
 907 }
 908
 909 bool usb_drv_stalled(int ep, bool in)
 910 {
 911     (void)ep;
 912     (void)in;
 913
 914     return 0;
 915 }
 916
 917 #endif