Fix bugs in PL2303 emulation

F1-nolib/PL2303/Makefile

@@ -10,7 +10,7 @@ DENSITY 	?= MD
 # change this linking script depending on particular MCU model,
 LDSCRIPT	?= stm32f103x8.ld
 # debug
-DEFS		= -DEBUG
+#DEFS		= -DEBUG
 
 INDEPENDENT_HEADERS=
 

F1-nolib/PL2303/main.c

@@ -20,6 +20,7 @@
  */
 
 #include "hardware.h"
+#include "usart.h"
 #include "usb.h"
 #include "usb_lib.h"
 
@@ -53,31 +54,32 @@ void iwdg_setup(){
     IWDG->KR = IWDG_REFRESH; /* (6) */
 }
 
-char *parse_cmd(char *buf){
+#define USND(str)  do{USB_send((uint8_t*)str, sizeof(str)-1);}while(0)
+static const char *parse_cmd(const char *buf){
     if(buf[1] != '\n') return buf;
     switch(*buf){
         case 'p':
             pin_toggle(USBPU_port, USBPU_pin);
-            USB_send("USB pullup is ");
+            USND("USB pullup is ");
-            if(pin_read(USBPU_port, USBPU_pin)) USB_send("off\n");
+            if(pin_read(USBPU_port, USBPU_pin)) USND("off\n");
-            else USB_send("on\n");
+            else USND("on\n");
             return NULL;
         break;
         case 'L':
-            USB_send("Very long test string for USB (it's length is more than 64 bytes).\n"
+            USND("Very long test string for USB (it's length is more than 64 bytes).\n"
                      "This is another part of the string! Can you see all of this?\n");
             return "OK\n";
         break;
         case 'R':
-            USB_send("Soft reset\n");
+            USND("Soft reset\n");
             NVIC_SystemReset();
         break;
         case 'S':
-            USB_send("Test string for USB\n");
+            USND("Test string for USB\n");
             return "OK\n";
         break;
         case 'W':
-            USB_send("Wait for reboot\n");
+            USND("Wait for reboot\n");
             while(1){nop();};
         break;
         default: // help
@@ -97,10 +99,16 @@ char *parse_cmd(char *buf){
 char *get_USB(){
     static char tmpbuf[512], *curptr = tmpbuf;
     static int rest = 511;
-    int x = USB_receive(curptr, rest);
+    uint8_t x = USB_receive((uint8_t*)curptr);
     curptr[x] = 0;
     if(!x) return NULL;
     if(curptr[x-1] == '\n'){
+#ifdef EBUG
+        DBG("fullline");
+        IWDG->KR = IWDG_REFRESH;
+        SEND(tmpbuf);
+        transmit_tbuf();
+#endif
         curptr = tmpbuf;
         rest = 511;
         return tmpbuf;
@@ -119,13 +127,15 @@ int main(void){
     StartHSE();
     hw_setup();
     SysTick_Config(72000);
-/*
+
+    usart_setup();
+    DBG("Start");
     if(RCC->CSR & RCC_CSR_IWDGRSTF){ // watchdog reset occured
-        SEND("WDGRESET=1\n");
+        SEND("WDGRESET=1"); newline();
     }
     if(RCC->CSR & RCC_CSR_SFTRSTF){ // software reset occured
-        SEND("SOFTRESET=1\n");
+        SEND("SOFTRESET=1"); newline();
-    }*/
+    }
     RCC->CSR |= RCC_CSR_RMVF; // remove reset flags
 
     USBPU_OFF();
@@ -138,14 +148,25 @@ int main(void){
         if(lastT > Tms || Tms - lastT > 499){
             LED_blink(LED0);
             lastT = Tms;
+            USND("tick\n");
+            transmit_tbuf();
         }
         usb_proc();
         char *txt, *ans;
         if((txt = get_USB())){
-            ans = parse_cmd(txt);
+            IWDG->KR = IWDG_REFRESH;
-            if(ans) USB_send(ans);
+#ifdef EBUG
+            SEND("Got data: ");
+            SEND(txt); newline();
+            transmit_tbuf();
+#endif
+            ans = (char*)parse_cmd(txt);
+            if(ans){
+                uint16_t l = 0; char *p = ans;
+                while(*p++) l++;
+                USB_send((uint8_t*)ans, l);
+            }
         }
     }
     return 0;
 }
-

F1-nolib/PL2303/usart.c

@@ -0,0 +1,267 @@
+/*
+ * usart.c
+ *
+ * Copyright 2018 Edward V. Emelianoff <eddy@sao.ru, edward.emelianoff@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+#include "stm32f1.h"
+#include "usart.h"
+#include "usb.h"
+
+extern volatile uint32_t Tms;
+static volatile int idatalen[2] = {0,0}; // received data line length (including '\n')
+static volatile int odatalen[2] = {0,0};
+
+static int dlen = 0; // length of data (including '\n') in current buffer
+
+int linerdy = 0,        // received data ready
+    bufovr = 0,         // input buffer overfull
+    txrdy = 1           // transmission done
+;
+
+static int rbufno = 0, tbufno = 0; // current rbuf/tbuf numbers
+static uint8_t rbuf[2][UARTBUFSZI], tbuf[2][UARTBUFSZO]; // receive & transmit buffers
+static uint8_t *recvdata = NULL;
+
+/**
+ * return length of received data (without trailing zero)
+ */
+uint16_t usart_get(uint8_t **line){
+    if(!line) return 0;
+    *line = NULL;
+    if(bufovr){
+        bufovr = 0;
+        linerdy = 0;
+        return 0;
+    }
+    if(!linerdy) return 0;
+    USART1->CR1 &= ~USART_CR1_RXNEIE; // disallow Rx IRQ
+    dlen = idatalen[rbufno];
+    recvdata = rbuf[rbufno];
+    // prepare other buffer
+    rbufno = !rbufno;
+    idatalen[rbufno] = 0;
+    recvdata[dlen] = 0;
+    *line = recvdata;
+    linerdy = 0;
+    USART1->CR1 |= USART_CR1_RXNEIE; // allow Rx IRQ
+    return dlen;
+}
+
+// transmit current tbuf and swap buffers
+int transmit_tbuf(){
+    uint32_t tmout = 7200;
+    while(!txrdy){ // wait for previos buffer transmission
+        IWDG->KR = IWDG_REFRESH;
+        if(--tmout == 0){
+            //DMA1_Channel4->CCR &= ~DMA_CCR_EN;
+            //txrdy = 1;
+            return 1;
+        }
+    }
+    int l = odatalen[tbufno];
+    if(!l){
+        return 0;
+    }
+    DMA1_Channel4->CCR &= ~DMA_CCR_EN;
+    DMA1_Channel4->CMAR = (uint32_t) tbuf[tbufno]; // mem
+    DMA1_Channel4->CNDTR = l;
+    tbufno = !tbufno;
+    odatalen[tbufno] = 0;
+    txrdy = 0;
+    DMA1_Channel4->CCR |= DMA_CCR_EN;
+    return 0;
+}
+
+void usart_putchar(const char ch){
+    tbuf[tbufno][odatalen[tbufno]++] = ch;
+    if(odatalen[tbufno] >= UARTBUFSZO){
+        while(transmit_tbuf()) IWDG->KR = IWDG_REFRESH;
+    }
+}
+
+void usart_send(const char *str){
+    if(!str) return;
+    while(*str){
+        tbuf[tbufno][odatalen[tbufno]++] = *str++;
+        if(odatalen[tbufno] >= UARTBUFSZO){
+            while(transmit_tbuf()) IWDG->KR = IWDG_REFRESH;
+        }
+    }
+}
+
+/**
+ * @brief usart_senddata - the same as usart_send, but with given length
+ */
+void usart_senddata(const uint8_t *str, uint16_t len){
+    while(len--){
+        tbuf[tbufno][odatalen[tbufno]++] = *str++;
+        if(odatalen[tbufno] >= UARTBUFSZO){
+            while(transmit_tbuf()) IWDG->KR = IWDG_REFRESH;
+        }
+    }
+}
+
+void newline(){
+    usart_putchar('\n');
+}
+
+/*
+ * USART speed: baudrate = Fck/(USARTDIV)
+ * USARTDIV stored in USART->BRR
+ *
+ * for 72MHz USARTDIV=72000/f(kboud); so for 115200 USARTDIV=72000/115.2=625 -> BRR=0x271
+ *         9600: BRR = 7500 (0x1D4C)
+ */
+
+void usart_setup(){
+    uint32_t tmout = 16000000;
+    // PA9 - Tx, PA10 - Rx 
+    RCC->APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_USART1EN | RCC_APB2ENR_AFIOEN;
+    RCC->AHBENR |= RCC_AHBENR_DMA1EN;
+    GPIOA->CRH = CRH(9, CNF_AFPP|MODE_NORMAL) | CRH(10, CNF_FLINPUT|MODE_INPUT); 
+
+    // USART1 Tx DMA - Channel4 (Rx - channel 5)
+    DMA1_Channel4->CPAR = (uint32_t) &USART1->DR; // periph
+    DMA1_Channel4->CCR |= DMA_CCR_MINC | DMA_CCR_DIR | DMA_CCR_TCIE; // 8bit, mem++, mem->per, transcompl irq
+    // Tx CNDTR set @ each transmission due to data size
+    NVIC_SetPriority(DMA1_Channel4_IRQn, 3);
+    NVIC_EnableIRQ(DMA1_Channel4_IRQn);
+    NVIC_SetPriority(USART1_IRQn, 0);
+    // setup usart1
+    USART1->BRR = 72000000 / 115200;
+    //USART1->BRR = 24; // 3000000
+    USART1->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_UE; // 1start,8data,nstop; enable Rx,Tx,USART
+    while(!(USART1->SR & USART_SR_TC)){ // polling idle frame Transmission
+        IWDG->KR = IWDG_REFRESH;
+        if(--tmout == 0) break;
+    }
+    USART1->SR = 0; // clear flags
+    USART1->CR1 |= USART_CR1_RXNEIE; // allow Rx IRQ
+    USART1->CR3 = USART_CR3_DMAT; // enable DMA Tx
+    NVIC_EnableIRQ(USART1_IRQn);
+}
+
+
+void usart1_isr(){
+    #ifdef CHECK_TMOUT
+    static uint32_t tmout = 0;
+    #endif
+    if(USART1->SR & USART_SR_RXNE){ // RX not emty - receive next char
+        #ifdef CHECK_TMOUT
+        if(tmout && Tms >= tmout){ // set overflow flag
+            bufovr = 1;
+            idatalen[rbufno] = 0;
+        }
+        tmout = Tms + TIMEOUT_MS;
+        if(!tmout) tmout = 1; // prevent 0
+        #endif
+        uint8_t rb = USART1->DR;
+        if(idatalen[rbufno] < UARTBUFSZI){ // put next char into buf
+            rbuf[rbufno][idatalen[rbufno]++] = rb;
+            linerdy = 1; // ready for reading
+            #ifdef CHECK_TMOUT
+            // clear timeout at line end
+            tmout = 0;
+            #endif
+        }else{ // buffer overrun
+            bufovr = 1;
+            idatalen[rbufno] = 0;
+            #ifdef CHECK_TMOUT
+            tmout = 0;
+            #endif
+        }
+    }
+}
+
+
+// print 32bit unsigned int
+void printu(uint32_t val){
+    char bufa[11], bufb[10];
+    int l = 0, bpos = 0;
+    if(!val){
+        bufa[0] = '0';
+        l = 1;
+    }else{
+        while(val){
+            bufb[l++] = val % 10 + '0';
+            val /= 10;
+        }
+        int i;
+        bpos += l;
+        for(i = 0; i < l; ++i){
+            bufa[--bpos] = bufb[i];
+        }
+    }
+    bufa[l + bpos] = 0;
+    IWDG->KR = IWDG_REFRESH;
+    usart_send(bufa);
+}
+
+// print 32bit unsigned int as hex
+void printuhex(uint32_t val){
+    usart_send("0x");
+    uint8_t *ptr = (uint8_t*)&val + 3;
+    int i, j;
+    for(i = 0; i < 4; ++i, --ptr){
+        for(j = 1; j > -1; --j){
+            register uint8_t half = (*ptr >> (4*j)) & 0x0f;
+            if(half < 10) usart_putchar(half + '0');
+            else usart_putchar(half - 10 + 'a');
+        }
+        IWDG->KR = IWDG_REFRESH;
+    }
+}
+/*
+// dump memory buffer
+void hexdump(const uint8_t *arr, uint16_t len){
+    for(uint16_t l = 0; l < len; ++l, ++arr){
+        for(int16_t j = 1; j > -1; --j){
+            register uint8_t half = (*arr >> (4*j)) & 0x0f;
+            if(half < 10) usart_putchar(half + '0');
+            else usart_putchar(half - 10 + 'a');
+        }
+        if(l % 16 == 15) usart_putchar('\n');
+        else if(l & 1) usart_putchar(' ');
+    }
+}
+*/
+void dma1_channel4_isr(){
+    DMA1->IFCR = DMA_IFCR_CTCIF4; // clear TC flag
+    txrdy = 1;
+}
+
+/*
+#if USARTNUM == 2
+void dma1_channel4_5_isr(){
+    if(DMA1->ISR & DMA_ISR_TCIF4){ // Tx
+        DMA1->IFCR |= DMA_IFCR_CTCIF4; // clear TC flag
+        txrdy = 1;
+    }
+}
+// USART1
+#elif USARTNUM == 1
+void dma1_channel2_3_isr(){
+    if(DMA1->ISR & DMA_ISR_TCIF2){ // Tx
+        DMA1->IFCR |= DMA_IFCR_CTCIF2; // clear TC flag
+        txrdy = 1;
+    }
+}
+#else
+#error "Not implemented"
+#endif
+*/

F1-nolib/PL2303/usart.h

@@ -0,0 +1,67 @@
+/*
+ * usart.h
+ *
+ * Copyright 2018 Edward V. Emelianoff <eddy@sao.ru, edward.emelianoff@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#pragma once
+#ifndef __USART_H__
+#define __USART_H__
+
+#include <stdint.h>
+
+// input and output buffers size
+#define UARTBUFSZI  (64)
+#define UARTBUFSZO  (64)
+// timeout between data bytes
+#ifndef TIMEOUT_MS
+#define TIMEOUT_MS (1500)
+#endif
+
+// macro for static strings
+#define SEND(str) usart_send(str)
+#define _s(s)   #s
+#define STR(s)  _s(s)
+
+#ifdef EBUG
+#define DBG(str)  do{SEND(__FILE__ " (L" STR(__LINE__) "): " str); newline();}while(0)
+#define HERE()    do{SEND(STR(__LINE__)); usart_putchar('\n');}while(0)
+#define MSG(str)  do{SEND(str); usart_putchar('\n');}while(0)
+#else
+#define MSG(str)
+#define HERE()
+#define DBG(str)
+#endif
+
+#define usartrx()  (linerdy)
+#define usartovr() (bufovr)
+
+extern int linerdy, bufovr, txrdy;
+
+int transmit_tbuf();
+void usart_setup();
+uint16_t usart_get(uint8_t **line);
+void usart_send(const char *str);
+void usart_senddata(const uint8_t *str, uint16_t len);
+void newline();
+void usart_putchar(const char ch);
+void printu(uint32_t val);
+void printuhex(uint32_t val);
+void hexdump(const uint8_t *arr, uint16_t len);
+
+#endif // __USART_H__

F1-nolib/PL2303/usb.c

@@ -20,53 +20,36 @@
  * MA 02110-1301, USA.
  *
  */
+#include "usart.h"
 #include "usb.h"
 #include "usb_lib.h"
 
-// incoming buffer size
+static volatile uint8_t tx_succesfull = 1;
-#define IDATASZ     (256)
+static volatile uint8_t rxNE = 0;
-static uint8_t incoming_data[IDATASZ];
-static uint8_t ovfl = 0;
-static uint16_t idatalen = 0;
-static volatile uint8_t tx_succesfull = 0;
-static int8_t usbON = 0; // ==1 when USB fully configured
 
 // interrupt IN handler (never used?)
-static uint16_t EP1_Handler(ep_t ep){
+static void EP1_Handler(){
-    if (ep.rx_flag){
+    uint16_t epstatus = KEEP_DTOG(USB->EPnR[1]);
-        ep.status = SET_VALID_TX(ep.status);
+    if(RX_FLAG(epstatus)) epstatus = (epstatus & ~USB_EPnR_STAT_TX) ^ USB_EPnR_STAT_RX; // set valid RX
-        ep.status = KEEP_STAT_RX(ep.status);
+    else epstatus = epstatus & ~(USB_EPnR_STAT_TX|USB_EPnR_STAT_RX);
-    }else if (ep.tx_flag){
+    // clear CTR
-        ep.status = SET_VALID_RX(ep.status);
+    epstatus = (epstatus & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX));
-        ep.status = SET_STALL_TX(ep.status);
+    USB->EPnR[1] = epstatus;
-    }
-    return ep.status;
 }
 
-// data IN/OUT handler
+// data IN/OUT handlers
-static uint16_t EP23_Handler(ep_t ep){
+static void transmit_Handler(){ // EP3IN
-    if(ep.rx_flag){
-        int rd = ep.rx_cnt, rest = IDATASZ - idatalen;
-        if(rd){
-            if(rd <= rest){
-                idatalen += EP_Read(2, (uint16_t*)&incoming_data[idatalen]);
-                ovfl = 0;
-            }else{
-                ep.status = SET_NAK_RX(ep.status);
-                ovfl = 1;
-                return ep.status;
-            }
-        }
-        // end of transaction: clear DTOGs
-        ep.status = CLEAR_DTOG_RX(ep.status);
-        ep.status = CLEAR_DTOG_TX(ep.status);
-        ep.status = SET_STALL_TX(ep.status);
-    }else if (ep.tx_flag){
-        ep.status = KEEP_STAT_TX(ep.status);
     tx_succesfull = 1;
+    uint16_t epstatus = KEEP_DTOG_STAT(USB->EPnR[3]);
+    // clear CTR keep DTOGs & STATs
+    USB->EPnR[3] = (epstatus & ~(USB_EPnR_CTR_TX)); // clear TX ctr
 }
-    ep.status = SET_VALID_RX(ep.status);
+
-    return ep.status;
+static void receive_Handler(){ // EP2OUT
+    rxNE = 1;
+    uint16_t epstatus = KEEP_DTOG_STAT(USB->EPnR[2]);
+    USB->EPnR[2] = (epstatus & ~(USB_EPnR_CTR_RX)); // clear RX ctr
+    DBG("RXh");
 }
 
 void USB_setup(){
@@ -82,84 +65,103 @@ void USB_setup(){
     USB->ISTR   = 0;
     USB->CNTR   = USB_CNTR_RESETM | USB_CNTR_WKUPM; // allow only wakeup & reset interrupts
     NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn);
-    NVIC_EnableIRQ(USB_HP_CAN1_TX_IRQn );
+}
+
+static int usbwr(const uint8_t *buf, uint16_t l){
+    uint32_t ctra = 1000000;
+    while(--ctra && tx_succesfull == 0){
+        IWDG->KR = IWDG_REFRESH;
+    }
+    tx_succesfull = 0;
+    EP_Write(3, buf, l);
+    ctra = 1000000;
+    while(--ctra && tx_succesfull == 0){
+        IWDG->KR = IWDG_REFRESH;
+    }
+    if(tx_succesfull == 0){usbON = 0; return 1;} // usb is OFF?
+    return 0;
+}
+
+static uint8_t usbbuff[USB_TXBUFSZ-1]; // temporary buffer (63 - to prevent need of ZLP)
+static uint8_t buflen = 0; // amount of symbols in usbbuff
+
+// send next up to 63 bytes of data in usbbuff
+static void send_next(){
+    if(!buflen || !tx_succesfull) return;
+    tx_succesfull = 0;
+    EP_Write(3, usbbuff, buflen);
+    buflen = 0;
+}
+
+// unblocking sending - just fill a buffer
+void USB_send(const uint8_t *buf, uint16_t len){
+    if(!usbON || !len) return;
+    if(len > USB_TXBUFSZ-1 - buflen){
+        usbwr(usbbuff, buflen);
+        buflen = 0;
+    }
+    if(len > USB_TXBUFSZ-1){
+        USB_send_blk(buf, len);
+        return;
+    }
+    while(len--) usbbuff[buflen++] = *buf++;
+}
+
+// blocking sending
+void USB_send_blk(const uint8_t *buf, uint16_t len){
+    if(!usbON || !len) return; // USB disconnected
+    if(buflen){
+        usbwr(usbbuff, buflen);
+        buflen = 0;
+    }
+    int needzlp = 0;
+    while(len){
+        if(len == USB_TXBUFSZ) needzlp = 1;
+        uint16_t s = (len > USB_TXBUFSZ) ? USB_TXBUFSZ : len;
+        if(usbwr(buf, s)) return;
+        len -= s;
+        buf += s;
+    }
+    if(needzlp){
+        usbwr(NULL, 0);
+    }
 }
 
 void usb_proc(){
-    if(USB_GetState() == USB_CONFIGURE_STATE){ // USB configured - activate other endpoints
+    switch(USB_Dev.USB_Status){
-        if(!usbON){ // endpoints not activated
+        case USB_STATE_CONFIGURED:
             // make new BULK endpoint
             // Buffer have 1024 bytes, but last 256 we use for CAN bus (30.2 of RM: USB main features)
-            EP_Init(1, EP_TYPE_INTERRUPT, 10, 0, EP1_Handler); // IN1 - transmit
+            EP_Init(1, EP_TYPE_INTERRUPT, USB_EP1BUFSZ, 0, EP1_Handler); // IN1 - transmit
-            EP_Init(2, EP_TYPE_BULK, 0, USB_RXBUFSZ, EP23_Handler); // OUT2 - receive data
+            EP_Init(2, EP_TYPE_BULK, 0, USB_RXBUFSZ, receive_Handler); // OUT2 - receive data
-            EP_Init(3, EP_TYPE_BULK, USB_TXBUFSZ, 0, EP23_Handler); // IN3 - transmit data
+            EP_Init(3, EP_TYPE_BULK, USB_TXBUFSZ, 0, transmit_Handler); // IN3 - transmit data
-            usbON = 1;
+            USB_Dev.USB_Status = USB_STATE_CONNECTED;
-        }
+        break;
-    }else{
+        case USB_STATE_DEFAULT:
+        case USB_STATE_ADDRESSED:
+            if(usbON){
                 usbON = 0;
             }
-}
+        break;
-
+        default: // USB_STATE_CONNECTED - send next data portion
-void USB_send(const char *buf){
+            if(!usbON) return;
-    if(!USB_configured()){
+            send_next();
-        return;
-    }
-    char tmpbuf[USB_TXBUFSZ];
-    uint16_t l = 0, ctr = 0;
-    const char *p = buf;
-    while(*p++) ++l;
-    while(l){
-        uint16_t proc = 0, s  = (l > USB_TXBUFSZ - 1) ? USB_TXBUFSZ - 1: l;
-        for(int i = 0; i < s; ++i, ++proc){
-            char c = buf[ctr+proc];
-            /*
-            if(c == '\n' && the_conf.defflags & FLAG_STRENDRN){ // add '\r' before '\n'
-                tmpbuf[i++] = '\r';
-                if(i == s) ++s;
-            }*/
-            tmpbuf[i] = c;
-        }
-        tx_succesfull = 0;
-        EP_Write(3, (uint8_t*)tmpbuf, s);
-        uint32_t ctra = 1000000;
-        while(--ctra && tx_succesfull == 0);
-        l -= proc;
-        ctr += proc;
     }
 }
 
 /**
  * @brief USB_receive
- * @param buf (i) - buffer for received data
+ * @param buf (i) - buffer[64] for received data
- * @param bufsize - its size
  * @return amount of received bytes
  */
-int USB_receive(char *buf, int bufsize){
+uint8_t USB_receive(uint8_t *buf){
-    if(!bufsize || !idatalen) return 0;
+    if(!usbON || !rxNE) return 0;
-    USB->CNTR = 0;
+    DBG("Get data");
-    int sz = (idatalen > bufsize) ? bufsize : idatalen, rest = idatalen - sz;
+    SEND((char*)buf); newline();
-    for(int i = 0; i < sz; ++i) buf[i] = incoming_data[i];
+    uint8_t sz = EP_Read(2, (uint16_t*)buf);
-    if(rest > 0){
+    uint16_t epstatus = KEEP_DTOG(USB->EPnR[2]);
-        uint8_t *ptr = &incoming_data[sz];
+    // keep stat_tx & set ACK rx
-        for(int i = 0; i < rest; ++i) incoming_data[i] = *ptr++;
+    USB->EPnR[2] = (epstatus & ~(USB_EPnR_STAT_TX)) ^ USB_EPnR_STAT_RX;
-        //memmove(incoming_data, &incoming_data[sz], rest); - hardfault on memcpy&memmove
+    rxNE = 0;
-        idatalen = rest;
-    }else idatalen = 0;
-    if(ovfl){
-        EP23_Handler(endpoints[2]);
-        uint16_t epstatus = USB->EPnR[2];
-        epstatus = CLEAR_DTOG_RX(epstatus);
-        epstatus = SET_VALID_RX(epstatus);
-        USB->EPnR[2] = epstatus;
-    }
-    USB->CNTR = USB_CNTR_RESETM | USB_CNTR_CTRM;
     return sz;
 }
-
-/**
- * @brief USB_configured
- * @return 1 if USB is in configured state
- */
-int USB_configured(){
-    return usbON;
-}

F1-nolib/PL2303/usb.h

@@ -30,8 +30,8 @@
 
 void USB_setup();
 void usb_proc();
-void USB_send(const char *buf);
+void USB_send(const uint8_t *buf, uint16_t len);
-int USB_receive(char *buf, int bufsize);
+void USB_send_blk(const uint8_t *buf, uint16_t len);
-int USB_configured();
+uint8_t USB_receive(uint8_t *buf);
 
 #endif // __USB_H__

F1-nolib/PL2303/usb_defs.h

@@ -41,6 +41,8 @@
 #define USB_TXBUFSZ             64
 // USB receive buffer size (64 for PL2303)
 #define USB_RXBUFSZ             64
+// EP1 - interrupt - buffer size
+#define USB_EP1BUFSZ            8
 
 #define USB_BTABLE_BASE         0x40006000
 #define USB_BASE                ((uint32_t)0x40005C00)
@@ -91,18 +93,6 @@ typedef struct {
     __IO uint32_t BTABLE;
 } USB_TypeDef;
 
-/*
-typedef struct{
-    __IO uint16_t USB_ADDR_TX;
-    __IO uint16_t res1;
-    __IO uint16_t USB_COUNT_TX;
-    __IO uint16_t res2;
-    __IO uint16_t USB_ADDR_RX;
-    __IO uint16_t res3;
-    __IO uint16_t USB_COUNT_RX;
-    __IO uint16_t res4;
-} USB_EPDATA_TypeDef;*/
-
 typedef struct{
     __IO uint32_t USB_ADDR_TX;
     __IO uint32_t USB_COUNT_TX;

F1-nolib/PL2303/usb_lib.c

@@ -26,14 +26,16 @@
 
 ep_t endpoints[STM32ENDPOINTS];
 
-static usb_dev_t USB_Dev;
+usb_dev_t USB_Dev;
 static usb_LineCoding lineCoding = {115200, 0, 0, 8};
-config_pack_t setup_packet;
+static config_pack_t setup_packet;
 static uint8_t ep0databuf[EP0DATABUF_SIZE];
 static uint8_t ep0dbuflen = 0;
 
 usb_LineCoding getLineCoding(){return lineCoding;}
 
+uint8_t usbON = 0; // device disconnected from terminal
+
 // definition of parts common for USB_DeviceDescriptor & USB_DeviceQualifierDescriptor
 #define bcdUSB_L        0x10
 #define bcdUSB_H        0x01
@@ -174,8 +176,31 @@ void WEAK vendor_handler(config_pack_t *packet){
 }
 
 static void wr0(const uint8_t *buf, uint16_t size){
-    if(setup_packet.wLength < size) size = setup_packet.wLength;
+    if(setup_packet.wLength < size) size = setup_packet.wLength; // shortened request
+    if(size < endpoints[0].txbufsz){
         EP_WriteIRQ(0, buf, size);
+        return;
+    }
+    while(size){
+        uint16_t l = size;
+        if(l > endpoints[0].txbufsz) l = endpoints[0].txbufsz;
+        EP_WriteIRQ(0, buf, l);
+        buf += l;
+        size -= l;
+        uint8_t needzlp = (l == endpoints[0].txbufsz) ? 1 : 0;
+        if(size || needzlp){ // send last data buffer
+            uint16_t status = KEEP_DTOG(USB->EPnR[0]);
+            // keep DTOGs, clear CTR_RX,TX, set TX VALID, leave stat_Rx
+            USB->EPnR[0] = (status & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX|USB_EPnR_STAT_RX))
+                            ^ USB_EPnR_STAT_TX;
+            uint32_t ctr = 1000000;
+            while(--ctr && (USB->ISTR & USB_ISTR_CTR) == 0){IWDG->KR = IWDG_REFRESH;};
+            if((USB->ISTR & USB_ISTR_CTR) == 0){
+                return;
+            }
+            if(needzlp) EP_WriteIRQ(0, (uint8_t*)0, 0);
+        }
+    }
 }
 
 static inline void get_descriptor(){
@@ -232,7 +257,7 @@ static inline void std_h2d_req(){
         break;
         case SET_CONFIGURATION:
             // Now device configured
-            USB_Dev.USB_Status = USB_CONFIGURE_STATE;
+            USB_Dev.USB_Status = USB_STATE_CONFIGURED;
             configuration = setup_packet.wValue;
         break;
         default:
@@ -248,14 +273,13 @@ bmRequestType: 76543210
 */
 /**
  * Endpoint0 (control) handler
- * @param ep - endpoint state
- * @return data written to EP0R
  */
-static uint16_t EP0_Handler(ep_t ep){
+static void EP0_Handler(){
-    uint16_t epstatus = ep.status; // EP0R on input -> return this value after modifications
+    uint16_t epstatus = USB->EPnR[0]; // EP0R on input -> return this value after modifications
     uint8_t reqtype = setup_packet.bmRequestType & 0x7f;
     uint8_t dev2host = (setup_packet.bmRequestType & 0x80) ? 1 : 0;
-    if ((ep.rx_flag) && (ep.setup_flag)){
+    int rxflag = RX_FLAG(epstatus);
+    if(rxflag && SETUP_FLAG(epstatus)){
         switch(reqtype){
             case STANDARD_DEVICE_REQUEST_TYPE: // standard device request
                 if(dev2host){
@@ -264,20 +288,14 @@ static uint16_t EP0_Handler(ep_t ep){
                     std_h2d_req();
                     EP_WriteIRQ(0, (uint8_t *)0, 0);
                 }
-                epstatus = SET_NAK_RX(epstatus);
-                epstatus = SET_VALID_TX(epstatus);
             break;
             case STANDARD_ENDPOINT_REQUEST_TYPE: // standard endpoint request
                 if(setup_packet.bRequest == CLEAR_FEATURE){
                     EP_WriteIRQ(0, (uint8_t *)0, 0);
-                    epstatus = SET_NAK_RX(epstatus);
-                    epstatus = SET_VALID_TX(epstatus);
                 }
             break;
             case VENDOR_REQUEST_TYPE:
                 vendor_handler(&setup_packet);
-                epstatus = SET_NAK_RX(epstatus);
-                epstatus = SET_VALID_TX(epstatus);
             break;
             case CONTROL_REQUEST_TYPE:
                 switch(setup_packet.bRequest){
@@ -287,50 +305,40 @@ static uint16_t EP0_Handler(ep_t ep){
                     case SET_LINE_CODING: // omit this for next stage, when data will come
                     break;
                     case SET_CONTROL_LINE_STATE:
+                        usbON = 1;
                         clstate_handler(setup_packet.wValue);
                     break;
                     case SEND_BREAK:
+                        usbON = 0;
                         break_handler();
                     break;
                     default:
                     break;
                 }
-                //if(!dev2host) EP_WriteIRQ(0, (uint8_t *)0, 0); // write acknowledgement <- DO WE NEED THIS? TODO!!!
-                // OR THIS: ???
                 if(setup_packet.bRequest != GET_LINE_CODING) EP_WriteIRQ(0, (uint8_t *)0, 0); // write acknowledgement
-
-                epstatus = SET_VALID_RX(epstatus);
-                epstatus = SET_VALID_TX(epstatus);
             break;
             default:
                 EP_WriteIRQ(0, (uint8_t *)0, 0);
-                epstatus = SET_NAK_RX(epstatus);
-                epstatus = SET_VALID_TX(epstatus);
         }
-    }else if (ep.rx_flag){ // got data over EP0 or host acknowlegement
+    }else if(rxflag){ // got data over EP0 or host acknowlegement
-        if(ep.rx_cnt){
+        if(endpoints[0].rx_cnt){
-            //EP_WriteIRQ(0, (uint8_t *)0, 0);
             if(setup_packet.bRequest == SET_LINE_CODING){
                 linecoding_handler((usb_LineCoding*)ep0databuf);
             }
         }
-        // wait for new data from host
+    } else if(TX_FLAG(epstatus)){ // package transmitted
-        epstatus = SET_VALID_RX(epstatus);
-        epstatus = SET_VALID_TX(epstatus);
-    } else if (ep.tx_flag){ // package transmitted
         // now we can change address after enumeration
         if ((USB->DADDR & USB_DADDR_ADD) != USB_Dev.USB_Addr){
             USB->DADDR = USB_DADDR_EF | USB_Dev.USB_Addr;
             // change state to ADRESSED
-            USB_Dev.USB_Status = USB_ADRESSED_STATE;
+            USB_Dev.USB_Status = USB_STATE_ADDRESSED;
         }
-        // end of transaction
-        epstatus = CLEAR_DTOG_RX(epstatus);
-        epstatus = CLEAR_DTOG_TX(epstatus);
-        epstatus = SET_VALID_RX(epstatus);
-        epstatus = SET_VALID_TX(epstatus);
     }
-    return epstatus;
+    epstatus = KEEP_DTOG(USB->EPnR[0]);
+    if(rxflag) epstatus ^= USB_EPnR_STAT_TX; // start ZLP/data transmission
+    else epstatus &= ~USB_EPnR_STAT_TX; // or leave unchanged
+    // keep DTOGs, clear CTR_RX,TX, set RX VALID
+    USB->EPnR[0] = (epstatus & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX)) ^ USB_EPnR_STAT_RX;
 }
 
 static uint16_t lastaddr = LASTADDR_DEFAULT;
@@ -343,7 +351,7 @@ static uint16_t lastaddr = LASTADDR_DEFAULT;
  * @param uint16_t (*func)(ep_t *ep) - EP handler function
  * @return 0 if all OK
  */
-int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, uint16_t (*func)(ep_t ep)){
+int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, void (*func)(ep_t ep)){
     if(number >= STM32ENDPOINTS) return 4; // out of configured amount
     if(txsz > USB_BTABLE_SIZE || rxsz > USB_BTABLE_SIZE) return 1; // buffer too large
     if(lastaddr + txsz + rxsz >= USB_BTABLE_SIZE) return 2; // out of btable
@@ -358,6 +366,7 @@ int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, uint16_t
     }
     USB_BTABLE->EP[number].USB_ADDR_TX = lastaddr;
     endpoints[number].tx_buf = (uint16_t *)(USB_BTABLE_BASE + lastaddr*2);
+    endpoints[number].txbufsz = txsz;
     lastaddr += txsz;
     USB_BTABLE->EP[number].USB_COUNT_TX = 0;
     USB_BTABLE->EP[number].USB_ADDR_RX = lastaddr;
@@ -370,17 +379,19 @@ int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, uint16_t
 
 //extern int8_t dump;
 // standard IRQ handler
-void usb_isr(){
+void usb_lp_can_rx0_isr(){
     if(USB->ISTR & USB_ISTR_RESET){
+        usbON = 0;
         // Reinit registers
-        USB->CNTR = USB_CNTR_RESETM | USB_CNTR_CTRM;
+        USB->CNTR = USB_CNTR_RESETM | USB_CNTR_CTRM | USB_CNTR_SUSPM | USB_CNTR_WKUPM;
         USB->ISTR = 0;
         // Endpoint 0 - CONTROL
         // ON USB LS size of EP0 may be 8 bytes, but on FS it should be 64 bytes!
         lastaddr = LASTADDR_DEFAULT;
         // clear address, leave only enable bit
         USB->DADDR = USB_DADDR_EF;
-        USB_Dev.USB_Status =USB_DEFAULT_STATE;
+        USB_Dev.USB_Status = USB_STATE_DEFAULT;
+        USB->ISTR = ~USB_ISTR_RESET;
         if(EP_Init(0, EP_TYPE_CONTROL, USB_EP0_BUFSZ, USB_EP0_BUFSZ, EP0_Handler)){
             return;
         }
@@ -390,11 +401,6 @@ void usb_isr(){
         uint8_t n = USB->ISTR & USB_ISTR_EPID;
         // copy status register
         uint16_t epstatus = USB->EPnR[n];
-    //  dump = 1;
-        // Calculate flags
-        endpoints[n].rx_flag = (epstatus & USB_EPnR_CTR_RX) ? 1 : 0;
-        endpoints[n].setup_flag = (epstatus & USB_EPnR_SETUP) ? 1 : 0;
-        endpoints[n].tx_flag = (epstatus & USB_EPnR_CTR_TX) ? 1 : 0;
         // copy received bytes amount
         endpoints[n].rx_cnt = USB_BTABLE->EP[n].USB_COUNT_RX & 0x3FF; // low 10 bits is counter
         // check direction
@@ -409,61 +415,19 @@ void usb_isr(){
                     EP_Read(0, (uint16_t*)&ep0databuf);
                 }
             }
-        }else{ // IN interrupt - transmit data, only CTR_TX == 1
-            // enumeration end could be here (if EP0)
         }
-        // prepare status field for EP handler
+        // call EP handler
-        endpoints[n].status = epstatus;
+        if(endpoints[n].func) endpoints[n].func(endpoints[n]);
-        // call EP handler (even if it will change EPnR, it should return new status)
-        epstatus = endpoints[n].func(endpoints[n]);
-        // keep DTOG state
-        epstatus = KEEP_DTOG_TX(epstatus);
-        epstatus = KEEP_DTOG_RX(epstatus);
-        // clear all RX/TX flags
-        epstatus = CLEAR_CTR_RX(epstatus);
-        epstatus = CLEAR_CTR_TX(epstatus);
-        // refresh EPnR
-        USB->EPnR[n] = epstatus;
     }
+    if(USB->ISTR & USB_ISTR_SUSP){ // suspend -> still no connection, may sleep
+        usbON = 0;
+        USB->CNTR |= USB_CNTR_FSUSP | USB_CNTR_LP_MODE;
+        USB->ISTR = ~USB_ISTR_SUSP;
     }
-
+    if(USB->ISTR & USB_ISTR_WKUP){ // wakeup
-/*
+        USB->CNTR &= ~(USB_CNTR_FSUSP | USB_CNTR_LP_MODE); // clear suspend flags
-    if (USB->ISTR & USB_ISTR_PMAOVR) {
+        USB->ISTR = ~USB_ISTR_WKUP;
-        MSG("PMAOVR\n");
-        // Handle PMAOVR status
     }
-    if (USB->ISTR & USB_ISTR_SUSP) {
-        MSG("SUSP\n");
-        if (USB->DADDR & 0x7f) {
-            USB->DADDR = 0;
-            USB->CNTR &= ~ 0x800;
-        }
-    }
-    if (USB->ISTR & USB_ISTR_ERR) {
-        MSG("ERR\n");
-        // Handle Error
-    }
-    if (USB->ISTR & USB_ISTR_WKUP) {
-        MSG("WKUP\n");
-        // Handle Wakeup
-    }
-    if (USB->ISTR & USB_ISTR_SOF) {
-        MSG("SOF\n");
-        // Handle SOF
-    }
-    if (USB->ISTR & USB_ISTR_ESOF) {
-        MSG("ESOF\n");
-        // Handle ESOF
-    }
-    USB->ISTR = 0;
-*/
-
-void usb_lp_can_rx0_isr(){
-    usb_isr();
-}
-
-void usb_hp_can_tx_isr(){
-    usb_isr();
 }
 
 /**
@@ -492,13 +456,10 @@ void EP_WriteIRQ(uint8_t number, const uint8_t *buf, uint16_t size){
  * @param size - its size
  */
 void EP_Write(uint8_t number, const uint8_t *buf, uint16_t size){
-    uint16_t status = USB->EPnR[number];
     EP_WriteIRQ(number, buf, size);
-    status = SET_NAK_RX(status);
+    uint16_t status = KEEP_DTOG(USB->EPnR[number]);
-    status = SET_VALID_TX(status);
+    // keep DTOGs, clear CTR_TX & set TX VALID to start transmission
-    status = KEEP_DTOG_TX(status);
+    USB->EPnR[number] = (status & ~(USB_EPnR_CTR_TX)) ^ USB_EPnR_STAT_TX;
-    status = KEEP_DTOG_RX(status);
-    USB->EPnR[number] = status;
 }
 
 /*
@@ -507,13 +468,16 @@ void EP_Write(uint8_t number, const uint8_t *buf, uint16_t size){
  * @return amount of data read
  */
 int EP_Read(uint8_t number, uint16_t *buf){
-    int n = (endpoints[number].rx_cnt + 1) >> 1;
+    int sz = endpoints[number].rx_cnt;
+    if(!sz) return 0;
+    endpoints[number].rx_cnt = 0;
+    int n = (sz + 1) >> 1;
     uint32_t *in = (uint32_t *)endpoints[number].rx_buf;
     if(n){
         for(int i = 0; i < n; ++i, ++in)
             buf[i] = *(uint16_t*)in;
     }
-    return endpoints[number].rx_cnt;
+    return sz;
 }
 
 // USB status

F1-nolib/PL2303/usb_lib.h

@@ -31,8 +31,6 @@
 #define EP0DATABUF_SIZE                 (64)
 #define LASTADDR_DEFAULT                (STM32ENDPOINTS * 8)
 
-// Max EP amount (EP0 + other used)
-//#define ENDPOINTS_NUM                   4
 // bmRequestType & 0x7f
 #define STANDARD_DEVICE_REQUEST_TYPE    0
 #define STANDARD_ENDPOINT_REQUEST_TYPE  2
@@ -78,31 +76,21 @@
 #define STRING_SN_DESCRIPTOR            0x303
 #define DEVICE_QUALIFIER_DESCRIPTOR     0x600
 
+#define RX_FLAG(epstat)                 (epstat & USB_EPnR_CTR_RX)
+#define TX_FLAG(epstat)                 (epstat & USB_EPnR_CTR_TX)
+#define SETUP_FLAG(epstat)              (epstat & USB_EPnR_SETUP)
+
 // EPnR bits manipulation
-#define CLEAR_DTOG_RX(R)                (R & USB_EPnR_DTOG_RX) ? R : (R & (~USB_EPnR_DTOG_RX))
+#define KEEP_DTOG_STAT(EPnR)            (EPnR & ~(USB_EPnR_STAT_RX|USB_EPnR_STAT_TX|USB_EPnR_DTOG_RX|USB_EPnR_DTOG_TX))
-#define SET_DTOG_RX(R)                  (R & USB_EPnR_DTOG_RX) ? (R & (~USB_EPnR_DTOG_RX)) : R
+#define KEEP_DTOG(EPnR)                 (EPnR & ~(USB_EPnR_DTOG_RX|USB_EPnR_DTOG_TX))
-#define TOGGLE_DTOG_RX(R)               (R | USB_EPnR_DTOG_RX)
-#define KEEP_DTOG_RX(R)                 (R & (~USB_EPnR_DTOG_RX))
-#define CLEAR_DTOG_TX(R)                (R & USB_EPnR_DTOG_TX) ? R : (R & (~USB_EPnR_DTOG_TX))
-#define SET_DTOG_TX(R)                  (R & USB_EPnR_DTOG_TX) ? (R & (~USB_EPnR_DTOG_TX)) : R
-#define TOGGLE_DTOG_TX(R)               (R | USB_EPnR_DTOG_TX)
-#define KEEP_DTOG_TX(R)                 (R & (~USB_EPnR_DTOG_TX))
-#define SET_VALID_RX(R)                 ((R & USB_EPnR_STAT_RX) ^ USB_EPnR_STAT_RX)   | (R & (~USB_EPnR_STAT_RX))
-#define SET_NAK_RX(R)                   ((R & USB_EPnR_STAT_RX) ^ USB_EPnR_STAT_RX_1) | (R & (~USB_EPnR_STAT_RX))
-#define SET_STALL_RX(R)                 ((R & USB_EPnR_STAT_RX) ^ USB_EPnR_STAT_RX_0) | (R & (~USB_EPnR_STAT_RX))
-#define KEEP_STAT_RX(R)                 (R & (~USB_EPnR_STAT_RX))
-#define SET_VALID_TX(R)                 ((R & USB_EPnR_STAT_TX) ^ USB_EPnR_STAT_TX)   | (R & (~USB_EPnR_STAT_TX))
-#define SET_NAK_TX(R)                   ((R & USB_EPnR_STAT_TX) ^ USB_EPnR_STAT_TX_1) | (R & (~USB_EPnR_STAT_TX))
-#define SET_STALL_TX(R)                 ((R & USB_EPnR_STAT_TX) ^ USB_EPnR_STAT_TX_0) | (R & (~USB_EPnR_STAT_TX))
-#define KEEP_STAT_TX(R)                 (R & (~USB_EPnR_STAT_TX))
-#define CLEAR_CTR_RX(R)                 (R & (~USB_EPnR_CTR_RX))
-#define CLEAR_CTR_TX(R)                 (R & (~USB_EPnR_CTR_TX))
-#define CLEAR_CTR_RX_TX(R)              (R & (~(USB_EPnR_CTR_TX | USB_EPnR_CTR_RX)))
 
 // USB state: uninitialized, addressed, ready for use
-#define USB_DEFAULT_STATE               0
+typedef enum{
-#define USB_ADRESSED_STATE              1
+    USB_STATE_DEFAULT,
-#define USB_CONFIGURE_STATE             2
+    USB_STATE_ADDRESSED,
+    USB_STATE_CONFIGURED,
+    USB_STATE_CONNECTED
+} USB_state;
 
 // EP types
 #define EP_TYPE_BULK                    0x00
@@ -144,15 +132,12 @@ typedef struct {
 } config_pack_t;
 
 // endpoints state
-typedef struct __ep_t{
+typedef struct{
     uint16_t *tx_buf;           // transmission buffer address
+    uint16_t txbufsz;           // transmission buffer size
     uint16_t *rx_buf;           // reception buffer address
-    uint16_t (*func)();         // endpoint action function
+    void (*func)();             // endpoint action function
-    uint16_t status;            // status flags
     unsigned rx_cnt  : 10;      // received data counter
-    unsigned tx_flag : 1;       // transmission flag
-    unsigned rx_flag : 1;       // reception flag
-    unsigned setup_flag : 1;    // this is setup packet (only for EP0)
 } ep_t;
 
 // USB status & its address
@@ -185,18 +170,20 @@ typedef struct {
 } __attribute__ ((packed)) usb_cdc_notification;
 
 extern ep_t endpoints[];
+extern usb_dev_t USB_Dev;
+extern uint8_t usbON;
 
 void USB_Init();
-uint8_t USB_GetState();
+void USB_ResetState();
-int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, uint16_t (*func)(ep_t ep));
+int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, void (*func)());
 void EP_WriteIRQ(uint8_t number, const uint8_t *buf, uint16_t size);
 void EP_Write(uint8_t number, const uint8_t *buf, uint16_t size);
 int EP_Read(uint8_t number, uint16_t *buf);
 usb_LineCoding getLineCoding();
 
-void WEAK linecoding_handler(usb_LineCoding *lc);
+void linecoding_handler(usb_LineCoding *lc);
-void WEAK clstate_handler(uint16_t val);
+void clstate_handler(uint16_t val);
-void WEAK break_handler();
+void break_handler();
-void WEAK vendor_handler(config_pack_t *packet);
+void vendor_handler(config_pack_t *packet);
 
 #endif // __USB_LIB_H__