firmware/drivers/m66591.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2009 by Karl Kurbjun
  11  * Portions Copyright (C) 2007 by Catalin Patulea
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22 #define LOGF_ENABLE
  23
  24 #include "system.h"
  25 #include "config.h"
  26 #include "string.h"
  27 #include "usb_ch9.h"
  28 #include "usb_core.h"
  29 #include "kernel.h"
  30 #include "panic.h"
  31 #include "usb_drv.h"
  32 #include "logf.h"
  33
  34 #include "config.h"
  35 #include "cpu.h"
  36 #include "ata.h"
  37 #include "usb.h"
  38 #include "usb-target.h"
  39 #include "m66591.h"
  40
  41 /*******************************************************************************
  42  *  These are the driver specific defines.
  43  ******************************************************************************/
  44 #define HISPEED
  45
  46 /* Right now sending blocks till the full transfer has completed, this needs to
  47  *  be fixed so that it does not require a block. (USB_TRAN_LOCK ideally would
  48  *  not be set).
  49  */
  50 #define USB_TRAN_BLOCK
  51
  52 /*******************************************************************************
  53  * The following functions are all helpers which should not be called directly
  54  *  from the USB stack.  They should only be called by eachother, or the USB
  55  *  stack visible functions.
  56  ******************************************************************************/
  57
  58 static volatile unsigned short * pipe_ctrl_addr(int pipe);
  59 static void pipe_handshake(int pipe, int handshake);
  60 static void pipe_c_select (int pipe, bool dir);
  61 #if !defined(USB_TRAN_BLOCK)
  62 static int pipe_buffer_size (int pipe);
  63 #endif
  64 static int pipe_maxpack_size (int pipe);
  65 static void control_received(void);
  66 static void transfer_complete(int endpoint);
  67 static int mxx_transmit_receive(int endpoint);
  68 static int mxx_queue(int endpoint, void * ptr, int length, bool send);
  69
  70 struct M66591_epstat {
  71     unsigned char dir;      /* endpoint direction */
  72     char *buf;              /* user buffer to store data */
  73     int length;             /* how match data will fit */
  74     volatile int count;     /* actual data count */
  75     bool waiting;           /* is there data to transfer? */
  76     bool busy;              /* has the pipe been requested for use? */
  77 } ;
  78
  79 static struct M66591_epstat M66591_eps[USB_NUM_ENDPOINTS];
  80
  81 /* This function is used to return the control address for each pipe */
  82 static volatile unsigned short * pipe_ctrl_addr(int pipe) {
  83     if(pipe==0) {
  84         return &M66591_DCPCTRL;
  85     } else {
  86         return &M66591_PIPECTRL1 + (pipe-1);
  87     }
  88 }
  89
  90 /* This function sets the pipe/endpoint handshake */
  91 static void pipe_handshake(int pipe, int handshake) {
  92     handshake&=0x03;
  93
  94     if(handshake == PIPE_SHAKE_STALL) {
  95         if( *(pipe_ctrl_addr(pipe)) & 0x03 ) {
  96             *(pipe_ctrl_addr(pipe)) = 0x03;
  97         } else {
  98             *(pipe_ctrl_addr(pipe)) = 0x02;
  99         }
 100     } else {
 101         *(pipe_ctrl_addr(pipe)) = handshake;
 102     }
 103 }
 104
 105 /* This function chooses the pipe desired and waits the required time before
 106  *  warites/reads are valid */
 107 static void pipe_c_select (int pipe, bool dir) {
 108     M66591_CPORT_CTRL0 = pipe | (1<<10) | (dir<<5);
 109
 110     // Wait for the Pipe to be valid;
 111     udelay(2);
 112 }
 113
 114 #if !defined(USB_TRAN_BLOCK)
 115 /* This returns the maximum buffer size of each pipe.  On this device the size
 116  *  is fixed.
 117  */
 118 static int pipe_buffer_size (int pipe) {
 119     switch(pipe) {
 120     case 0:
 121         return 256;
 122     case 1:
 123     case 2:
 124         return 1024;
 125     case 3:
 126     case 4:
 127         return 512;
 128     case 5:
 129     case 6:
 130         return 64;
 131     default:
 132         return 0;
 133     }
 134 }
 135 #endif
 136
 137 /* This function returns the maximum packet size for each endpoint/pipe.  It is
 138  *  Currently only setup to support Highspeed mode.
 139  */
 140 static int pipe_maxpack_size (int pipe) {
 141     switch(pipe) {
 142     case 0:
 143         /* DCP max packet size is configurable */
 144         return M66591_DCP_MXPKSZ;
 145     case 1:
 146     case 2:
 147     case 3:
 148     case 4:
 149         return 512;
 150     case 5:
 151     case 6:
 152         return 64;
 153     default:
 154         return 0;
 155     }
 156 }
 157
 158 /* This is a helper function that is only called from the interupt handler.  It
 159  *  copies the control packet information from the PHY and notifies the stack.
 160  */
 161 static void control_received(void) {
 162     /* copy setup data from packet */
 163     static struct usb_ctrlrequest temp;
 164
 165     memcpy(&temp, (unsigned char*)&M66591_USB_REQ0, 8);
 166
 167     logf("mxx: bReqType=0x%02x bReq=0x%02x wVal=0x%04x"
 168         " wIdx=0x%04x wLen=0x%04x",
 169         temp.bRequestType, temp.bRequest, temp.wValue,
 170         temp.wIndex, temp.wLength);
 171
 172     /* acknowledge packet recieved (clear valid) */
 173     M66591_INTSTAT_MAIN &= ~(1<<3);
 174
 175     usb_core_control_request(&temp);
 176 }
 177
 178 /* This is a helper function, it is used to notife the stack that a transfer is
 179  *  done.
 180  */
 181 static void transfer_complete(int endpoint) {
 182     M66591_INTCFG_EMP &= ~(1 << endpoint);
 183     logf("mxx: ep %d transfer complete", endpoint);
 184     int temp=M66591_eps[endpoint].dir ? USB_DIR_IN : USB_DIR_OUT;
 185     usb_core_transfer_complete(endpoint, temp, 0,
 186         M66591_eps[endpoint].length);
 187 }
 188
 189 /* This is the main transmit routine that is typically called from the interrupt
 190  *  handler (the queue function calls it in some situations)
 191  */
 192 static int mxx_transmit_receive(int endpoint) {
 193     logf("mxx: do start");
 194
 195     /* Only the lower 15 bits of the endpoint correlate to the pipe number.
 196      *  For example pipe 2 will corelate to endpoint 0x82, so the upper bits
 197      * need to be masked out.
 198      */
 199     endpoint &= 0x7F;
 200
 201     int i;      /* Used as a loop counter */
 202     int length; /* Used in transfers to determine the amount to send/receive */
 203
 204     bool send=M66591_eps[endpoint].dir;
 205
 206     /* This is used as the internal buffer pointer */
 207     unsigned short *ptrs;
 208
 209     /* Choose the pipe that data is being transfered on */
 210     pipe_c_select(endpoint, send);
 211
 212     /* Check to see if the endpoint is ready and give it some time to become
 213      *  ready.  If it runs out of time exit out as an error.
 214      */
 215     i = 0;
 216     while (!(M66591_CPORT_CTRL1&(1<<13))) {
 217         if (i++ > 100000) {
 218             logf("mxx: FIFO %d not ready", endpoint);
 219             return -1;
 220         }
 221     }
 222
 223     /* Write to FIFO */
 224     if(send) {
 225         int maxpack=pipe_maxpack_size(endpoint);
 226 #if defined(USB_TRAN_BLOCK)
 227         length = M66591_eps[endpoint].length;
 228 #else
 229         int bufsize=pipe_buffer_size(endpoint);
 230         length=MIN(M66591_eps[endpoint].length, bufsize);
 231 #endif
 232
 233         /* Calculate the position in the buffer, all transfers should be 2-byte
 234          *  aligned till the last packet or short packet.
 235          */
 236         ptrs = (unsigned short *)(M66591_eps[endpoint].buf
 237             + M66591_eps[endpoint].count);
 238
 239         /* Start sending data in 16-bit words */
 240         for (i = 0; i < (length>>1); i++) {
 241             /* This wait is dangerous in the event htat something happens to
 242              *  the PHY pipe where it never becomes ready again, should probably
 243              *  add a timeout, and ideally completely remove.
 244              */
 245             while(!(M66591_CPORT_CTRL1&(1<<13))){};
 246
 247             M66591_CPORT = *ptrs++;
 248             M66591_eps[endpoint].count+=2;
 249         }
 250
 251         /* If the length is odd, send the last byte after setting the byte width
 252          *  of the FIFO.
 253          */
 254         if(length & 0x01) {
 255             /* Unset MBW (8-bit transfer) */
 256             M66591_CPORT_CTRL0 &= ~(1<<10);
 257             M66591_CPORT = *((unsigned char *)ptrs - 1);
 258             M66591_eps[endpoint].count++;
 259         }
 260
 261         /* Set BVAL if length is not a multiple of the maximum packet size */
 262         if( (length == 0) || (length % maxpack != 0) ) {
 263             logf("mxx: do set BVAL");
 264             M66591_CPORT_CTRL1 |= (1<<15);
 265         }
 266
 267         /* If the transfer is complete set up interrupts to notify when FIFO is
 268          *  EMPTY, disable READY and let the handler know that there is nothing
 269          *  left to transfer on this pipe.
 270          */
 271         if(M66591_eps[endpoint].count == M66591_eps[endpoint].length) {
 272             /* Enable Empty flag */
 273             M66591_INTCFG_EMP |= 1 << endpoint;
 274             /* Disable ready flag */
 275             M66591_INTCFG_RDY &= ~(1 << endpoint);
 276             /* Nothing left to transfer */
 277             M66591_eps[endpoint].waiting=false;
 278         } else {
 279             /* There is still data to transfer, make sure READY is enabled */
 280             M66591_INTCFG_RDY |= 1 << endpoint;
 281         }
 282     } else {
 283         /* Read data from FIFO */
 284
 285         /* Read the number of bytes that the PHY received */
 286         int receive_length=M66591_CPORT_CTRL1 & 0x03FF;
 287
 288         /* The number of bytes to actually read is either what's left of the
 289          *  amount requested, or the amount that the PHY received.  Choose the
 290          *  smaller of the two.
 291          */
 292         length = MIN(M66591_eps[endpoint].length - M66591_eps[endpoint].count,
 293             receive_length);
 294
 295         /* If the length is zero, just clear the buffer as specified in the
 296          *  datasheet.  Otherwise read in the data (in 16-bit pieces */
 297         if(length==0) {
 298             /* Set the BCLR bit */
 299             M66591_CPORT_CTRL1 |= 1<<14;
 300         } else {
 301             /* Set the position in the buffer */
 302             ptrs = (unsigned short *)(M66591_eps[endpoint].buf
 303                 + M66591_eps[endpoint].count);
 304
 305             /* Read in the data (buffer size should be even).  The PHY cannot
 306              *  switch from 16-bit mode to 8-bit mode on an OUT buffer.
 307              */
 308             for (i = 0; i < ((length+1)>>1); i++) {
 309                 *ptrs++ = M66591_CPORT;
 310                 M66591_eps[endpoint].count+=2;
 311             }
 312         }
 313
 314         /* If the length was odd subtract 1 from the count */
 315         M66591_eps[endpoint].count -= (length&0x01);
 316
 317         /* If the requested size of data was received, or the data received was
 318          *  less than the maximum packet size end the transfer.
 319          */
 320         if( (M66591_eps[endpoint].count == M66591_eps[endpoint].length)
 321             || (length % pipe_maxpack_size(endpoint)) ) {
 322
 323             /* If the host tries to send anything else the FIFO is not ready/
 324              *  enabled yet (NAK).
 325              */
 326             pipe_handshake(endpoint, PIPE_SHAKE_NAK);
 327             /* Tell the interrupt handler that transfer is complete. */
 328             M66591_eps[endpoint].waiting=false;
 329             /* Disable ready */
 330             M66591_INTCFG_RDY &= ~(1 << endpoint);
 331
 332             /* Let the stack know that the transfer is complete */
 333             if(endpoint!=0)
 334                 transfer_complete(endpoint);
 335         }
 336     }
 337
 338     logf("mxx: do done ep %d %s len: %d cnt: %d", endpoint,
 339         send ? "out" : "in", length, M66591_eps[endpoint].count);
 340
 341     return 0;
 342 }
 343
 344 /* This function is used to start transfers.  It is a helper function for the
 345  *  usb_drv_send_nonblocking, usb_drv_send, and usb_drv_receive functions.
 346  */
 347 static int mxx_queue(int endpoint, void * ptr, int length, bool send) {
 348     /* Disable IRQs */
 349     int flags = disable_irq_save();
 350
 351     /* Only the lower 15 bits of the endpoint correlate to the pipe number.
 352      *  For example pipe 2 will corelate to endpoint 0x82, so the upper bits
 353      *  need to be masked out.
 354      */
 355     endpoint &= 0x7F;
 356
 357     /* Initialize the enpoint status registers used for the transfer */
 358     M66591_eps[endpoint].buf=ptr;
 359     M66591_eps[endpoint].length=length;
 360     M66591_eps[endpoint].count=0;
 361     M66591_eps[endpoint].dir=send;
 362     M66591_eps[endpoint].waiting=true;
 363
 364     logf("mxx: queue ep %d %s, len: %d", endpoint, send ? "out" : "in", length);
 365
 366     /* Pick the pipe that communications are happening on */
 367     pipe_c_select(endpoint, send);
 368
 369     /* All transfers start with a BUF handshake */
 370     pipe_handshake(endpoint, PIPE_SHAKE_BUF);
 371
 372     /* This USB PHY takes care of control completion packets by setting the
 373      *  CCPL bit in EP0 (endpoint 0, or DCP).  If the control state is "write no
 374      *  data tranfer" then we just need to set the CCPL bit (hopefully)
 375      *  regardless of what the stack said to send.
 376      */
 377     int control_state = (M66591_INTSTAT_MAIN & 0x07);
 378     if(endpoint==0 && control_state==CTRL_WTND) {
 379         logf("mxx: queue ep 0 ctls: 5, set ccpl");
 380
 381         /* Set CCPL */
 382         M66591_DCPCTRL |= 1<<2;
 383     } else {
 384         /* This is the standard case for transmitting data */
 385         if(send) {
 386             /* If the pipe is not ready don't try and send right away; instead
 387              *  just set the READY interrupt so that the handler can initiate
 388              *  the transfer.
 389              */
 390             if((M66591_CPORT_CTRL1&(1<<13))) {
 391                 mxx_transmit_receive(endpoint);
 392             } else {
 393                 M66591_INTCFG_RDY |= 1 << endpoint;
 394             }
 395
 396             if(length==0) {
 397                 transfer_complete(endpoint);
 398             }
 399         } else {
 400             /* When receiving data, just enable the ready interrupt, the PHY
 401              *  will trigger it and then the reads can start.
 402              */
 403             M66591_INTCFG_RDY |= 1 << endpoint;
 404         }
 405     }
 406
 407     /* Re-enable IRQs */
 408     restore_irq(flags);
 409     return 0;
 410 }
 411
 412 /*******************************************************************************
 413  * This is the interrupt handler for this driver.  It should be called from the
 414  *  target interrupt handler routine (eg. GPIO3 on M:Robe 500).
 415  ******************************************************************************/
 416 void USB_DEVICE(void) {
 417     int pipe_restore=M66591_CPORT_CTRL0;
 418     logf("mxx: INT BEGIN tick: %d\n", (int) current_tick);
 419
 420     logf("mxx: sMAIN0: 0x%04x, sRDY: 0x%04x",
 421         M66591_INTSTAT_MAIN, M66591_INTSTAT_RDY);
 422     logf("mxx:  sNRDY: 0x%04x, sEMP: 0x%04x",
 423         M66591_INTSTAT_NRDY, M66591_INTSTAT_EMP);
 424
 425     /* VBUS (connected) interrupt */
 426     while ( M66591_INTSTAT_MAIN & (1<<15) ) {
 427         M66591_INTSTAT_MAIN &= ~(1<<15);
 428
 429         /* If device is not clocked, interrupt flag must be set manually */
 430         if ( !(M66591_TRN_CTRL & (1<<10)) ) {
 431             M66591_INTSTAT_MAIN |= (1<<15);
 432         }
 433     }
 434
 435     /* Resume interrupt: This is not used. Extra logic needs to be added similar
 436     *  to the VBUS interrupt incase the PHY clock is not running.
 437     */
 438     if(M66591_INTSTAT_MAIN & (1<<14)) {
 439         M66591_INTSTAT_MAIN &= ~(1<<14);
 440         logf("mxx: RESUME");
 441     }
 442
 443     /* Device state transition interrupt: Not used, but useful for debugging */
 444     if(M66591_INTSTAT_MAIN & (1<<12)) {
 445         M66591_INTSTAT_MAIN &= ~(1<<12);
 446         logf("mxx: DEV state CHANGE=%d",
 447         ((M66591_INTSTAT_MAIN & (0x07<<4)) >> 4) );
 448     }
 449
 450     /* Control transfer stage interrupt */
 451     if(M66591_INTSTAT_MAIN & (1<<11)) {
 452         M66591_INTSTAT_MAIN &= ~(1<<11);
 453         int control_state = (M66591_INTSTAT_MAIN & 0x07);
 454
 455         logf("mxx: CTRT with CTSQ=%d", control_state);
 456
 457         switch ( control_state ) {
 458         case CTRL_IDLE:
 459             transfer_complete(0);
 460             break;
 461         case CTRL_RTDS:
 462         case CTRL_WTDS:
 463         case CTRL_WTND:
 464             // If data is not valid stop
 465                 if(!(M66591_INTSTAT_MAIN & (1<<3)) ) {
 466                     logf("mxx: CTRT interrupt but VALID is false");
 467                     break;
 468             }
 469             control_received();
 470             break;
 471         case CTRL_RTSS:
 472         case CTRL_WTSS:
 473             pipe_handshake(0, PIPE_SHAKE_BUF);
 474             M66591_DCPCTRL |= 1<<2; // Set CCPL
 475             break;
 476         default:
 477             logf("mxx: CTRT with unknown CTSQ");
 478             break;
 479         }
 480     }
 481
 482     /* FIFO EMPTY interrupt: when this happens the transfer should be complete.
 483      *  When the interrupt occurs notify the stack.
 484      */
 485     if(M66591_INTSTAT_MAIN & (1<<10)) {
 486         int i;
 487         logf("mxx: INT EMPTY: 0x%04x", M66591_INTSTAT_EMP);
 488
 489         for(i=0; i<USB_NUM_ENDPOINTS; i++) {
 490             if(M66591_INTSTAT_EMP&(1<<i)) {
 491                 /* Clear the empty flag */
 492                 M66591_INTSTAT_EMP=~(1<<i);
 493                 /* Notify the stack */
 494                 transfer_complete(i);
 495             }
 496         }
 497     }
 498
 499     /* FIFO NOT READY interrupt: This is not used, but included incase the
 500      *  interrupt is endabled.
 501      */
 502     if(M66591_INTSTAT_MAIN & (1<<9)) {
 503         logf("mxx: INT NOT READY: 0x%04x", M66591_INTSTAT_NRDY);
 504         M66591_INTSTAT_NRDY = 0;
 505     }
 506
 507     /* FIFO READY interrupt: This just initiates transfers if they are needed */
 508     if(M66591_INTSTAT_MAIN & (1<<8)) {
 509         int i;
 510         logf("mxx: INT READY: 0x%04x", M66591_INTSTAT_RDY);
 511
 512         for(i=0; i<USB_NUM_ENDPOINTS; i++) {
 513             /* Was this endpoint ready and waiting */
 514             if(M66591_INTSTAT_RDY&(1<<i) && M66591_eps[i].waiting) {
 515                 /* Clear the ready flag */
 516                 M66591_INTSTAT_RDY=~(1<<i);
 517                 /* It was ready and waiting so start a transfer */
 518                 mxx_transmit_receive(i);
 519             }
 520         }
 521     }
 522
 523     /* Make sure that the INTStatus register is completely cleared. */
 524     M66591_INTSTAT_MAIN = 0;
 525
 526     /* Restore the pipe state before the interrupt occured */
 527     M66591_CPORT_CTRL0=pipe_restore;
 528     logf("\nmxx: INT END");
 529 }
 530
 531 /*******************************************************************************
 532  *  The following functions are all called by and visible to the USB stack.
 533  ******************************************************************************/
 534
 535 /* The M55691 handles this automatically, nothing to do */
 536 void usb_drv_set_address(int address) {
 537     (void) address;
 538 }
 539
 540 /* This function sets the standard test modes, it is not required, but might as
 541  *  well implement it since the hardware supports it
 542  */
 543 void usb_drv_set_test_mode(int mode) {
 544     /* This sets the test bits and assumes that mode is from 0 to 0x04 */
 545     M66591_TESTMODE &= 0x0007;
 546     M66591_TESTMODE |= mode;
 547 }
 548
 549 /* Request an unused endpoint, support for interrupt endpoints needs addition */
 550 int usb_drv_request_endpoint(int type, int dir) {
 551     int ep;
 552     int pipecfg = 0;
 553
 554     if (type != USB_ENDPOINT_XFER_BULK)
 555         return -1;
 556
 557     /* The endpoint/pipes are hard coded: This could be more flexible */
 558     if (dir == USB_DIR_IN) {
 559         pipecfg |= (1<<4);
 560         ep = 2;
 561     } else {
 562         ep = 1;
 563     }
 564
 565     if (!M66591_eps[ep].busy) {
 566         M66591_eps[ep].busy = true;
 567         M66591_eps[ep].dir = dir;
 568     } else {
 569         logf("mxx: ep %d busy", ep);
 570         return -1;
 571     }
 572
 573     M66591_PIPE_CFGSEL=ep;
 574
 575     pipecfg |= 1<<15 | 1<<9 | 1<<8;
 576
 577     pipe_handshake(ep, PIPE_SHAKE_NAK);
 578
 579     // Setup the flags
 580     M66591_PIPE_CFGWND=pipecfg;
 581
 582     logf("mxx: ep req ep#: %d config: 0x%04x", ep, M66591_PIPE_CFGWND);
 583
 584     return ep | dir;
 585 }
 586
 587 /* Used by stack to tell the helper functions that the pipe is not in use */
 588 void usb_drv_release_endpoint(int ep) {
 589     int flags;
 590     ep &= 0x7f;
 591
 592     if (ep < 1 || ep > USB_NUM_ENDPOINTS || M66591_eps[ep].busy == false)
 593         return ;
 594
 595     flags = disable_irq_save();
 596
 597     logf("mxx: ep %d release", ep);
 598
 599     M66591_eps[ep].busy = false;
 600     M66591_eps[ep].dir = -1;
 601
 602     restore_irq(flags);
 603 }
 604
 605 /* Periodically called to check if a cable was plugged into the device */
 606 inline int usb_detect(void)
 607 {
 608     if(M66591_INTSTAT_MAIN&(1<<7))
 609         return USB_INSERTED;
 610     else
 611         return USB_EXTRACTED;
 612 }
 613
 614 void usb_enable(bool on) {
 615     logf("mxx: %s: %s", __FUNCTION__, on ? "true" : "false");
 616     if (on)
 617         usb_core_init();
 618     else
 619         usb_core_exit();
 620 }
 621
 622 /* This is where the driver stuff starts */
 623 void usb_drv_init(void) {
 624     logf("mxx: Device Init");
 625
 626     /* State left behind by m:robe 500i original firmware */
 627     M66591_TRN_CTRL         = 0x8001; /* External 48 MHz clock */
 628     M66591_TRN_LNSTAT       = 0x0040; /* "Reserved. Set it to '1'." */
 629
 630     M66591_PIN_CFG0         = 0x0000;
 631     M66591_PIN_CFG1         = 0x8000; /* Drive Current: 3.3V setting */
 632     M66591_PIN_CFG2         = 0x0000;
 633
 634     M66591_INTCFG_MAIN      = 0x0000; /* All Interrupts Disable for now */
 635     M66591_INTCFG_OUT       = 0x0000; /* Sense is edge, polarity is low */
 636     M66591_INTCFG_RDY       = 0x0000;
 637     M66591_INTCFG_NRDY      = 0x0000;
 638     M66591_INTCFG_EMP       = 0x0000;
 639
 640     M66591_INTSTAT_MAIN     = 0;
 641     M66591_INTSTAT_RDY      = 0;
 642     M66591_INTSTAT_NRDY     = 0;
 643     M66591_INTSTAT_EMP      = 0;
 644 }
 645
 646 /* fully enable driver */
 647 void usb_attach(void) {
 648     int i;
 649
 650     /* Reset Endpoint states */
 651     for(i=0; i<USB_NUM_ENDPOINTS; i++) {
 652         M66591_eps[i].dir = -1;
 653         M66591_eps[i].buf = (char *) 0;
 654         M66591_eps[i].length = 0;
 655         M66591_eps[i].count = 0;
 656         M66591_eps[i].waiting = false;
 657         M66591_eps[i].busy = false;
 658     }
 659
 660     /* Issue a h/w reset */
 661     usb_init_device();
 662     usb_drv_init();
 663
 664     /* USB Attach Process: This follows the flow diagram in the M66591GP
 665      *  Reference Manual Rev 1.00, p. 77 */
 666
 667 #if defined(HISPEED)
 668     /* Run Hi-Speed */
 669     M66591_TRN_CTRL |= 1<<7;
 670 #else
 671     /* Run Full-Speed */
 672     M66591_TRN_CTRL &= ~(1<<7);
 673 #endif
 674
 675     /* Enable oscillation buffer */
 676         M66591_TRN_CTRL |= (1<<13);
 677
 678     udelay(1500);
 679
 680     /* Enable reference clock, PLL */
 681     M66591_TRN_CTRL |= (3<<11);
 682
 683     udelay(9);
 684
 685     /* Enable internal clock supply */
 686     M66591_TRN_CTRL |= (1<<10);
 687
 688     /* Disable PIPE ready interrupts */
 689     M66591_INTCFG_RDY = 0;
 690
 691     /* Disable PIPE not-ready interrupts */
 692     M66591_INTCFG_NRDY = 0;
 693
 694     /* Disable PIPE empyt/size error interrupts */
 695     M66591_INTCFG_EMP = 0;
 696
 697     /* Enable all interrupts except NOT READY, RESUME, and VBUS */
 698     M66591_INTCFG_MAIN = 0x1DFF;
 699
 700     pipe_c_select(0, false);
 701
 702     /* Enable continuous transfer mode on the DCP */
 703     M66591_DCP_CNTMD |= (1<<8);
 704
 705     /* Set the threshold that the PHY will automatically transmit from EP0 */
 706     M66591_DCP_CTRLEN = 128;
 707
 708     pipe_handshake(0, PIPE_SHAKE_NAK);
 709
 710     /* Set the Max packet size to 64 */
 711     M66591_DCP_MXPKSZ = 64;
 712
 713     /* Attach notification to PC (D+ pull-up) */
 714     M66591_TRN_CTRL |= (1<<4);
 715
 716     logf("mxx: attached");
 717 }
 718
 719 void usb_drv_exit(void) {
 720     /* USB Detach Process: This follows the flow diagram in the M66591GP
 721      *  Reference Manual Rev 1.00, p. 78.
 722      */
 723
 724     /* Detach notification to PC (disable D+ pull-up) */
 725     M66591_TRN_CTRL &= ~(1<<4);
 726
 727     /* Software reset */
 728     M66591_TRN_CTRL &= ~0x01;
 729
 730     /* Disable internal clock supply */
 731     M66591_TRN_CTRL &= ~(1<<10);
 732     udelay(3);
 733
 734     /* Disable PLL */
 735     M66591_TRN_CTRL &= ~(1<<11);
 736     udelay(3);
 737
 738     /* Disable internal reference clock */
 739     M66591_TRN_CTRL &= ~(1<<12);
 740     udelay(3);
 741
 742     /* Disable oscillation buffer, reenable USB operation */
 743     M66591_TRN_CTRL &= ~(1<<13);
 744
 745     M66591_TRN_CTRL |= 0x01;
 746
 747     logf("mxx: detached");
 748 }
 749
 750 /* This function begins a transmit (on an IN endpoint), it should not block
 751  *  so the actual transmit is done in the interrupt handler.
 752  */
 753 int usb_drv_send_nonblocking(int endpoint, void* ptr, int length)
 754 {
 755     /* The last arguement for queue specifies the dir of data (true==send) */
 756     return mxx_queue(endpoint, ptr, length, true);
 757 }
 758
 759 /* This function begins a transmit (on an IN endpoint), it does not block
 760  *  so the actual transmit is done in the interrupt handler.
 761  */
 762 int usb_drv_send(int endpoint, void* ptr, int length)
 763 {
 764     /* The last arguement for queue specifies the dir of data (true==send) */
 765     return mxx_queue(endpoint, ptr, length, true);
 766 }
 767
 768 /* This function begins a receive (on an OUT endpoint), it should not block
 769  *  so the actual receive is done in the interrupt handler.
 770  */
 771 int usb_drv_recv(int endpoint, void* ptr, int length)
 772 {
 773     /* Last arguement for queue specifies the dir of data (false==receive) */
 774     return mxx_queue(endpoint, ptr, length, false);
 775 }
 776
 777 /* This function checks the reset handshake speed status
 778  *  (Fullspeed or Highspeed)
 779  */
 780 int usb_drv_port_speed(void)
 781 {
 782     int handshake = (M66591_HSFS & 0xFF);
 783
 784     if( handshake == 0x02) {
 785         return 0; /* Handshook at Full-Speed */
 786     } else if( handshake == 0x03) {
 787         return 1; /* Handshook at Hi-Speed */
 788     } else {
 789         return -1; /* Error, handshake may not be complete */
 790     }
 791 }
 792
 793 /* This function checks if the endpoint is stalled (error).  I am not sure what
 794  *  the "in" variable is intended for.
 795  */
 796 bool usb_drv_stalled(int endpoint,bool in)
 797 {
 798     (void) in;
 799
 800     bool stalled = (*(pipe_ctrl_addr(endpoint)) & (0x02)) ? true : false;
 801
 802     logf("mxx: stall?: %s ep: %d", stalled ? "true" : "false", endpoint);
 803
 804     if(stalled) {
 805         return true;
 806     } else {
 807         return false;
 808     }
 809 }
 810
 811 /* This function stalls/unstalls the endpoint.  Stalls only happen on error so
 812  *  if the endpoint is functioning properly this should not be called.  I am
 813  *  not sure what the "in" variable is intended for.
 814  */
 815 void usb_drv_stall(int endpoint, bool stall,bool in)
 816 {
 817     (void) in;
 818
 819     logf("mxx: stall - ep: %d", endpoint);
 820
 821     if(stall) {
 822         /* Stall the pipe (host needs to intervene/error) */
 823         pipe_handshake(endpoint, PIPE_SHAKE_STALL);
 824     } else {
 825         /* Setting this to a NAK, not sure if it is appropriate */
 826         pipe_handshake(endpoint, PIPE_SHAKE_NAK);
 827     }
 828 }
 829
 830 /* !!!!!!!!!!This function is likely incomplete!!!!!!!!!!!!!! */
 831 void usb_drv_cancel_all_transfers(void)
 832 {
 833     int endpoint;
 834     int flags;
 835
 836     logf("mxx: %s", __func__);
 837
 838     flags = disable_irq_save();
 839     for (endpoint = 0; endpoint < USB_NUM_ENDPOINTS; endpoint++) {
 840         if (M66591_eps[endpoint].buf) {
 841             M66591_eps[endpoint].buf = NULL;
 842         }
 843     }
 844
 845     restore_irq(flags);
 846 }
 847