- merge: usb_driver.c conflicts fixed

class/cdc.c

@@ -11,7 +11,7 @@
 #include <cmsis_gcc.h>
 
 // state
-static USB_CdcState cdcs = { 0 };
+static USB_CdcState cdcs = {0};
 static uint8_t tx_buffer[USB_CDC_PCKT_BUFSIZE];
 
 #define USB_CDC_FIFO_MEM_SIZE (3072) // FIXME: ez vagy a blocking FIFO bugos
@@ -19,7 +19,7 @@ static uint8_t tx_buffer[USB_CDC_PCKT_BUFSIZE];
 static uint8_t fifo_mem[USB_CDC_FIFO_MEM_SIZE];
 static BFifo fifo;
 
-void usb_cdc_read_callback(const uint8_t * data, uint32_t size);
+void usb_cdc_read_callback(const uint8_t *data, uint32_t size);
 
 void usb_cdc_init(const USB_CdcAssignments *as) {
     // clear the structure
@@ -38,11 +38,15 @@ void usb_cdc_init(const USB_CdcAssignments *as) {
     // initialize buffer
     bfifo_create(&fifo, fifo_mem, USB_CDC_FIFO_MEM_SIZE);
 
+    // initialize an all-0 interrupt
+    cdcs.interrupt_data = 0;
+    cdcs.interrupt_pending = true;
+
     // from now on CDC is considered initialized
     cdcs.initialized = true;
 }
 
-//static uint8_t replyBuf[sizeof(USB_Cdc_LineCodingStruct)];
+// static uint8_t replyBuf[sizeof(USB_Cdc_LineCodingStruct)];
 
 int usb_cdc_process_and_return(USB_CallbackEvent *cbevt) {
     int ret = -1;
@@ -51,11 +55,11 @@ int usb_cdc_process_and_return(USB_CallbackEvent *cbevt) {
         switch (cbevt->setup_request->bRequest) {
         case USB_CDC_SET_LINE_CODING: // set line coding
             memcpy(&cdcs.line_coding, cbevt->data, sizeof(USB_Cdc_LineCodingStruct));
-                    //MSG("%u\n", cdcs.line_coding.dwDTERate);
+            // MSG("%u\n", cdcs.line_coding.dwDTERate);
             ret = 0;
             break;
         case USB_CDC_GET_LINE_CODING:                               // get line coding
-                    cbevt->reply_data = (const uint8_t *) &cdcs.line_coding; // expert move: pass the pointer, no copying
+            cbevt->reply_data = (const uint8_t *)&cdcs.line_coding; // expert move: pass the pointer, no copying
             cbevt->reply_size = sizeof(USB_Cdc_LineCodingStruct);
             cbevt->reply_valid = true; // the reply has been set to something valid
             ret = 0;
@@ -66,7 +70,7 @@ int usb_cdc_process_and_return(USB_CallbackEvent *cbevt) {
             break;
         case USB_CDC_SET_CONTROL_LINE_STATE: // set control line state
             memcpy(&cdcs.control_line_state, cbevt->data, sizeof(USB_Cdc_ControlLineStateStruct));
-                    //MSG("%u\n", cdcs.control_line_state.D);
+            // MSG("%u\n", cdcs.control_line_state.D);
             ret = 0;
             break;
         default:
@@ -85,21 +89,24 @@ int usb_cdc_process_and_return(USB_CallbackEvent *cbevt) {
 
     case USB_CBEVT_OUT: {
         if (cbevt->ep == cdcs.ep_assignments.data_ep) {
-                //MSG("%c\n", cbevt->data[0]);
+            // MSG("%c\n", cbevt->data[0]);
             ret = 0;
 
             usb_cdc_read_callback(cbevt->data, cbevt->size);
-                //usbcore_schedule_transmission(cdcs.ep_assignments.data_ep, cbevt->data, cbevt->size); // echo
+            // usbcore_schedule_transmission(cdcs.ep_assignments.data_ep, cbevt->data, cbevt->size); // echo
         }
         break;
     }
 
     case USB_CBEVT_IN: {
         if (cbevt->ep == cdcs.ep_assignments.control_ep) { // if notification feeding is requested
-                usbcore_schedule_transmission(cdcs.ep_assignments.control_ep, NULL, 0); // send ZLP
+            if (cdcs.interrupt_pending) {
+                usbcore_schedule_transmission(cdcs.ep_assignments.control_ep, (const uint8_t *)&(cdcs.interrupt_data), sizeof(uint16_t)); // send ZLP
+                cdcs.interrupt_pending = false;
+            }
             ret = 0;
         } else if (cbevt->ep == cdcs.ep_assignments.data_ep) { // if data are requested
-                //usbcore_schedule_transmission(cdcs.ep_assignments.data_ep, NULL, 0); // send ZLP
+            // usbcore_schedule_transmission(cdcs.ep_assignments.data_ep, NULL, 0); // send ZLP
             ret = 0;
 
             // read from the fifo
@@ -122,15 +129,15 @@ int usb_cdc_process_and_return(USB_CallbackEvent *cbevt) {
 //    usb_cdc_process_and_return(cbevt);
 // }
 
-void usb_cdc_write(const uint8_t * data, uint32_t size) {
+void usb_cdc_write(const uint8_t *data, uint32_t size) {
     if (cdcs.initialized) {
         bfifo_push_all(&fifo, data, size);
         usbcore_wake_up_endpoint(cdcs.ep_assignments.data_ep, USB_IN);
     }
 }
 
-__attribute__((weak)) void usb_cdc_read_callback(const uint8_t * data, uint32_t size) {
+__attribute__((weak)) void usb_cdc_read_callback(const uint8_t *data, uint32_t size) {
-    (void) data;
+    (void)data;
-    (void) size;
+    (void)size;
     return;
 }

class/cdc.h

@@ -50,6 +50,8 @@ typedef struct {
     USB_CdcAssignments ep_assignments; // endpoint assignments
     USB_Cdc_LineCodingStruct line_coding; // line coding
     USB_Cdc_ControlLineStateStruct control_line_state; // control line state
+    uint16_t interrupt_data; // data sent though the next transfer on the notification element
+    bool interrupt_pending; // interrupt data is valid and should be send in the next cycle
     bool initialized; // CDC is initialized
 } USB_CdcState;
 

class/eem.c

@@ -97,17 +97,17 @@ int usb_eem_process_and_return(USB_CallbackEvent *cbevt) {
                 uint16_t bytesLeft = eems.hostbFrameLength - eems.hostbFrameIndex;                    // calculate bytes left
                 uint32_t writeSize = usbcore_schedule_transmission(eems.data_ep, readPtr, bytesLeft); // attempt to schedule transmission
 
-                //bool enableZLP = (bytesLeft < EEM_TRANSFER_UNIT) && ((bytesLeft % EEM_PCKT_SIZE) == 0); // ZLP transmission should be enabled if this was the last write and transfer size is integer multiple of the USB packet size
+                // bool enableZLP = (bytesLeft < EEM_TRANSFER_UNIT) && ((bytesLeft % EEM_PCKT_SIZE) == 0); // ZLP transmission should be enabled if this was the last write and transfer size is integer multiple of the USB packet size
-                //cbevt->enable_autozlp = enableZLP;
+                // cbevt->enable_autozlp = enableZLP;
 
                 eems.hostbFrameIndex += writeSize; // advance frame index
-                //MSG("U: %u T: %u\n", writeSize, bytesLeft);
+                // MSG("U: %u T: %u\n", writeSize, bytesLeft);
 
                 // if (eems.hostbFrameIndex >= eems.hostbFrameLength) {
                 //     MSG("---\n");
                 // }
             } else { // no data is waiting for transmission
-                //usbcore_schedule_transmission(eems.data_ep, NULL, 0); // send ZLP
+                // usbcore_schedule_transmission(eems.data_ep, NULL, 0); // send ZLP
             }
 
             // if FIFO is empty or flushed, then send notification
@@ -241,7 +241,7 @@ void usb_eem_process_hostbound() {
     }
 
     // invalidate frame
-    USB_EemFrame * oldEemFrame = eems.hostbFrame;
+    USB_EemFrame *oldEemFrame = eems.hostbFrame;
     eems.hostbFrame = NULL;
 
     // release frame
@@ -300,6 +300,10 @@ void usb_eem_ethernet_intercept_cb(EthInterface *intf, const RawPckt *rawPckt) {
 }
 
 void usb_eem_set_intf(EthInterface *intf) {
+    if (!eems.initialized) {
+        return;
+    }
+
     eems.intf = intf;                                                   // store interface
     ethinf_set_intercept_callback(intf, usb_eem_ethernet_intercept_cb); // set intercept callback
 }

usb_driver.c

@@ -169,6 +169,9 @@ void usbdrv_init_global_state() {
 #endif
 }
 
+// ---------------
+
+
 #ifdef USB_HIGH_SPEED
 __weak void usbdrv_ulpi_init() {
     return;
@@ -240,6 +243,10 @@ void usbdrv_periph_init() {
 #endif
 
 #endif
+    (uint32_t *)(((uint32_t)USBG) + 0x028), // DIEPTXF0
+    (uint32_t *)(((uint32_t)USBG) + 0x104), // DIEPTXF1
+    (uint32_t *)(((uint32_t)USBG) + 0x108), // DIEPTXF2
+    (uint32_t *)(((uint32_t)USBG) + 0x10C), // DIEPTXF3
 
     CLEAR_BIT(USBG->GCCFG, USB_OTG_GCCFG_PWRDWN); // power down the peripheral
 
@@ -752,7 +759,7 @@ uint32_t usbdrv_arm_IN_endpoint(uint8_t ep, const uint8_t *data, uint16_t len) {
 
 // arm OUT endpoint
 uint32_t usbdrv_arm_OUT_endpoint(uint8_t ep, uint8_t size) {
-    // arm endpoint only if it was not armed before OR if it's the EP0 OUT which is always enabled, but responds NAK after a successful transfer
+    // arm endpoint only if it was not armed before
     if (READ_BIT(USBOUTEP[ep].DOEPCTL, USB_OTG_DOEPCTL_EPENA)) {
         return 0;
     }