teensy3/usb_seremu.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 "usb_dev.h"
  33 #include "usb_seremu.h"
  34 #include "core_pins.h" // for yield()
  35 //#include "HardwareSerial.h"
  36
  37 #ifdef SEREMU_INTERFACE // defined by usb_dev.h -> usb_desc.h
  38
  39 volatile uint8_t usb_seremu_transmit_flush_timer=0;
  40
  41 static usb_packet_t *rx_packet=NULL;
  42 static usb_packet_t *tx_packet=NULL;
  43 static volatile uint8_t tx_noautoflush=0;
  44
  45 #define TRANSMIT_FLUSH_TIMEOUT  5   /* in milliseconds */
  46
  47
  48 // get the next character, or -1 if nothing received
  49 int usb_seremu_getchar(void)
  50 {
  51         unsigned int i;
  52         int c;
  53
  54         while (1) {
  55                 if (!usb_configuration) return -1;
  56                 if (!rx_packet) rx_packet = usb_rx(SEREMU_RX_ENDPOINT);
  57                 if (!rx_packet) return -1;
  58                 i = rx_packet->index;
  59                 c = rx_packet->buf[i++];
  60                 if (c) {
  61                         if (i >= rx_packet->len) {
  62                                 usb_free(rx_packet);
  63                                 rx_packet = NULL;
  64                         } else {
  65                                 rx_packet->index = i;
  66                         }
  67                         return c;
  68                 }
  69                 usb_free(rx_packet);
  70                 rx_packet = NULL;
  71         }
  72 }
  73
  74 // peek at the next character, or -1 if nothing received
  75 int usb_seremu_peekchar(void)
  76 {
  77         int c;
  78
  79         while (1) {
  80                 if (!usb_configuration) return -1;
  81                 if (!rx_packet) rx_packet = usb_rx(SEREMU_RX_ENDPOINT);
  82                 if (!rx_packet) return -1;
  83                 c = rx_packet->buf[rx_packet->index];
  84                 if (c) return c;
  85                 usb_free(rx_packet);
  86                 rx_packet = NULL;
  87         }
  88 }
  89
  90 // number of bytes available in the receive buffer
  91 int usb_seremu_available(void)
  92 {
  93         int i, len, count;
  94
  95         if (!rx_packet) {
  96                 if (usb_configuration) rx_packet = usb_rx(SEREMU_RX_ENDPOINT);
  97                 if (!rx_packet) return 0;
  98         }
  99         len = rx_packet->len;
 100         i = rx_packet->index;
 101         count = 0;
 102         for (i = rx_packet->index; i < len; i++) {
 103                 if (rx_packet->buf[i] == 0) break;
 104                 count++;
 105         }
 106         if (count == 0) {
 107                 usb_free(rx_packet);
 108                 rx_packet = NULL;
 109         }
 110         return count;
 111 }
 112
 113
 114 // discard any buffered input
 115 void usb_seremu_flush_input(void)
 116 {
 117         usb_packet_t *rx;
 118
 119         if (!usb_configuration) return;
 120         if (rx_packet) {
 121                 usb_free(rx_packet);
 122                 rx_packet = NULL;
 123         }
 124         while (1) {
 125                 rx = usb_rx(SEREMU_RX_ENDPOINT);
 126                 if (!rx) break;
 127                 usb_free(rx);
 128         }
 129 }
 130
 131
 132
 133 // Maximum number of transmit packets to queue so we don't starve other endpoints for memory
 134 #define TX_PACKET_LIMIT 6
 135
 136 // When the PC isn't listening, how long do we wait before discarding data?  If this is
 137 // too short, we risk losing data during the stalls that are common with ordinary desktop
 138 // software.  If it's too long, we stall the user's program when no software is running.
 139 #define TX_TIMEOUT_MSEC 30
 140
 141 #if F_CPU == 96000000
 142   #define TX_TIMEOUT (TX_TIMEOUT_MSEC * 596)
 143 #elif F_CPU == 48000000
 144   #define TX_TIMEOUT (TX_TIMEOUT_MSEC * 428)
 145 #elif F_CPU == 24000000
 146   #define TX_TIMEOUT (TX_TIMEOUT_MSEC * 262)
 147 #endif
 148
 149 // When we've suffered the transmit timeout, don't wait again until the computer
 150 // begins accepting data.  If no software is running to receive, we'll just discard
 151 // data as rapidly as Serial.print() can generate it, until there's something to
 152 // actually receive it.
 153 static uint8_t transmit_previous_timeout=0;
 154
 155
 156 // transmit a character.  0 returned on success, -1 on error
 157 int usb_seremu_putchar(uint8_t c)
 158 {
 159         return usb_seremu_write(&c, 1);
 160 }
 161
 162
 163 int usb_seremu_write(const void *buffer, uint32_t size)
 164 {
 165 #if 1
 166         uint32_t len;
 167         uint32_t wait_count;
 168         const uint8_t *src = (const uint8_t *)buffer;
 169         uint8_t *dest;
 170
 171         tx_noautoflush = 1;
 172         while (size > 0) {
 173                 if (!tx_packet) {
 174                         wait_count = 0;
 175                         while (1) {
 176                                 if (!usb_configuration) {
 177                                         tx_noautoflush = 0;
 178                                         return -1;
 179                                 }
 180                                 if (usb_tx_packet_count(SEREMU_TX_ENDPOINT) < TX_PACKET_LIMIT) {
 181                                         tx_noautoflush = 1;
 182                                         tx_packet = usb_malloc();
 183                                         if (tx_packet) break;
 184                                 }
 185                                 if (++wait_count > TX_TIMEOUT || transmit_previous_timeout) {
 186                                         transmit_previous_timeout = 1;
 187                                         tx_noautoflush = 0;
 188                                         return -1;
 189                                 }
 190                                 tx_noautoflush = 0;
 191                                 yield();
 192                                 tx_noautoflush = 1;
 193                         }
 194                 }
 195                 transmit_previous_timeout = 0;
 196                 len = SEREMU_TX_SIZE - tx_packet->index;
 197                 if (len > size) len = size;
 198                 dest = tx_packet->buf + tx_packet->index;
 199                 tx_packet->index += len;
 200                 size -= len;
 201                 while (len-- > 0) *dest++ = *src++;
 202                 if (tx_packet->index < SEREMU_TX_SIZE) {
 203                         usb_seremu_transmit_flush_timer = TRANSMIT_FLUSH_TIMEOUT;
 204                 } else {
 205                         tx_packet->len = SEREMU_TX_SIZE;
 206                         usb_seremu_transmit_flush_timer = 0;
 207                         usb_tx(SEREMU_TX_ENDPOINT, tx_packet);
 208                         tx_packet = NULL;
 209                 }
 210         }
 211         tx_noautoflush = 0;
 212         return 0;
 213 #endif
 214 }
 215
 216 void usb_seremu_flush_output(void)
 217 {
 218         int i;
 219
 220         if (!usb_configuration) return;
 221         //serial_print("usb_serial_flush_output\n");
 222         if (tx_packet && tx_packet->index > 0) {
 223                 usb_seremu_transmit_flush_timer = 0;
 224                 for (i = tx_packet->index; i < SEREMU_TX_SIZE; i++) {
 225                         tx_packet->buf[i] = 0;
 226                 }
 227                 tx_packet->len = SEREMU_TX_SIZE;
 228                 usb_tx(SEREMU_TX_ENDPOINT, tx_packet);
 229                 tx_packet = NULL;
 230         }
 231         // while (usb_tx_byte_count(SEREMU_TX_ENDPOINT) > 0) ; // wait
 232 }
 233
 234 void usb_seremu_flush_callback(void)
 235 {
 236         int i;
 237         //serial_print("C");
 238         if (tx_noautoflush) return;
 239         //serial_print("usb_flush_callback \n");
 240         for (i = tx_packet->index; i < SEREMU_TX_SIZE; i++) {
 241                 tx_packet->buf[i] = 0;
 242         }
 243         tx_packet->len = SEREMU_TX_SIZE;
 244         usb_tx(SEREMU_TX_ENDPOINT, tx_packet);
 245         tx_packet = NULL;
 246         //serial_print("usb_flush_callback end\n");
 247 }
 248
 249 #endif // SEREMU_INTERFACE