teensy3/usb_dev.c

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