Output/pjrcUSB/arm/usb_dev.c

   1 /* Teensyduino Core Library
   2  * http://www.pjrc.com/teensy/
   3  * Copyright (c) 2013 PJRC.COM, LLC.
   4  * Modifications by Jacob Alexander (2013-2014)
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sublicense, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * 1. The above copyright notice and this permission notice shall be
  15  * included in all copies or substantial portions of the Software.
  16  *
  17  * 2. If the Software is incorporated into a build system that allows
  18  * selection among a list of target devices, then similar target
  19  * devices manufactured by PJRC.COM must be included in the list of
  20  * target devices and selectable in the same manner.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  26  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  27  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  28  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  29  * SOFTWARE.
  30  */
  31
  32 // ----- Includes -----
  33
  34 // Project Includes
  35 #include <Lib/OutputLib.h>
  36 #include <print.h>
  37
  38 // Local Includes
  39 #include "usb_dev.h"
  40 #include "usb_mem.h"
  41
  42
  43
  44 // ----- Defines -----
  45
  46 // DEBUG Mode
  47 // XXX - Only use when using usbMuxUart Module
  48 // Delay causes issues initializing more than 1 hid device (i.e. NKRO keyboard)
  49 //#define UART_DEBUG 1
  50 // Debug Unknown USB requests, usually what you want to debug USB issues
  51 //#define UART_DEBUG_UNKNOWN 1
  52
  53
  54 #define TX_STATE_BOTH_FREE_EVEN_FIRST   0
  55 #define TX_STATE_BOTH_FREE_ODD_FIRST    1
  56 #define TX_STATE_EVEN_FREE              2
  57 #define TX_STATE_ODD_FREE               3
  58 #define TX_STATE_NONE_FREE_EVEN_FIRST   4
  59 #define TX_STATE_NONE_FREE_ODD_FIRST    5
  60
  61 #define BDT_OWN         0x80
  62 #define BDT_DATA1       0x40
  63 #define BDT_DATA0       0x00
  64 #define BDT_DTS         0x08
  65 #define BDT_STALL       0x04
  66
  67 #define TX    1
  68 #define RX    0
  69 #define ODD   1
  70 #define EVEN  0
  71 #define DATA0 0
  72 #define DATA1 1
  73
  74
  75 #define GET_STATUS              0
  76 #define CLEAR_FEATURE           1
  77 #define SET_FEATURE             3
  78 #define SET_ADDRESS             5
  79 #define GET_DESCRIPTOR          6
  80 #define SET_DESCRIPTOR          7
  81 #define GET_CONFIGURATION       8
  82 #define SET_CONFIGURATION       9
  83 #define GET_INTERFACE           10
  84 #define SET_INTERFACE           11
  85 #define SYNCH_FRAME             12
  86
  87 #define TX_STATE_BOTH_FREE_EVEN_FIRST   0
  88 #define TX_STATE_BOTH_FREE_ODD_FIRST    1
  89 #define TX_STATE_EVEN_FREE              2
  90 #define TX_STATE_ODD_FREE               3
  91 #define TX_STATE_NONE_FREE              4
  92
  93
  94
  95
  96
  97 // ----- Macros -----
  98
  99 #define BDT_PID(n)      (((n) >> 2) & 15)
 100
 101 #define BDT_DESC(count, data)   (BDT_OWN | BDT_DTS \
 102                                 | ((data) ? BDT_DATA1 : BDT_DATA0) \
 103                                 | ((count) << 16))
 104
 105 #define index(endpoint, tx, odd) (((endpoint) << 2) | ((tx) << 1) | (odd))
 106 #define stat2bufferdescriptor(stat) (table + ((stat) >> 2))
 107
 108
 109
 110 // ----- Structs -----
 111
 112 // buffer descriptor table
 113
 114 typedef struct {
 115         uint32_t desc;
 116         void * addr;
 117 } bdt_t;
 118
 119 static union {
 120         struct {
 121                 union {
 122                         struct {
 123                                 uint8_t bmRequestType;
 124                                 uint8_t bRequest;
 125                         };
 126                         uint16_t wRequestAndType;
 127                 };
 128                 uint16_t wValue;
 129                 uint16_t wIndex;
 130                 uint16_t wLength;
 131         };
 132         struct {
 133                 uint32_t word1;
 134                 uint32_t word2;
 135         };
 136 } setup;
 137
 138
 139
 140 // ----- Variables -----
 141
 142 __attribute__ ((section(".usbdescriptortable"), used))
 143 static bdt_t table[ (NUM_ENDPOINTS + 1) * 4 ];
 144
 145 static usb_packet_t *rx_first  [ NUM_ENDPOINTS ];
 146 static usb_packet_t *rx_last   [ NUM_ENDPOINTS ];
 147 static usb_packet_t *tx_first  [ NUM_ENDPOINTS ];
 148 static usb_packet_t *tx_last   [ NUM_ENDPOINTS ];
 149 uint16_t usb_rx_byte_count_data[ NUM_ENDPOINTS ];
 150
 151 static uint8_t tx_state[NUM_ENDPOINTS];
 152
 153 // SETUP always uses a DATA0 PID for the data field of the SETUP transaction.
 154 // transactions in the data phase start with DATA1 and toggle (figure 8-12, USB1.1)
 155 // Status stage uses a DATA1 PID.
 156
 157 static uint8_t ep0_rx0_buf[EP0_SIZE] __attribute__ ((aligned (4)));
 158 static uint8_t ep0_rx1_buf[EP0_SIZE] __attribute__ ((aligned (4)));
 159 static const uint8_t *ep0_tx_ptr = NULL;
 160 static uint16_t ep0_tx_len;
 161 static uint8_t ep0_tx_bdt_bank = 0;
 162 static uint8_t ep0_tx_data_toggle = 0;
 163 uint8_t usb_rx_memory_needed = 0;
 164
 165 volatile uint8_t usb_configuration = 0;
 166 volatile uint8_t usb_reboot_timer = 0;
 167
 168 static uint8_t reply_buffer[8];
 169
 170
 171
 172 // ----- Functions -----
 173
 174 static void endpoint0_stall()
 175 {
 176         USB0_ENDPT0 = USB_ENDPT_EPSTALL | USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;
 177 }
 178
 179 static void endpoint0_transmit( const void *data, uint32_t len )
 180 {
 181         table[index(0, TX, ep0_tx_bdt_bank)].addr = (void *)data;
 182         table[index(0, TX, ep0_tx_bdt_bank)].desc = BDT_DESC(len, ep0_tx_data_toggle);
 183         ep0_tx_data_toggle ^= 1;
 184         ep0_tx_bdt_bank ^= 1;
 185 }
 186
 187 static void usb_setup()
 188 {
 189         const uint8_t *data = NULL;
 190         uint32_t datalen = 0;
 191         const usb_descriptor_list_t *list;
 192         uint32_t size;
 193         volatile uint8_t *reg;
 194         uint8_t epconf;
 195         const uint8_t *cfg;
 196         int i;
 197
 198         switch ( setup.wRequestAndType )
 199         {
 200         case 0x0500: // SET_ADDRESS
 201                 break;
 202         case 0x0900: // SET_CONFIGURATION
 203                 #ifdef UART_DEBUG
 204                 print("CONFIGURE - ");
 205                 #endif
 206                 usb_configuration = setup.wValue;
 207                 reg = &USB0_ENDPT1;
 208                 cfg = usb_endpoint_config_table;
 209                 // clear all BDT entries, free any allocated memory...
 210                 for ( i = 4; i < ( NUM_ENDPOINTS + 1) * 4; i++ )
 211                 {
 212                         if ( table[i].desc & BDT_OWN )
 213                         {
 214                                 usb_free( (usb_packet_t *)((uint8_t *)(table[ i ].addr) - 8) );
 215                         }
 216                 }
 217                 // free all queued packets
 218                 for ( i = 0; i < NUM_ENDPOINTS; i++ )
 219                 {
 220                         usb_packet_t *p, *n;
 221                         p = rx_first[i];
 222                         while ( p )
 223                         {
 224                                 n = p->next;
 225                                 usb_free(p);
 226                                 p = n;
 227                         }
 228                         rx_first[ i ] = NULL;
 229                         rx_last[ i ] = NULL;
 230                         p = tx_first[i];
 231                         while (p)
 232                         {
 233                                 n = p->next;
 234                                 usb_free(p);
 235                                 p = n;
 236                         }
 237                         tx_first[ i ] = NULL;
 238                         tx_last[ i ] = NULL;
 239                         usb_rx_byte_count_data[i] = 0;
 240
 241                         switch ( tx_state[ i ] )
 242                         {
 243                         case TX_STATE_EVEN_FREE:
 244                         case TX_STATE_NONE_FREE_EVEN_FIRST:
 245                                 tx_state[ i ] = TX_STATE_BOTH_FREE_EVEN_FIRST;
 246                                 break;
 247                         case TX_STATE_ODD_FREE:
 248                         case TX_STATE_NONE_FREE_ODD_FIRST:
 249                                 tx_state[ i ] = TX_STATE_BOTH_FREE_ODD_FIRST;
 250                                 break;
 251                         default:
 252                                 break;
 253                         }
 254                 }
 255                 usb_rx_memory_needed = 0;
 256                 for ( i = 1; i <= NUM_ENDPOINTS; i++ )
 257                 {
 258                         epconf = *cfg++;
 259                         *reg = epconf;
 260                         reg += 4;
 261                         if ( epconf & USB_ENDPT_EPRXEN )
 262                         {
 263                                 usb_packet_t *p;
 264                                 p = usb_malloc();
 265                                 if ( p )
 266                                 {
 267                                         table[ index( i, RX, EVEN ) ].addr = p->buf;
 268                                         table[ index( i, RX, EVEN ) ].desc = BDT_DESC( 64, 0 );
 269                                 }
 270                                 else
 271                                 {
 272                                         table[ index( i, RX, EVEN ) ].desc = 0;
 273                                         usb_rx_memory_needed++;
 274                                 }
 275                                 p = usb_malloc();
 276                                 if ( p )
 277                                 {
 278                                         table[ index( i, RX, ODD ) ].addr = p->buf;
 279                                         table[ index( i, RX, ODD ) ].desc = BDT_DESC( 64, 1 );
 280                                 }
 281                                 else
 282                                 {
 283                                         table[ index( i, RX, ODD ) ].desc = 0;
 284                                         usb_rx_memory_needed++;
 285                                 }
 286                         }
 287                         table[ index( i, TX, EVEN ) ].desc = 0;
 288                         table[ index( i, TX, ODD ) ].desc = 0;
 289                 }
 290                 break;
 291         case 0x0880: // GET_CONFIGURATION
 292                 reply_buffer[0] = usb_configuration;
 293                 datalen = 1;
 294                 data = reply_buffer;
 295                 break;
 296         case 0x0080: // GET_STATUS (device)
 297                 reply_buffer[0] = 0;
 298                 reply_buffer[1] = 0;
 299                 datalen = 2;
 300                 data = reply_buffer;
 301                 break;
 302         case 0x0082: // GET_STATUS (endpoint)
 303                 if (setup.wIndex > NUM_ENDPOINTS)
 304                 {
 305                         // TODO: do we need to handle IN vs OUT here?
 306                         endpoint0_stall();
 307                         return;
 308                 }
 309                 reply_buffer[0] = 0;
 310                 reply_buffer[1] = 0;
 311                 if ( *(uint8_t *)(&USB0_ENDPT0 + setup.wIndex * 4) & 0x02 )
 312                         reply_buffer[0] = 1;
 313                 data = reply_buffer;
 314                 datalen = 2;
 315                 break;
 316         case 0x0102: // CLEAR_FEATURE (endpoint)
 317                 i = setup.wIndex & 0x7F;
 318                 if ( i > NUM_ENDPOINTS || setup.wValue != 0 )
 319                 {
 320                         // TODO: do we need to handle IN vs OUT here?
 321                         endpoint0_stall();
 322                         return;
 323                 }
 324                 (*(uint8_t *)(&USB0_ENDPT0 + setup.wIndex * 4)) &= ~0x02;
 325                 // TODO: do we need to clear the data toggle here?
 326                 break;
 327         case 0x0302: // SET_FEATURE (endpoint)
 328                 i = setup.wIndex & 0x7F;
 329                 if ( i > NUM_ENDPOINTS || setup.wValue != 0 )
 330                 {
 331                         // TODO: do we need to handle IN vs OUT here?
 332                         endpoint0_stall();
 333                         return;
 334                 }
 335                 (*(uint8_t *)(&USB0_ENDPT0 + setup.wIndex * 4)) |= 0x02;
 336                 // TODO: do we need to clear the data toggle here?
 337                 break;
 338         case 0x0680: // GET_DESCRIPTOR
 339         case 0x0681:
 340                 #ifdef UART_DEBUG
 341                 print("desc:");
 342                 printHex( setup.wValue );
 343                 print( NL );
 344                 #endif
 345                 for ( list = usb_descriptor_list; 1; list++ )
 346                 {
 347                         if ( list->addr == NULL )
 348                                 break;
 349                         if ( setup.wValue == list->wValue && setup.wIndex == list->wIndex )
 350                         {
 351                                 data = list->addr;
 352                                 if ( (setup.wValue >> 8) == 3 )
 353                                 {
 354                                         // for string descriptors, use the descriptor's
 355                                         // length field, allowing runtime configured
 356                                         // length.
 357                                         datalen = *(list->addr);
 358                                 }
 359                                 else
 360                                 {
 361                                         datalen = list->length;
 362                                 }
 363                                 #if UART_DEBUG
 364                                 print("Desc found, ");
 365                                 printHex32( (uint32_t)data );
 366                                 print(",");
 367                                 printHex( datalen );
 368                                 print(",");
 369                                 printHex_op( data[0], 2 );
 370                                 printHex_op( data[1], 2 );
 371                                 printHex_op( data[2], 2 );
 372                                 printHex_op( data[3], 2 );
 373                                 printHex_op( data[4], 2 );
 374                                 printHex_op( data[5], 2 );
 375                                 print( NL );
 376                                 #endif
 377                                 goto send;
 378                         }
 379                 }
 380                 #ifdef UART_DEBUG
 381                 print( "desc: not found" NL );
 382                 #endif
 383                 endpoint0_stall();
 384                 return;
 385
 386         case 0x2221: // CDC_SET_CONTROL_LINE_STATE
 387                 usb_cdc_line_rtsdtr = setup.wValue;
 388                 //serial_print("set control line state\n");
 389                 endpoint0_stall();
 390                 return;
 391
 392         case 0x21A1: // CDC_GET_LINE_CODING
 393                 data = (uint8_t*)usb_cdc_line_coding;
 394                 datalen = sizeof( usb_cdc_line_coding );
 395                 goto send;
 396
 397         case 0x2021: // CDC_SET_LINE_CODING
 398                 // XXX Needed?
 399                 //serial_print("set coding, waiting...\n");
 400                 endpoint0_stall();
 401                 return; // Cannot stall here (causes issues)
 402
 403         case 0x0921: // HID SET_REPORT
 404                 #ifdef UART_DEBUG
 405                 print("SET_REPORT - ");
 406                 printHex( setup.wValue );
 407                 print(" - ");
 408                 printHex( setup.wValue & 0xFF );
 409                 print( NL );
 410                 #endif
 411                 USBKeys_LEDs = setup.wValue & 0xFF;
 412                 endpoint0_stall();
 413                 return;
 414
 415         case 0x01A1: // HID GET_REPORT
 416                 #ifdef UART_DEBUG
 417                 print("GET_REPORT - ");
 418                 printHex( USBKeys_LEDs );
 419                 print(NL);
 420                 #endif
 421                 data = (uint8_t*)&USBKeys_LEDs;
 422                 datalen = 1;
 423                 goto send;
 424
 425         case 0x0A21: // HID SET_IDLE
 426                 #ifdef UART_DEBUG
 427                 print("SET_IDLE - ");
 428                 printHex( setup.wValue );
 429                 print(NL);
 430                 #endif
 431                 USBKeys_Idle_Config = (setup.wValue >> 8);
 432                 USBKeys_Idle_Count = 0;
 433                 endpoint0_stall();
 434                 return;
 435
 436         case 0x0B21: // HID SET_PROTOCOL
 437                 #ifdef UART_DEBUG
 438                 print("SET_PROTOCOL - ");
 439                 printHex( setup.wValue );
 440                 print(" - ");
 441                 printHex( setup.wValue & 0xFF );
 442                 print(NL);
 443                 #endif
 444                 USBKeys_Protocol = setup.wValue & 0xFF; // 0 - Boot Mode, 1 - NKRO Mode
 445                 endpoint0_stall();
 446                 return;
 447
 448         // case 0xC940:
 449         default:
 450                 #ifdef UART_DEBUG_UNKNOWN
 451                 print("UNKNOWN");
 452                 #endif
 453                 endpoint0_stall();
 454                 return;
 455         }
 456
 457 send:
 458         #ifdef UART_DEBUG
 459         print("setup send ");
 460         printHex32((uint32_t)data);
 461         print(",");
 462         printHex(datalen);
 463         print(NL);
 464         #endif
 465
 466         if ( datalen > setup.wLength )
 467                 datalen = setup.wLength;
 468
 469         size = datalen;
 470         if ( size > EP0_SIZE )
 471                 size = EP0_SIZE;
 472
 473         endpoint0_transmit(data, size);
 474         data += size;
 475         datalen -= size;
 476
 477         // See if transmit has finished
 478         if ( datalen == 0 && size < EP0_SIZE )
 479                 return;
 480
 481         size = datalen;
 482         if ( size > EP0_SIZE )
 483                 size = EP0_SIZE;
 484         endpoint0_transmit(data, size);
 485         data += size;
 486         datalen -= size;
 487
 488         // See if transmit has finished
 489         if ( datalen == 0 && size < EP0_SIZE )
 490                 return;
 491
 492         // Save rest of transfer for later? XXX
 493         ep0_tx_ptr = data;
 494         ep0_tx_len = datalen;
 495 }
 496
 497
 498 //A bulk endpoint's toggle sequence is initialized to DATA0 when the endpoint
 499 //experiences any configuration event (configuration events are explained in
 500 //Sections 9.1.1.5 and 9.4.5).
 501
 502 //Configuring a device or changing an alternate setting causes all of the status
 503 //and configuration values associated with endpoints in the affected interfaces
 504 //to be set to their default values. This includes setting the data toggle of
 505 //any endpoint using data toggles to the value DATA0.
 506
 507 //For endpoints using data toggle, regardless of whether an endpoint has the
 508 //Halt feature set, a ClearFeature(ENDPOINT_HALT) request always results in the
 509 //data toggle being reinitialized to DATA0.
 510
 511 static void usb_control( uint32_t stat )
 512 {
 513         #ifdef UART_DEBUG
 514         print("CONTROL - ");
 515         #endif
 516         bdt_t *b;
 517         uint32_t pid, size;
 518         uint8_t *buf;
 519         const uint8_t *data;
 520
 521         b = stat2bufferdescriptor( stat );
 522         pid = BDT_PID( b->desc );
 523         buf = b->addr;
 524         #ifdef UART_DEBUG
 525         print("pid:");
 526         printHex(pid);
 527         print(", count:");
 528         printHex32(b->desc);
 529         print(" - ");
 530         #endif
 531
 532         switch (pid)
 533         {
 534         case 0x0D: // Setup received from host
 535                 //serial_print("PID=Setup\n");
 536                 //if (count != 8) ; // panic?
 537                 // grab the 8 byte setup info
 538                 setup.word1 = *(uint32_t *)(buf);
 539                 setup.word2 = *(uint32_t *)(buf + 4);
 540
 541                 // give the buffer back
 542                 b->desc = BDT_DESC( EP0_SIZE, DATA1 );
 543                 //table[index(0, RX, EVEN)].desc = BDT_DESC(EP0_SIZE, 1);
 544                 //table[index(0, RX, ODD)].desc = BDT_DESC(EP0_SIZE, 1);
 545
 546                 // clear any leftover pending IN transactions
 547                 ep0_tx_ptr = NULL;
 548                 if ( ep0_tx_data_toggle )
 549                 {
 550                 }
 551                 //if (table[index(0, TX, EVEN)].desc & 0x80) {
 552                         //serial_print("leftover tx even\n");
 553                 //}
 554                 //if (table[index(0, TX, ODD)].desc & 0x80) {
 555                         //serial_print("leftover tx odd\n");
 556                 //}
 557                 table[index(0, TX, EVEN)].desc = 0;
 558                 table[index(0, TX, ODD)].desc = 0;
 559                 // first IN after Setup is always DATA1
 560                 ep0_tx_data_toggle = 1;
 561
 562                 #ifdef UART_DEBUG_UNKNOWN
 563                 print("bmRequestType:");
 564                 printHex(setup.bmRequestType);
 565                 print(", bRequest:");
 566                 printHex(setup.bRequest);
 567                 print(", wValue:");
 568                 printHex(setup.wValue);
 569                 print(", wIndex:");
 570                 printHex(setup.wIndex);
 571                 print(", len:");
 572                 printHex(setup.wLength);
 573                 print(NL);
 574                 #endif
 575                 // actually "do" the setup request
 576                 usb_setup();
 577                 // unfreeze the USB, now that we're ready
 578                 USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit
 579                 break;
 580         case 0x01:  // OUT transaction received from host
 581         case 0x02:
 582                 #ifdef UART_DEBUG
 583                 print("PID=OUT"NL);
 584                 #endif
 585                 // CDC Interface
 586                 if ( setup.wRequestAndType == 0x2021 /*CDC_SET_LINE_CODING*/ )
 587                 {
 588                         int i;
 589                         uint8_t *dst = (uint8_t *)usb_cdc_line_coding;
 590                         //serial_print("set line coding ");
 591                         for ( i = 0; i < 7; i++ )
 592                         {
 593                                 //serial_phex(*buf);
 594                                 *dst++ = *buf++;
 595                         }
 596                         //serial_phex32(usb_cdc_line_coding[0]);
 597                         //serial_print("\n");
 598                         if ( usb_cdc_line_coding[0] == 134 )
 599                                 usb_reboot_timer = 15;
 600                         endpoint0_transmit( NULL, 0 );
 601                 }
 602
 603                 // Keyboard Interface
 604                 if ( setup.word1 == 0x02000921 && setup.word2 == ( (1<<16) | KEYBOARD_INTERFACE ) )
 605                 {
 606                         USBKeys_LEDs = buf[0];
 607                         endpoint0_transmit( NULL, 0 );
 608                 }
 609                 // NKRO Keyboard Interface
 610                 if ( setup.word1 == 0x02000921 && setup.word2 == ( (1<<16) | NKRO_KEYBOARD_INTERFACE ) )
 611                 {
 612                         USBKeys_LEDs = buf[0];
 613                         endpoint0_transmit( NULL, 0 );
 614                 }
 615
 616                 // give the buffer back
 617                 b->desc = BDT_DESC( EP0_SIZE, DATA1 );
 618                 break;
 619
 620         case 0x09: // IN transaction completed to host
 621                 #ifdef UART_DEBUG
 622                 print("PID=IN:");
 623                 printHex(stat);
 624                 print(NL);
 625                 #endif
 626
 627                 // send remaining data, if any...
 628                 data = ep0_tx_ptr;
 629                 if ( data )
 630                 {
 631                         size = ep0_tx_len;
 632                         if (size > EP0_SIZE) size = EP0_SIZE;
 633                         endpoint0_transmit(data, size);
 634                         data += size;
 635                         ep0_tx_len -= size;
 636                         ep0_tx_ptr = (ep0_tx_len > 0 || size == EP0_SIZE) ? data : NULL;
 637                 }
 638
 639                 if ( setup.bRequest == 5 && setup.bmRequestType == 0 )
 640                 {
 641                         setup.bRequest = 0;
 642                         #ifdef UART_DEBUG
 643                         print("set address: ");
 644                         printHex(setup.wValue);
 645                         print(NL);
 646                         #endif
 647                         USB0_ADDR = setup.wValue;
 648                 }
 649
 650                 break;
 651         default:
 652                 #ifdef UART_DEBUG
 653                 print("PID=unknown:");
 654                 printHex(pid);
 655                 print(NL);
 656                 #endif
 657                 break;
 658         }
 659         USB0_CTL = USB_CTL_USBENSOFEN; // clear TXSUSPENDTOKENBUSY bit
 660 }
 661
 662 usb_packet_t *usb_rx( uint32_t endpoint )
 663 {
 664         //print("USB RX");
 665         usb_packet_t *ret;
 666         endpoint--;
 667         if ( endpoint >= NUM_ENDPOINTS )
 668                 return NULL;
 669         __disable_irq();
 670         ret = rx_first[endpoint];
 671         if ( ret )
 672                 rx_first[ endpoint ] = ret->next;
 673         usb_rx_byte_count_data[ endpoint ] -= ret->len;
 674         __enable_irq();
 675         //serial_print("rx, epidx=");
 676         //serial_phex(endpoint);
 677         //serial_print(", packet=");
 678         //serial_phex32(ret);
 679         //serial_print("\n");
 680         return ret;
 681 }
 682
 683 static uint32_t usb_queue_byte_count( const usb_packet_t *p )
 684 {
 685         uint32_t count=0;
 686
 687         __disable_irq();
 688         for ( ; p; p = p->next )
 689         {
 690                 count += p->len;
 691         }
 692         __enable_irq();
 693         return count;
 694 }
 695
 696 uint32_t usb_tx_byte_count( uint32_t endpoint )
 697 {
 698         endpoint--;
 699         if ( endpoint >= NUM_ENDPOINTS )
 700                 return 0;
 701         return usb_queue_byte_count( tx_first[ endpoint ] );
 702 }
 703
 704 uint32_t usb_tx_packet_count( uint32_t endpoint )
 705 {
 706         const usb_packet_t *p;
 707         uint32_t count=0;
 708
 709         endpoint--;
 710         if ( endpoint >= NUM_ENDPOINTS )
 711                 return 0;
 712         __disable_irq();
 713         for ( p = tx_first[ endpoint ]; p; p = p->next )
 714                 count++;
 715         __enable_irq();
 716         return count;
 717 }
 718
 719
 720 // Called from usb_free, but only when usb_rx_memory_needed > 0, indicating
 721 // receive endpoints are starving for memory.  The intention is to give
 722 // endpoints needing receive memory priority over the user's code, which is
 723 // likely calling usb_malloc to obtain memory for transmitting.  When the
 724 // user is creating data very quickly, their consumption could starve reception
 725 // without this prioritization.  The packet buffer (input) is assigned to the
 726 // first endpoint needing memory.
 727 //
 728 void usb_rx_memory( usb_packet_t *packet )
 729 {
 730         //print("USB RX MEMORY");
 731         unsigned int i;
 732         const uint8_t *cfg;
 733
 734         cfg = usb_endpoint_config_table;
 735         //serial_print("rx_mem:");
 736         __disable_irq();
 737         for ( i = 1; i <= NUM_ENDPOINTS; i++ )
 738         {
 739                 if ( *cfg++ & USB_ENDPT_EPRXEN )
 740                 {
 741                         if ( table[ index( i, RX, EVEN ) ].desc == 0 )
 742                         {
 743                                 table[ index( i, RX, EVEN ) ].addr = packet->buf;
 744                                 table[ index( i, RX, EVEN ) ].desc = BDT_DESC( 64, 0 );
 745                                 usb_rx_memory_needed--;
 746                                 __enable_irq();
 747                                 //serial_phex(i);
 748                                 //serial_print(",even\n");
 749                                 return;
 750                         }
 751                         if ( table[ index( i, RX, ODD ) ].desc == 0 )
 752                         {
 753                                 table[ index( i, RX, ODD ) ].addr = packet->buf;
 754                                 table[ index( i, RX, ODD ) ].desc = BDT_DESC( 64, 1 );
 755                                 usb_rx_memory_needed--;
 756                                 __enable_irq();
 757                                 //serial_phex(i);
 758                                 //serial_print(",odd\n");
 759                                 return;
 760                         }
 761                 }
 762         }
 763         __enable_irq();
 764         // we should never reach this point.  If we get here, it means
 765         // usb_rx_memory_needed was set greater than zero, but no memory
 766         // was actually needed.
 767         usb_rx_memory_needed = 0;
 768         usb_free( packet );
 769         return;
 770 }
 771
 772 //#define index(endpoint, tx, odd) (((endpoint) << 2) | ((tx) << 1) | (odd))
 773 //#define stat2bufferdescriptor(stat) (table + ((stat) >> 2))
 774
 775 void usb_tx( uint32_t endpoint, usb_packet_t *packet )
 776 {
 777         bdt_t *b = &table[ index( endpoint, TX, EVEN ) ];
 778         uint8_t next;
 779
 780         endpoint--;
 781         if ( endpoint >= NUM_ENDPOINTS )
 782                 return;
 783         __disable_irq();
 784         //serial_print("txstate=");
 785         //serial_phex(tx_state[ endpoint ]);
 786         //serial_print("\n");
 787         switch ( tx_state[ endpoint ] )
 788         {
 789         case TX_STATE_BOTH_FREE_EVEN_FIRST:
 790                 next = TX_STATE_ODD_FREE;
 791                 break;
 792         case TX_STATE_BOTH_FREE_ODD_FIRST:
 793                 b++;
 794                 next = TX_STATE_EVEN_FREE;
 795                 break;
 796         case TX_STATE_EVEN_FREE:
 797                 next = TX_STATE_NONE_FREE_ODD_FIRST;
 798                 break;
 799         case TX_STATE_ODD_FREE:
 800                 b++;
 801                 next = TX_STATE_NONE_FREE_EVEN_FIRST;
 802                 break;
 803         default:
 804                 if (tx_first[ endpoint ] == NULL)
 805                 {
 806                         tx_first[ endpoint ] = packet;
 807                 }
 808                 else
 809                 {
 810                         tx_last[ endpoint ]->next = packet;
 811                 }
 812                 tx_last[ endpoint ] = packet;
 813                 __enable_irq();
 814                 return;
 815         }
 816
 817         tx_state[ endpoint ] = next;
 818         b->addr = packet->buf;
 819         b->desc = BDT_DESC( packet->len, ((uint32_t)b & 8) ? DATA1 : DATA0 );
 820         __enable_irq();
 821 }
 822
 823
 824 void usb_device_reload()
 825 {
 826 // MCHCK
 827 #if defined(_mk20dx128vlf5_)
 828
 829         // MCHCK Kiibohd Variant
 830         // Check to see if PTA3 (has a pull-up) is connected to GND (usually via jumper)
 831         // Only allow reload if the jumper is present (security)
 832         GPIOA_PDDR &= ~(1<<3); // Input
 833         PORTA_PCR3 = PORT_PCR_PFE | PORT_PCR_MUX(1); // Internal pull-up
 834
 835         // Check for jumper
 836         if ( GPIOA_PDIR & (1<<3) )
 837         {
 838                 print( NL );
 839                 warn_print("Security jumper not present, cancelling firmware reload...");
 840                 info_msg("Replace jumper on middle 2 pins, or manually press the firmware reload button.");
 841         }
 842         else
 843         {
 844                 // Copies variable into the VBAT register, must be identical to the variable in the bootloader to jump to the bootloader flash mode
 845                 for ( int pos = 0; pos < sizeof(sys_reset_to_loader_magic); pos++ )
 846                         (&VBAT)[ pos ] = sys_reset_to_loader_magic[ pos ];
 847                 SOFTWARE_RESET();
 848         }
 849
 850 // Teensy 3.0 and 3.1
 851 #else
 852         asm volatile("bkpt");
 853 #endif
 854 }
 855
 856
 857 void usb_isr()
 858 {
 859         uint8_t status, stat, t;
 860
 861         //serial_print("isr");
 862         //status = USB0_ISTAT;
 863         //serial_phex(status);
 864         //serial_print("\n");
 865 restart:
 866         status = USB0_ISTAT;
 867         /*
 868         print("USB ISR STATUS: ");
 869         printHex( status );
 870         print( NL );
 871         */
 872
 873         if ( (status & USB_INTEN_SOFTOKEN /* 04 */ ) )
 874         {
 875                 if ( usb_configuration )
 876                 {
 877                         t = usb_reboot_timer;
 878                         if ( t )
 879                         {
 880                                 usb_reboot_timer = --t;
 881                                 if ( !t )
 882                                         usb_device_reload();
 883                         }
 884
 885                         // CDC Interface
 886                         t = usb_cdc_transmit_flush_timer;
 887                         if ( t )
 888                         {
 889                                 usb_cdc_transmit_flush_timer = --t;
 890                                 if ( t == 0 )
 891                                         usb_serial_flush_callback();
 892                         }
 893
 894                 }
 895                 USB0_ISTAT = USB_INTEN_SOFTOKEN;
 896         }
 897
 898         if ( (status & USB_ISTAT_TOKDNE /* 08 */ ) )
 899         {
 900                 uint8_t endpoint;
 901                 stat = USB0_STAT;
 902                 //serial_print("token: ep=");
 903                 //serial_phex(stat >> 4);
 904                 //serial_print(stat & 0x08 ? ",tx" : ",rx");
 905                 //serial_print(stat & 0x04 ? ",odd\n" : ",even\n");
 906                 endpoint = stat >> 4;
 907                 if ( endpoint == 0 )
 908                 {
 909                         usb_control( stat );
 910                 }
 911                 else
 912                 {
 913                         bdt_t *b = stat2bufferdescriptor(stat);
 914                         usb_packet_t *packet = (usb_packet_t *)((uint8_t *)(b->addr) - 8);
 915 #if 0
 916                         serial_print("ep:");
 917                         serial_phex(endpoint);
 918                         serial_print(", pid:");
 919                         serial_phex(BDT_PID(b->desc));
 920                         serial_print(((uint32_t)b & 8) ? ", odd" : ", even");
 921                         serial_print(", count:");
 922                         serial_phex(b->desc >> 16);
 923                         serial_print("\n");
 924 #endif
 925                         endpoint--;     // endpoint is index to zero-based arrays
 926
 927                         if ( stat & 0x08 )
 928                         { // transmit
 929                                 usb_free( packet );
 930                                 packet = tx_first[ endpoint ];
 931                                 if ( packet )
 932                                 {
 933                                         //serial_print("tx packet\n");
 934                                         tx_first[endpoint] = packet->next;
 935                                         b->addr = packet->buf;
 936                                         switch ( tx_state[ endpoint ] )
 937                                         {
 938                                         case TX_STATE_BOTH_FREE_EVEN_FIRST:
 939                                                 tx_state[ endpoint ] = TX_STATE_ODD_FREE;
 940                                                 break;
 941                                         case TX_STATE_BOTH_FREE_ODD_FIRST:
 942                                                 tx_state[ endpoint ] = TX_STATE_EVEN_FREE;
 943                                                 break;
 944                                         case TX_STATE_EVEN_FREE:
 945                                                 tx_state[ endpoint ] = TX_STATE_NONE_FREE_ODD_FIRST;
 946                                                 break;
 947                                         case TX_STATE_ODD_FREE:
 948                                                 tx_state[ endpoint ] = TX_STATE_NONE_FREE_EVEN_FIRST;
 949                                                 break;
 950                                         default:
 951                                                 break;
 952                                         }
 953                                         b->desc = BDT_DESC( packet->len, ((uint32_t)b & 8) ? DATA1 : DATA0 );
 954                                 } else {
 955                                         //serial_print("tx no packet\n");
 956                                         switch ( tx_state[ endpoint ] )
 957                                         {
 958                                         case TX_STATE_BOTH_FREE_EVEN_FIRST:
 959                                         case TX_STATE_BOTH_FREE_ODD_FIRST:
 960                                                 break;
 961                                         case TX_STATE_EVEN_FREE:
 962                                                 tx_state[ endpoint ] = TX_STATE_BOTH_FREE_EVEN_FIRST;
 963                                                 break;
 964                                         case TX_STATE_ODD_FREE:
 965                                                 tx_state[ endpoint ] = TX_STATE_BOTH_FREE_ODD_FIRST;
 966                                                 break;
 967                                         default:
 968                                                 tx_state[ endpoint ] = ((uint32_t)b & 8)
 969                                                   ? TX_STATE_ODD_FREE
 970                                                   : TX_STATE_EVEN_FREE;
 971                                                 break;
 972                                         }
 973                                 }
 974                         }
 975                         else
 976                         { // receive
 977                                 packet->len = b->desc >> 16;
 978                                 if ( packet->len > 0 )
 979                                 {
 980                                         packet->index = 0;
 981                                         packet->next = NULL;
 982                                         if ( rx_first[ endpoint ] == NULL )
 983                                         {
 984                                                 //serial_print("rx 1st, epidx=");
 985                                                 //serial_phex(endpoint);
 986                                                 //serial_print(", packet=");
 987                                                 //serial_phex32((uint32_t)packet);
 988                                                 //serial_print("\n");
 989                                                 rx_first[ endpoint ] = packet;
 990                                         }
 991                                         else
 992                                         {
 993                                                 //serial_print("rx Nth, epidx=");
 994                                                 //serial_phex(endpoint);
 995                                                 //serial_print(", packet=");
 996                                                 //serial_phex32((uint32_t)packet);
 997                                                 //serial_print("\n");
 998                                                 rx_last[ endpoint ]->next = packet;
 999                                         }
1000                                         rx_last[ endpoint ] = packet;
1001                                         usb_rx_byte_count_data[ endpoint ] += packet->len;
1002                                         // TODO: implement a per-endpoint maximum # of allocated packets
1003                                         // so a flood of incoming data on 1 endpoint doesn't starve
1004                                         // the others if the user isn't reading it regularly
1005                                         packet = usb_malloc();
1006                                         if ( packet )
1007                                         {
1008                                                 b->addr = packet->buf;
1009                                                 b->desc = BDT_DESC( 64, ((uint32_t)b & 8) ? DATA1 : DATA0 );
1010                                         }
1011                                         else
1012                                         {
1013                                                 //serial_print("starving ");
1014                                                 //serial_phex(endpoint + 1);
1015                                                 //serial_print(((uint32_t)b & 8) ? ",odd\n" : ",even\n");
1016                                                 b->desc = 0;
1017                                                 usb_rx_memory_needed++;
1018                                         }
1019                                 }
1020                                 else
1021                                 {
1022                                         b->desc = BDT_DESC( 64, ((uint32_t)b & 8) ? DATA1 : DATA0 );
1023                                 }
1024                         }
1025
1026
1027
1028
1029                 }
1030                 USB0_ISTAT = USB_ISTAT_TOKDNE;
1031                 goto restart;
1032         }
1033
1034
1035         if ( status & USB_ISTAT_USBRST /* 01 */ )
1036         {
1037                 //serial_print("reset\n");
1038
1039                 // initialize BDT toggle bits
1040                 USB0_CTL = USB_CTL_ODDRST;
1041                 ep0_tx_bdt_bank = 0;
1042
1043                 // set up buffers to receive Setup and OUT packets
1044                 table[index( 0, RX, EVEN ) ].desc = BDT_DESC( EP0_SIZE, 0 );
1045                 table[index( 0, RX, EVEN ) ].addr = ep0_rx0_buf;
1046                 table[index( 0, RX, ODD ) ].desc = BDT_DESC( EP0_SIZE, 0 );
1047                 table[index( 0, RX, ODD ) ].addr = ep0_rx1_buf;
1048                 table[index( 0, TX, EVEN ) ].desc = 0;
1049                 table[index( 0, TX, ODD ) ].desc = 0;
1050
1051                 // activate endpoint 0
1052                 USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;
1053
1054                 // clear all ending interrupts
1055                 USB0_ERRSTAT = 0xFF;
1056                 USB0_ISTAT = 0xFF;
1057
1058                 // set the address to zero during enumeration
1059                 USB0_ADDR = 0;
1060
1061                 // enable other interrupts
1062                 USB0_ERREN = 0xFF;
1063                 USB0_INTEN = USB_INTEN_TOKDNEEN |
1064                         USB_INTEN_SOFTOKEN |
1065                         USB_INTEN_STALLEN |
1066                         USB_INTEN_ERROREN |
1067                         USB_INTEN_USBRSTEN |
1068                         USB_INTEN_SLEEPEN;
1069
1070                 // is this necessary?
1071                 USB0_CTL = USB_CTL_USBENSOFEN;
1072                 return;
1073         }
1074
1075
1076         if ( (status & USB_ISTAT_STALL /* 80 */ ) )
1077         {
1078                 //serial_print("stall:\n");
1079                 USB0_ENDPT0 = USB_ENDPT_EPRXEN | USB_ENDPT_EPTXEN | USB_ENDPT_EPHSHK;
1080                 USB0_ISTAT = USB_ISTAT_STALL;
1081         }
1082         if ( (status & USB_ISTAT_ERROR /* 02 */ ) )
1083         {
1084                 uint8_t err = USB0_ERRSTAT;
1085                 USB0_ERRSTAT = err;
1086                 //serial_print("err:");
1087                 //serial_phex(err);
1088                 //serial_print("\n");
1089                 USB0_ISTAT = USB_ISTAT_ERROR;
1090         }
1091
1092         if ( (status & USB_ISTAT_SLEEP /* 10 */ ) )
1093         {
1094                 //serial_print("sleep\n");
1095                 USB0_ISTAT = USB_ISTAT_SLEEP;
1096         }
1097 }
1098
1099
1100
1101 uint8_t usb_init()
1102 {
1103         #ifdef UART_DEBUG
1104         print("USB INIT"NL);
1105         #endif
1106
1107         // If no USB cable is attached, do not initialize usb
1108         // XXX Test -HaaTa
1109         //if ( USB0_OTGISTAT & USB_OTGSTAT_ID )
1110         //      return 0;
1111
1112         // Clear out endpoints table
1113         for ( int i = 0; i <= NUM_ENDPOINTS * 4; i++ )
1114         {
1115                 table[i].desc = 0;
1116                 table[i].addr = 0;
1117         }
1118
1119         // this basically follows the flowchart in the Kinetis
1120         // Quick Reference User Guide, Rev. 1, 03/2012, page 141
1121
1122         // assume 48 MHz clock already running
1123         // SIM - enable clock
1124         SIM_SCGC4 |= SIM_SCGC4_USBOTG;
1125
1126         // reset USB module
1127         USB0_USBTRC0 = USB_USBTRC_USBRESET;
1128         while ( (USB0_USBTRC0 & USB_USBTRC_USBRESET) != 0 ); // wait for reset to end
1129
1130         // set desc table base addr
1131         USB0_BDTPAGE1 = ((uint32_t)table) >> 8;
1132         USB0_BDTPAGE2 = ((uint32_t)table) >> 16;
1133         USB0_BDTPAGE3 = ((uint32_t)table) >> 24;
1134
1135         // clear all ISR flags
1136         USB0_ISTAT = 0xFF;
1137         USB0_ERRSTAT = 0xFF;
1138         USB0_OTGISTAT = 0xFF;
1139
1140         USB0_USBTRC0 |= 0x40; // undocumented bit
1141
1142         // enable USB
1143         USB0_CTL = USB_CTL_USBENSOFEN;
1144         USB0_USBCTRL = 0;
1145
1146         // enable reset interrupt
1147         USB0_INTEN = USB_INTEN_USBRSTEN;
1148
1149         // enable interrupt in NVIC...
1150         NVIC_SET_PRIORITY( IRQ_USBOTG, 112 );
1151         NVIC_ENABLE_IRQ( IRQ_USBOTG );
1152
1153         // enable d+ pullup
1154         USB0_CONTROL = USB_CONTROL_DPPULLUPNONOTG;
1155
1156         return 1;
1157 }
1158
1159 // return 0 if the USB is not configured, or the configuration
1160 // number selected by the HOST
1161 uint8_t usb_configured()
1162 {
1163         return usb_configuration;
1164 }
1165