261 lines
7.2 KiB
C++
261 lines
7.2 KiB
C++
/******************************************************************************
|
|
* The MIT License
|
|
*
|
|
* Copyright (c) 2010 Perry Hung.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use, copy,
|
|
* modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
* of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*****************************************************************************/
|
|
|
|
/**
|
|
* @brief USB virtual serial terminal
|
|
*/
|
|
|
|
#include <wirish/usb_serial.h>
|
|
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
|
|
#include <libmaple/nvic.h>
|
|
#include <libmaple/usb_cdcacm.h>
|
|
#include <libmaple/usb.h>
|
|
|
|
#include <wirish/wirish.h>
|
|
|
|
/*
|
|
* Hooks used for bootloader reset signalling
|
|
*/
|
|
|
|
#if BOARD_HAVE_SERIALUSB
|
|
static void rxHook(unsigned, void*);
|
|
static void ifaceSetupHook(unsigned, void*);
|
|
#endif
|
|
|
|
/*
|
|
* USBSerial interface
|
|
*/
|
|
|
|
#define USB_TIMEOUT 50
|
|
|
|
USBSerial::USBSerial(void) {
|
|
#if !BOARD_HAVE_SERIALUSB
|
|
ASSERT(0);
|
|
#endif
|
|
}
|
|
|
|
void USBSerial::begin(void) {
|
|
#if BOARD_HAVE_SERIALUSB
|
|
usb_cdcacm_enable(BOARD_USB_DISC_DEV, BOARD_USB_DISC_BIT);
|
|
usb_cdcacm_set_hooks(USB_CDCACM_HOOK_RX, rxHook);
|
|
usb_cdcacm_set_hooks(USB_CDCACM_HOOK_IFACE_SETUP, ifaceSetupHook);
|
|
#endif
|
|
}
|
|
|
|
void USBSerial::end(void) {
|
|
#if BOARD_HAVE_SERIALUSB
|
|
usb_cdcacm_disable(BOARD_USB_DISC_DEV, BOARD_USB_DISC_BIT);
|
|
usb_cdcacm_remove_hooks(USB_CDCACM_HOOK_RX | USB_CDCACM_HOOK_IFACE_SETUP);
|
|
#endif
|
|
}
|
|
|
|
void USBSerial::write(uint8 ch) {
|
|
this->write(&ch, 1);
|
|
}
|
|
|
|
void USBSerial::write(const char *str) {
|
|
this->write(str, strlen(str));
|
|
}
|
|
|
|
void USBSerial::write(const void *buf, uint32 len) {
|
|
if (!this->isConnected() || !buf) {
|
|
return;
|
|
}
|
|
|
|
uint32 txed = 0;
|
|
uint32 old_txed = 0;
|
|
uint32 start = millis();
|
|
|
|
uint32 sent = 0;
|
|
|
|
while (txed < len && (millis() - start < USB_TIMEOUT)) {
|
|
sent = usb_cdcacm_tx((const uint8*)buf + txed, len - txed);
|
|
txed += sent;
|
|
if (old_txed != txed) {
|
|
start = millis();
|
|
}
|
|
old_txed = txed;
|
|
}
|
|
|
|
|
|
if (sent == USB_CDCACM_TX_EPSIZE) {
|
|
while (usb_cdcacm_is_transmitting() != 0) {
|
|
}
|
|
/* flush out to avoid having the pc wait for more data */
|
|
usb_cdcacm_tx(NULL, 0);
|
|
}
|
|
}
|
|
|
|
uint32 USBSerial::available(void) {
|
|
return usb_cdcacm_data_available();
|
|
}
|
|
|
|
uint32 USBSerial::read(void *buf, uint32 len) {
|
|
if (!buf) {
|
|
return 0;
|
|
}
|
|
|
|
uint32 rxed = 0;
|
|
while (rxed < len) {
|
|
rxed += usb_cdcacm_rx((uint8*)buf + rxed, len - rxed);
|
|
}
|
|
|
|
return rxed;
|
|
}
|
|
|
|
/* Blocks forever until 1 byte is received */
|
|
uint8 USBSerial::read(void) {
|
|
uint8 b;
|
|
this->read(&b, 1);
|
|
return b;
|
|
}
|
|
|
|
uint8 USBSerial::pending(void) {
|
|
return usb_cdcacm_get_pending();
|
|
}
|
|
|
|
uint8 USBSerial::isConnected(void) {
|
|
return usb_is_connected(USBLIB) && usb_is_configured(USBLIB);
|
|
}
|
|
|
|
uint8 USBSerial::getDTR(void) {
|
|
return usb_cdcacm_get_dtr();
|
|
}
|
|
|
|
uint8 USBSerial::getRTS(void) {
|
|
return usb_cdcacm_get_rts();
|
|
}
|
|
|
|
#if BOARD_HAVE_SERIALUSB
|
|
USBSerial SerialUSB;
|
|
#endif
|
|
|
|
/*
|
|
* Bootloader hook implementations
|
|
*/
|
|
|
|
#if BOARD_HAVE_SERIALUSB
|
|
|
|
enum reset_state_t {
|
|
DTR_UNSET,
|
|
DTR_HIGH,
|
|
DTR_NEGEDGE,
|
|
DTR_LOW
|
|
};
|
|
|
|
static reset_state_t reset_state = DTR_UNSET;
|
|
|
|
static void ifaceSetupHook(unsigned hook, void *requestvp) {
|
|
uint8 request = *(uint8*)requestvp;
|
|
|
|
// Ignore requests we're not interested in.
|
|
if (request != USB_CDCACM_SET_CONTROL_LINE_STATE) {
|
|
return;
|
|
}
|
|
|
|
// We need to see a negative edge on DTR before we start looking
|
|
// for the in-band magic reset byte sequence.
|
|
uint8 dtr = usb_cdcacm_get_dtr();
|
|
switch (reset_state) {
|
|
case DTR_UNSET:
|
|
reset_state = dtr ? DTR_HIGH : DTR_LOW;
|
|
break;
|
|
case DTR_HIGH:
|
|
reset_state = dtr ? DTR_HIGH : DTR_NEGEDGE;
|
|
break;
|
|
case DTR_NEGEDGE:
|
|
reset_state = dtr ? DTR_HIGH : DTR_LOW;
|
|
break;
|
|
case DTR_LOW:
|
|
reset_state = dtr ? DTR_HIGH : DTR_LOW;
|
|
break;
|
|
}
|
|
}
|
|
|
|
#define RESET_DELAY 100000
|
|
static void wait_reset(void) {
|
|
delay_us(RESET_DELAY);
|
|
nvic_sys_reset();
|
|
}
|
|
|
|
#define STACK_TOP 0x20000800
|
|
#define EXC_RETURN 0xFFFFFFF9
|
|
#define DEFAULT_CPSR 0x61000000
|
|
static void rxHook(unsigned hook, void *ignored) {
|
|
/* FIXME this is mad buggy; we need a new reset sequence. E.g. NAK
|
|
* after each RX means you can't reset if any bytes are waiting. */
|
|
if (reset_state == DTR_NEGEDGE) {
|
|
reset_state = DTR_LOW;
|
|
|
|
if (usb_cdcacm_data_available() >= 4) {
|
|
// The magic reset sequence is "1EAF".
|
|
static const uint8 magic[4] = {'1', 'E', 'A', 'F'};
|
|
uint8 chkBuf[4];
|
|
|
|
// Peek at the waiting bytes, looking for reset sequence,
|
|
// bailing on mismatch.
|
|
usb_cdcacm_peek(chkBuf, 4);
|
|
for (unsigned i = 0; i < sizeof(magic); i++) {
|
|
if (chkBuf[i] != magic[i]) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Got the magic sequence -> reset, presumably into the bootloader.
|
|
// Return address is wait_reset, but we must set the thumb bit.
|
|
uintptr_t target = (uintptr_t)wait_reset | 0x1;
|
|
asm volatile("mov r0, %[stack_top] \n\t" // Reset stack
|
|
"mov sp, r0 \n\t"
|
|
"mov r0, #1 \n\t"
|
|
"mov r1, %[target_addr] \n\t"
|
|
"mov r2, %[cpsr] \n\t"
|
|
"push {r2} \n\t" // Fake xPSR
|
|
"push {r1} \n\t" // PC target addr
|
|
"push {r0} \n\t" // Fake LR
|
|
"push {r0} \n\t" // Fake R12
|
|
"push {r0} \n\t" // Fake R3
|
|
"push {r0} \n\t" // Fake R2
|
|
"push {r0} \n\t" // Fake R1
|
|
"push {r0} \n\t" // Fake R0
|
|
"mov lr, %[exc_return] \n\t"
|
|
"bx lr"
|
|
:
|
|
: [stack_top] "r" (STACK_TOP),
|
|
[target_addr] "r" (target),
|
|
[exc_return] "r" (EXC_RETURN),
|
|
[cpsr] "r" (DEFAULT_CPSR)
|
|
: "r0", "r1", "r2");
|
|
/* Can't happen. */
|
|
ASSERT_FAULT(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // BOARD_HAVE_SERIALUSB
|