| 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 | |