firmware/target/arm/usb-tcc.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2008 by Vitja Makarov
  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 "config.h"
  23 #include "usb.h"
  24
  25 #include "usb-tcc.h"
  26
  27 #include "cpu.h"
  28 #include "system.h"
  29 #include "kernel.h"
  30 #include "panic.h"
  31
  32 #ifdef HAVE_USBSTACK
  33 #include "usb_ch9.h"
  34 #include "usb_core.h"
  35
  36 #define TCC7xx_USB_EPIF_IRQ_MASK 0xf
  37
  38 static int dbg_level = 0x00;
  39 static int global_ep_irq_mask = 0x1;
  40 #define DEBUG(level, fmt, args...) do { if (dbg_level & (level)) printf(fmt, ## args); } while (0)
  41
  42 #include <inttypes.h>
  43
  44
  45 #include "sprintf.h"
  46 #include "power.h"
  47
  48 #ifndef BOOTLOADER
  49 #define printf(...) do {} while (0)
  50 #define panicf_my panicf
  51 #else
  52 int printf(const char *fmt, ...);
  53 #define panicf_my(fmt, args...) {               \
  54     int flags = disable_irq_save();             \
  55     printf("*** PANIC ***");                    \
  56     printf(fmt, ## args);                       \
  57     printf("*** PANIC ***");                    \
  58     while (usb_detect() == USB_INSERTED)        \
  59         ;                                       \
  60     power_off();                                \
  61     while(1);                                   \
  62     restore_irq(flags);                         \
  63 }
  64 #endif
  65
  66 struct tcc_ep {
  67     unsigned char dir;      /* endpoint direction */
  68     volatile uint16_t  *ep; /* hw ep buffer */
  69     int id;       /* Endpoint id */
  70     int mask;     /* Endpoint bit mask */
  71     char *buf;    /* user buffer to store data */
  72     int max_len;  /* how match data will fit */
  73     int count;    /* actual data count */
  74     bool busy;
  75 } ;
  76
  77 static struct tcc_ep tcc_endpoints[] = {
  78     /* control */
  79     {
  80         .dir = -1,
  81         .ep = &TCC7xx_USB_EP0_BUF,
  82     }, {  /* bulk */
  83         .dir = -1,
  84         .ep = &TCC7xx_USB_EP1_BUF,
  85     }, { /* bulk */
  86         .dir = -1,
  87         .ep = &TCC7xx_USB_EP2_BUF,
  88     }, { /* interrupt */
  89         .dir = -1,
  90         .ep = &TCC7xx_USB_EP3_BUF,
  91     },
  92 } ;
  93
  94 static bool usb_drv_write_ep(struct tcc_ep *ep);
  95 static void usb_set_speed(int);
  96
  97 int usb_drv_request_endpoint(int type, int dir)
  98 {
  99     int flags = disable_irq_save();
 100     size_t ep;
 101     int ret = 0;
 102
 103     if (type != USB_ENDPOINT_XFER_BULK)
 104         return -1;
 105
 106     if (dir == USB_DIR_IN)
 107         ep = 1;
 108     else
 109         ep = 2;
 110
 111     if (!tcc_endpoints[ep].busy) {
 112         tcc_endpoints[ep].busy = true;
 113         tcc_endpoints[ep].dir = dir;
 114         ret = ep | dir;
 115     } else {
 116         ret = -1;
 117     }
 118
 119     restore_irq(flags);
 120     return ret;
 121 }
 122
 123 void usb_drv_release_endpoint(int ep)
 124 {
 125     int flags;
 126     ep = ep & 0x7f;
 127
 128     if (ep < 1 || ep > USB_NUM_ENDPOINTS)
 129         return ;
 130
 131     flags = disable_irq_save();
 132
 133     tcc_endpoints[ep].busy = false;
 134     tcc_endpoints[ep].dir = -1;
 135
 136     restore_irq(flags);
 137 }
 138
 139 static inline void pullup_on(void)
 140 {
 141     TCC7xx_USB_PHY_CFG = 0x000c;
 142 }
 143
 144 static inline void pullup_off(void)
 145 {
 146     TCC7xx_USB_PHY_CFG = 0x3e4c;
 147 }
 148
 149 #if 0
 150 static
 151 char *dump_data(char *data, int count)
 152 {
 153     static char buf[1024];
 154     char *dump = buf;
 155     int i;
 156
 157     for (i = 0; i < count; i++)
 158         dump += snprintf(dump, sizeof(buf) - (dump - buf), "%02x", data[i]);
 159     return buf;
 160 }
 161 #endif
 162
 163 static
 164 void handle_control(void)
 165 {
 166     /* control are always 8 bytes len */
 167     static unsigned char ep_control[8];
 168     struct usb_ctrlrequest *req =
 169         (struct usb_ctrlrequest *) ep_control;
 170     unsigned short stat;
 171     unsigned short count = 0;
 172     int i;
 173     int type;
 174
 175     /* select control endpoint */
 176     TCC7xx_USB_INDEX = 0x00;
 177     stat = TCC7xx_USB_EP0_STAT;
 178
 179     if (stat & 0x10) {
 180         DEBUG(2, "stall");
 181         TCC7xx_USB_EP0_STAT = 0x10;
 182     }
 183
 184     if (TCC7xx_USB_EP0_STAT & 0x01) { /* RX */
 185         uint16_t *ptr = (uint16_t *) ep_control;
 186
 187         count = TCC7xx_USB_EP_BRCR;
 188
 189         if (TCC7xx_USB_EP0_STAT & 0x2)
 190             TCC7xx_USB_EP0_STAT = 0x02;
 191
 192         if (count != 4) { /* bad control? */
 193             unsigned short dummy;
 194
 195             while (count--)
 196                 dummy = TCC7xx_USB_EP0_BUF;
 197                 DEBUG(1, "WTF: count = %d", count);
 198             } else {
 199                 /* simply read control packet */
 200                 for (i = 0; i < count; i++)
 201                     ptr[i] = TCC7xx_USB_EP0_BUF;
 202             }
 203
 204             count *= 2;
 205             TCC7xx_USB_EP0_STAT = 0x01;
 206             DEBUG(1, "CTRL: len = %d %04x", count, stat);
 207     } else if (TCC7xx_USB_EP0_STAT & 0x02) { /* TX */
 208         TCC7xx_USB_EP0_STAT = 0x02;
 209         DEBUG(2, "TX Done\n");
 210     } else {
 211         DEBUG(1, "stat: %04x", stat);
 212     }
 213
 214     TCC7xx_USB_EPIF = 1;
 215
 216     if (0 == (stat & 0x1) || count != 8)
 217         return ;
 218 #if 1 /* TODO: remove me someday */
 219     {
 220         int i;
 221         uint16_t *ptr = (uint16_t *) ep_control;
 222         for (i = 1; i < (count>>1); i++) {
 223             if (ptr[i] != ptr[0])
 224                 break;
 225         }
 226         if (i == (count>>1)) {
 227             /*DEBUG(2, */panicf_my("sanity failed");
 228             return ;
 229         }
 230     }
 231 #endif
 232     type = req->bRequestType;
 233
 234     /* TODO: don't pass some kinds of requests to upper level */
 235     switch (req->bRequest) {
 236     case USB_REQ_CLEAR_FEATURE:
 237         DEBUG(2, "USB_REQ_CLEAR_FEATURE");
 238         DEBUG(2, "...%04x %04x", req->wValue, req->wIndex);
 239         break;
 240     case USB_REQ_SET_ADDRESS:
 241         //DEBUG(2, "USB_REQ_SET_ADDRESS, %d %d", req->wValue, TCC7xx_USB_FUNC);
 242         /* seems we don't have to set it manually
 243            TCC7xx_USB_FUNC = req->wValue; */
 244         break;
 245     case USB_REQ_GET_DESCRIPTOR:
 246         DEBUG(2, "gd, %02x %02x", req->wValue, req->wIndex);
 247         break;
 248     case USB_REQ_GET_CONFIGURATION:
 249         DEBUG(2, "USB_REQ_GET_CONFIGURATION");
 250         break;
 251     default:
 252         DEBUG(2, "req: %02x %02d", req->bRequestType, req->bRequest);
 253     }
 254
 255     usb_core_control_request(req);
 256 }
 257
 258 static
 259 void handle_ep_in(struct tcc_ep *tcc_ep, uint16_t stat)
 260 {
 261     uint8_t *buf = tcc_ep->buf;
 262     uint16_t *wbuf = (uint16_t *) buf;
 263     int wcount;
 264     int count;
 265     int i;
 266
 267     if (tcc_ep->dir != USB_DIR_OUT) {
 268         panicf_my("ep%d: is input only", tcc_ep->id);
 269     }
 270
 271     wcount = TCC7xx_USB_EP_BRCR;
 272
 273     DEBUG(2, "ep%d: %04x %04x", tcc_ep->id, stat, wcount);
 274
 275     /* read data */
 276     count = wcount * 2;
 277     if (stat & TCC7xx_USP_EP_STAT_LWO) {
 278         count--;
 279         wcount--;
 280     }
 281
 282     if (buf == NULL)
 283         panicf_my("ep%d: Unexpected packet! %d %x", tcc_ep->id, count, TCC7xx_USB_EP_CTRL);
 284     if (tcc_ep->max_len < count)
 285         panicf_my("Too big packet: %d excepted %d %x", count, tcc_ep->max_len, TCC7xx_USB_EP_CTRL);
 286
 287     for (i = 0; i < wcount; i++)
 288         wbuf[i] = *tcc_ep->ep;
 289
 290     if (count & 1) { /* lwo */
 291         uint16_t tmp = *tcc_ep->ep;
 292         buf[count - 1] = tmp & 0xff;
 293     }
 294
 295     tcc_ep->buf = NULL;
 296
 297     TCC7xx_USB_EP_STAT = TCC7xx_USB_EP_STAT;
 298     TCC7xx_USB_EPIF = tcc_ep->mask;
 299     TCC7xx_USB_EPIE &= ~tcc_ep->mask; /* TODO: use INGLD? */
 300     global_ep_irq_mask &= ~tcc_ep->mask;
 301
 302     if (TCC7xx_USB_EP_STAT & 0x1)
 303         panicf_my("One more packet?");
 304
 305     TCC7xx_USB_EP_CTRL |= TCC7xx_USB_EP_CTRL_OUTHD;
 306
 307     usb_core_transfer_complete(tcc_ep->id, USB_DIR_OUT, 0, count);
 308 }
 309
 310 static
 311 void handle_ep_out(struct tcc_ep *tcc_ep, uint16_t stat)
 312 {
 313     bool done;
 314     (void) stat;
 315
 316     if (tcc_ep->dir != USB_DIR_IN) {
 317         panicf_my("ep%d: is out only", tcc_ep->id);
 318     }
 319
 320 //    if (tcc_ep->buf == NULL) {
 321 //        panicf_my("%s:%d", __FILE__, __LINE__);
 322 //    }
 323
 324     done = usb_drv_write_ep(tcc_ep);
 325
 326 //    TCC7xx_USB_EP_STAT = 0x2; /* Clear TX stat */
 327     TCC7xx_USB_EPIF = tcc_ep->mask;
 328
 329     if (done) { // tcc_ep->buf == NULL) {
 330         TCC7xx_USB_EPIE &= ~tcc_ep->mask;
 331         global_ep_irq_mask &= ~tcc_ep->mask;
 332
 333 //        usb_core_transfer_complete(tcc_ep->id, USB_DIR_IN, 0, tcc_ep->count);
 334     }
 335 }
 336
 337 static
 338 void handle_ep(unsigned short ep_irq)
 339 {
 340     if (ep_irq & 0x1) {
 341         handle_control();
 342     }
 343
 344     if (ep_irq & 0xe) {
 345         int endpoint;
 346
 347         for (endpoint = 1; endpoint < 4; endpoint++) {
 348             struct tcc_ep *tcc_ep = &tcc_endpoints[endpoint];
 349             uint16_t stat;
 350
 351             if (0 == (ep_irq & (1 << endpoint)))
 352                 continue;
 353             if (!tcc_ep->busy)
 354                 panicf_my("ep%d: wasn't requested", endpoint);
 355
 356             TCC7xx_USB_INDEX = endpoint;
 357             stat = TCC7xx_USB_EP_STAT;
 358
 359             DEBUG(1, "ep%d: %04x", endpoint, stat);
 360
 361             if (stat & 0x1)
 362                 handle_ep_in(tcc_ep, stat);
 363             else if (stat & 0x2)
 364                 handle_ep_out(tcc_ep, stat);
 365             else /* TODO: remove me? */
 366                 panicf_my("Unhandled ep%d state: %x, %d", endpoint, TCC7xx_USB_EP_STAT, TCC7xx_USB_INDEX);
 367         }
 368     }
 369 }
 370
 371 static void usb_set_speed(int high_speed)
 372 {
 373     TCC7xx_USB_EP_DIR = 0x0000;
 374
 375     /* control endpoint */
 376     TCC7xx_USB_INDEX = 0;
 377     TCC7xx_USB_EP0_CTRL = 0x0000;
 378     TCC7xx_USB_EP_MAXP = 64;
 379     TCC7xx_USB_EP_CTRL = TCC7xx_USB_EP_CTRL_CDP | TCC7xx_USB_EP_CTRL_FLUSH;
 380
 381     /* ep1: bulk-in, to host */
 382     TCC7xx_USB_INDEX = 1;
 383     TCC7xx_USB_EP_DIR |= (1 << 1);
 384     TCC7xx_USB_EP_CTRL = TCC7xx_USB_EP_CTRL_CDP;
 385
 386     if (high_speed)
 387         TCC7xx_USB_EP_MAXP = 512;
 388     else
 389         TCC7xx_USB_EP_MAXP = 64;
 390
 391     TCC7xx_USB_EP_DMA_CTRL = 0x0;
 392
 393     /* ep2: bulk-out, from host */
 394     TCC7xx_USB_INDEX = 2;
 395     TCC7xx_USB_EP_DIR &= ~(1 << 2);
 396     TCC7xx_USB_EP_CTRL = TCC7xx_USB_EP_CTRL_CDP;
 397
 398     if (high_speed)
 399         TCC7xx_USB_EP_MAXP = 512;
 400     else
 401         TCC7xx_USB_EP_MAXP = 64;
 402
 403     TCC7xx_USB_EP_DMA_CTRL = 0x0;
 404
 405     /* ep3: interrupt in */
 406     TCC7xx_USB_INDEX = 3;
 407     TCC7xx_USB_EP_DIR &= ~(1 << 3);
 408     TCC7xx_USB_EP_CTRL = TCC7xx_USB_EP_CTRL_CDP;
 409     TCC7xx_USB_EP_MAXP = 64;
 410
 411     TCC7xx_USB_EP_DMA_CTRL = 0x0;
 412 }
 413
 414 /*
 415   Reset TCC7xx usb device
 416  */
 417 static void usb_reset(void)
 418 {
 419     pullup_on();
 420
 421     TCC7xx_USB_DELAY_CTRL |= 0x81;
 422
 423     TCC7xx_USB_SYS_CTRL = 0xa000 |
 424         TCC7xx_USB_SYS_CTRL_RESET |
 425         TCC7xx_USB_SYS_CTRL_RFRE  |
 426         TCC7xx_USB_SYS_CTRL_SPDEN |
 427         TCC7xx_USB_SYS_CTRL_VBONE |
 428         TCC7xx_USB_SYS_CTRL_VBOFE;
 429
 430     usb_set_speed(1);
 431     pullup_on();
 432
 433     TCC7xx_USB_EPIF = TCC7xx_USB_EPIF_IRQ_MASK;
 434     global_ep_irq_mask = 0x1;
 435     TCC7xx_USB_EPIE = global_ep_irq_mask;
 436
 437     usb_core_bus_reset();
 438 }
 439
 440 /* IRQ handler */
 441 void USB_DEVICE(void)
 442 {
 443     unsigned short sys_stat;
 444     unsigned short ep_irq;
 445     unsigned short index_save;
 446
 447     sys_stat = TCC7xx_USB_SYS_STAT;
 448
 449     if (sys_stat & TCC7xx_USB_SYS_STAT_RESET) {
 450         TCC7xx_USB_SYS_STAT = TCC7xx_USB_SYS_STAT_RESET;
 451         usb_reset();
 452         TCC7xx_USB_SYS_CTRL |= TCC7xx_USB_SYS_CTRL_SUSPEND;
 453         DEBUG(2, "reset");
 454     }
 455
 456     if (sys_stat & TCC7xx_USB_SYS_STAT_RESUME) {
 457         TCC7xx_USB_SYS_STAT = TCC7xx_USB_SYS_STAT_RESUME;
 458         usb_reset();
 459         TCC7xx_USB_SYS_CTRL |= TCC7xx_USB_SYS_CTRL_SUSPEND;
 460         DEBUG(2, "resume");
 461     }
 462
 463     if (sys_stat & TCC7xx_USB_SYS_STAT_SPD_END) {
 464         usb_set_speed(1);
 465         TCC7xx_USB_SYS_STAT = TCC7xx_USB_SYS_STAT_SPD_END;
 466         DEBUG(2, "spd end");
 467     }
 468
 469     if (sys_stat & TCC7xx_USB_SYS_STAT_ERRORS) {
 470         DEBUG(2, "errors: %4x", sys_stat & TCC7xx_USB_SYS_STAT_ERRORS);
 471         TCC7xx_USB_SYS_STAT = sys_stat & TCC7xx_USB_SYS_STAT_ERRORS;
 472     }
 473
 474 //    TCC7xx_USB_SYS_STAT = sys_stat;
 475
 476     index_save = TCC7xx_USB_INDEX;
 477
 478     ep_irq = TCC7xx_USB_EPIF & global_ep_irq_mask;
 479
 480     while (ep_irq & TCC7xx_USB_EPIF_IRQ_MASK) {
 481         handle_ep(ep_irq);
 482
 483         /* is that really needed, btw not a problem for rockbox */
 484         udelay(50);
 485         ep_irq = TCC7xx_USB_EPIF & global_ep_irq_mask;
 486     }
 487
 488     TCC7xx_USB_INDEX = index_save;
 489 }
 490
 491 void usb_drv_set_address(int address)
 492 {
 493     (void) address;
 494     DEBUG(2, "setting address %d %d", address, TCC7xx_USB_FUNC);
 495 }
 496
 497 int usb_drv_port_speed(void)
 498 {
 499     return (TCC7xx_USB_SYS_STAT & 0x10) ? 1 : 0;
 500 }
 501
 502 static int usb_drv_write_packet(volatile unsigned short *buf, unsigned char *data, int len, int max)
 503 {
 504     uint16_t  *wbuf = (uint16_t *) data;
 505     int count, i;
 506
 507     len = MIN(len, max);
 508     count = (len + 1) / 2;
 509
 510     TCC7xx_USB_EP_BWCR = len;
 511
 512     for (i = 0; i < count; i++)
 513         *buf = *wbuf++;
 514
 515     return len;
 516 }
 517
 518 static bool usb_drv_write_ep(struct tcc_ep *ep)
 519 {
 520     int count;
 521
 522     if (ep->max_len == 0)
 523         return true;
 524
 525     count = usb_drv_write_packet(ep->ep, ep->buf, ep->max_len, 512);
 526     TCC7xx_USB_EP_STAT = 0x2; /* Clear TX stat */
 527
 528     ep->buf += count;
 529     ep->count += count;
 530     ep->max_len -= count;
 531
 532     if (ep->max_len == 0) {
 533         usb_core_transfer_complete(ep->id, USB_DIR_IN, 0, ep->count);
 534         ep->buf = NULL;
 535 //        return true;
 536     }
 537
 538     return false;
 539 }
 540
 541 int usb_drv_send(int endpoint, void *ptr, int length)
 542 {
 543     int flags = disable_irq_save();
 544     int rc = 0;
 545     char *data = (unsigned char*) ptr;
 546
 547     DEBUG(2, "%s(%d,%d)" , __func__, endpoint, length);
 548
 549     if (endpoint != 0)
 550         panicf_my("%s(%d,%d)", __func__, endpoint, length);
 551
 552     TCC7xx_USB_INDEX = 0;
 553     while (length > 0) {
 554         int ret;
 555
 556         ret = usb_drv_write_packet(&TCC7xx_USB_EP0_BUF, data, length, 64);
 557         length -= ret;
 558         data += ret;
 559
 560         while (0 == (TCC7xx_USB_EP0_STAT & 0x2))
 561             ;
 562         TCC7xx_USB_EP0_STAT = 0x2;
 563     }
 564
 565     restore_irq(flags);
 566     return rc;
 567 }
 568
 569
 570 int usb_drv_send_nonblocking(int endpoint, void *ptr, int length)
 571 {
 572     int flags;
 573     int rc = 0, count = length;
 574     char *data = (unsigned char*) ptr;
 575     struct tcc_ep *ep = &tcc_endpoints[endpoint & 0x7f];
 576
 577     if (ep->dir != USB_DIR_IN || length == 0)
 578         panicf_my("%s(%d,%d): Not supported", __func__, endpoint, length);
 579
 580     DEBUG(2, "%s(%d,%d):", __func__, endpoint, length);
 581
 582     flags = disable_irq_save();
 583
 584     if(ep->buf != NULL) {
 585         panicf_my("%s: ep is already busy", __func__);
 586     }
 587
 588     ep->buf = data;
 589     ep->max_len = length;
 590     ep->count = count;
 591
 592     TCC7xx_USB_INDEX = ep->id;
 593 #if 1
 594     TCC7xx_USB_EP_STAT = 0x2;
 595     /* TODO: use interrupts instead */
 596     while (!usb_drv_write_ep(ep)) {
 597         while (0==(TCC7xx_USB_EP_STAT & 0x2))
 598             ;
 599     }
 600 #else
 601     if (!usb_drv_write_ep(ep)) {
 602         TCC7xx_USB_EPIE |= ep->mask;
 603         global_ep_irq_mask |= ep->mask;
 604     }
 605 #endif
 606     restore_irq(flags);
 607
 608     DEBUG(2, "%s end", __func__);
 609
 610     return rc;
 611 }
 612
 613 int usb_drv_recv(int endpoint, void* ptr, int length)
 614 {
 615     volatile struct tcc_ep *tcc_ep = &tcc_endpoints[endpoint & 0x7f];
 616     int flags;
 617
 618     if (length == 0) {
 619         if (endpoint != 0)
 620             panicf_my("%s(%d,%d) zero length?", __func__, endpoint, length);
 621         return 0;
 622     }
 623     // TODO: check ep
 624     if (tcc_ep->dir != USB_DIR_OUT)
 625         panicf_my("%s(%d,%d)", __func__, endpoint, length);
 626
 627     DEBUG(2, "%s(%d,%d)", __func__, endpoint, length);
 628
 629     flags = disable_irq_save();
 630
 631     if (tcc_ep->buf) {
 632         panicf_my("%s: overrun: %x %x", __func__,
 633                   (unsigned int)tcc_ep->buf, (unsigned int)tcc_ep);
 634     }
 635
 636     tcc_ep->buf = ptr;
 637     tcc_ep->max_len = length;
 638     tcc_ep->count = 0;
 639
 640     TCC7xx_USB_INDEX = tcc_ep->id;
 641
 642     TCC7xx_USB_EP_CTRL &= ~TCC7xx_USB_EP_CTRL_OUTHD;
 643     TCC7xx_USB_EPIE |= tcc_ep->mask;
 644     global_ep_irq_mask |= tcc_ep->mask;
 645
 646     restore_irq(flags);
 647
 648     return 0;
 649 }
 650
 651 void usb_drv_cancel_all_transfers(void)
 652 {
 653     int endpoint;
 654     int flags;
 655
 656     DEBUG(2, "%s", __func__);
 657
 658     flags = disable_irq_save();
 659     for (endpoint = 0; endpoint < 4; endpoint++) {
 660         if (tcc_endpoints[endpoint].buf) {
 661 /*            usb_core_transfer_complete(tcc_endpoints[endpoint].id,
 662                                         tcc_endpoints[endpoint].dir, -1, 0); */
 663             tcc_endpoints[endpoint].buf = NULL;
 664         }
 665     }
 666
 667     global_ep_irq_mask = 1;
 668     TCC7xx_USB_EPIE = global_ep_irq_mask;
 669     TCC7xx_USB_EPIF = TCC7xx_USB_EPIF_IRQ_MASK;
 670     restore_irq(flags);
 671 }
 672
 673 void usb_drv_set_test_mode(int mode)
 674 {
 675     panicf_my("%s(%d)", __func__, mode);
 676 }
 677
 678 bool usb_drv_stalled(int endpoint, bool in)
 679 {
 680     panicf_my("%s(%d,%d)", __func__, endpoint, in);
 681     return false;
 682 }
 683
 684 void usb_drv_stall(int endpoint, bool stall,bool in)
 685 {
 686     (void) endpoint;
 687     (void) stall;
 688     (void) in;
 689     printf("%s(%d,%d,%d)", __func__, endpoint, stall, in);
 690 }
 691
 692 void usb_drv_init(void)
 693 {
 694     size_t i;
 695
 696     DEBUG(2, "%s", __func__);
 697
 698     for (i = 0; i < sizeof(tcc_endpoints)/sizeof(struct tcc_ep); i++) {
 699         tcc_endpoints[i].id = i;
 700         tcc_endpoints[i].mask = 1 << i;
 701         tcc_endpoints[i].buf = NULL;
 702         tcc_endpoints[i].busy = false;
 703         tcc_endpoints[i].dir = -1;
 704     }
 705
 706     /* Enable USB clock */
 707     BCLKCTR |= DEV_USBD;
 708
 709     /* switch USB to host and then reset */
 710     TCC7xx_USB_PHY_CFG = 0x3e4c;
 711     SWRESET |= DEV_USBD;
 712     udelay(50);
 713     SWRESET &= ~DEV_USBD;
 714
 715     usb_reset();
 716
 717     /* unmask irq */
 718     CREQ = USBD_IRQ_MASK;
 719     IRQSEL |= USBD_IRQ_MASK;
 720     TMODE &= ~USBD_IRQ_MASK;
 721     IEN |= USBD_IRQ_MASK;
 722 }
 723
 724 void usb_drv_exit(void)
 725 {
 726     TCC7xx_USB_EPIE = 0;
 727     BCLKCTR &= ~DEV_USBD;
 728
 729     SWRESET |= DEV_USBD;
 730     udelay(50);
 731     SWRESET &= ~DEV_USBD;
 732
 733     pullup_off();
 734 }
 735
 736 void usb_init_device(void)
 737 {
 738 }
 739
 740 void usb_enable(bool on)
 741 {
 742     if (on)
 743         usb_core_init();
 744     else
 745         usb_core_exit();
 746 }
 747
 748 void usb_attach(void)
 749 {
 750    usb_enable(true);
 751 }
 752
 753 int usb_detect(void)
 754 {
 755     /* TODO: not correct for all targets, we should poll VBUS
 756        signal on USB bus. */
 757     if (charger_inserted())
 758         return USB_INSERTED;
 759     return USB_EXTRACTED;
 760 }
 761
 762 #ifdef BOOTLOADER
 763 #include "ata.h"
 764 void usb_test(void)
 765 {
 766     int rc;
 767
 768     printf("ATA");
 769     rc = ata_init();
 770
 771     if(rc) {
 772         panicf("ata_init failed");
 773     }
 774
 775     usb_init();
 776     usb_start_monitoring();
 777     usb_acknowledge(SYS_USB_CONNECTED_ACK);
 778
 779     while (1) {
 780         sleep(HZ);
 781 //        usb_serial_send("Hello\r\n", 7);
 782     }
 783 }
 784 #endif
 785 #else
 786 void usb_init_device(void)
 787 {
 788     /* simply switch USB off for now */
 789     BCLKCTR |= DEV_USBD;
 790     TCC7xx_USB_PHY_CFG = 0x3e4c;
 791     BCLKCTR &= ~DEV_USBD;
 792 }
 793
 794 void usb_enable(bool on)
 795 {
 796     (void)on;
 797 }
 798
 799 /* Always return false for now */
 800 int usb_detect(void)
 801 {
 802     return USB_EXTRACTED;
 803 }
 804 #endif