Test with 1ms timer controlling USB/TransferDescriptor logic

Author: AndrewCapon

src/USBHost/USBHALHost.h

@@ -34,6 +34,12 @@ class USBHALHost {
     */
     USBHALHost();
 
+#if ARC_TICKER_BASED
+    mbed::Ticker ms_ticker;
+
+    void tickerCallback(void);
+#endif
+
     /**
     * Initialize host controller. Enable USB interrupts. This part is not in the constructor because,
     * this function calls a virtual method if a device is already connected

src/USBHost/USBHost.cpp

@@ -180,6 +180,11 @@ void USBHost::usb_process()
                             res = getDeviceDescriptor(&devices[i], buf, 8);
 
                             if (res == USB_TYPE_OK) {
+                                // Call the device connected callback if registered
+                                if (nullptr != mount_fnc) {
+                                    mount_fnc();
+                                }
+                                
                                 break;
                             }
 
@@ -188,10 +193,6 @@ void USBHost::usb_process()
 
                         USB_INFO("New device connected: %p [hub: %d - port: %d]", &devices[i], usb_msg->hub, usb_msg->port);
 
-                        // Call the device connected callback if registered
-                        if (nullptr != mount_fnc) {
-                            mount_fnc();
-                        }
 
 #if MAX_HUB_NB
                         if (buf[4] == HUB_CLASS) {

src/targets/TARGET_STM/USBHALHost_STM.cpp

@@ -91,6 +91,93 @@ uint32_t HAL_HCD_HC_GetType(HCD_HandleTypeDef *hhcd, uint8_t chnum)
 //  - URB_NOTREADY = a NAK, NYET, or not more than a couple of repeats of some of the errors that will
 //                   become URB_ERROR if they repeat several times in a row
 //
+#if ARC_TICKER_BASED
+void USBHALHost::tickerCallback(void)
+{
+  HCD_HandleTypeDef    *pHcd  = (HCD_HandleTypeDef *)usb_hcca;
+  if(pHcd->State != HAL_HCD_STATE_BUSY)
+  {
+    USBHALHost_Private_t *pPriv = (USBHALHost_Private_t *)(pHcd->pData);
+
+    // 10 host channels
+    for(uint8_t uChannel=0; uChannel <11; uChannel++)
+    {
+      USB_OTG_URBStateTypeDef urbState = pHcd->hc[uChannel].urb_state;
+
+      HCTD    *pTransferDescriptor  = (pPriv->addr[uChannel] == 0xffffffff) ? nullptr : (HCTD *)pPriv->addr[uChannel];
+      uint32_t uEndpointType        = pHcd->hc[uChannel].ep_type;
+      uint32_t uEndpointDirection   = pHcd->hc[uChannel].ep_is_in;;
+
+      if(pTransferDescriptor)
+      {
+        if (uEndpointType == EP_TYPE_INTR)
+        {
+          // Disable the channel interupt
+          pTransferDescriptor->state = USB_TYPE_IDLE;
+          HAL_HCD_DisableInt(pHcd, uChannel);
+        } 
+        else 
+        {
+          // Handle USB NAKs
+          if(urbState == URB_NOTREADY)
+          {
+            // retry Acks imediately
+            // retry Bulk and Control after uRetryCounts ms
+            if ((uEndpointType == EP_TYPE_BULK) || (uEndpointType == EP_TYPE_CTRL)) 
+            {
+              constexpr uint32_t uRetryCount = 5;
+
+              pTransferDescriptor->retry++;
+
+              if(urbState == URB_NOTREADY)
+              {
+                volatile uint32_t transferred = HAL_HCD_HC_GetXferCount(pHcd, uChannel);
+
+                if((pTransferDescriptor->retry == uRetryCount) || (pTransferDescriptor->size==0))
+                {
+                  // Submit the same request again, because the device wasn't ready to accept the last one
+                  // we need to be aware of any data that has already been transferred as it wont be again by the look of it.
+                  pTransferDescriptor->currBufPtr += transferred;
+                  pTransferDescriptor->size -= transferred;
+                  pTransferDescriptor->retry = 0;
+                  uint32_t uLength = pTransferDescriptor->size;
+
+                  HAL_HCD_HC_SubmitRequest(pHcd, uChannel, uEndpointDirection, uEndpointType, !pTransferDescriptor->setup, (uint8_t *) pTransferDescriptor->currBufPtr, uLength, 0);
+                  HAL_HCD_EnableInt(pHcd, uChannel);
+                }
+              }
+            }
+          }
+          else
+          {
+            // set the transfer descriptor state based on the URB state
+            switch(urbState)
+            {
+              case URB_IDLE:  // Guessing that we must have had a URB_DONE if we are idle
+              case URB_DONE:  pTransferDescriptor->state = USB_TYPE_IDLE; break;
+              case URB_ERROR: pTransferDescriptor->state = USB_TYPE_ERROR; break;
+              default:        pTransferDescriptor->state = USB_TYPE_PROCESSING; break; 
+            }
+          }
+        }
+
+        if (pTransferDescriptor->state == USB_TYPE_IDLE) 
+        {
+          // reset retry count
+          pTransferDescriptor->retry = 0;
+
+          // Update transfer descriptor buffer pointer
+          pTransferDescriptor->currBufPtr += HAL_HCD_HC_GetXferCount(pHcd, uChannel);
+
+          // Call transferCompleted on correct object
+          void (USBHALHost::*func)(volatile uint32_t addr) = pPriv->transferCompleted;
+          (pPriv->inst->*func)(reinterpret_cast<std::uintptr_t>(pTransferDescriptor));
+        }
+      }
+    }
+  }
+}
+#else
 void HAL_HCD_HC_NotifyURBChange_Callback(HCD_HandleTypeDef *hhcd, uint8_t chnum, HCD_URBStateTypeDef urb_state)
 {
     USBHALHost_Private_t *priv = (USBHALHost_Private_t *)(hhcd->pData);
@@ -120,9 +207,6 @@ void HAL_HCD_HC_NotifyURBChange_Callback(HCD_HandleTypeDef *hhcd, uint8_t chnum,
     uint32_t length;
     if ((addr != 0)) {
         HCTD *td = (HCTD *)addr;
-		    LogicUint7(0x70 + urb_state);
-		    LogicUint7(0x50 + chnum);
-        digitalWrite(PA_7, HIGH);
 
 #if ARC_USB_FULL_SIZE
         constexpr uint32_t uRetryCount = 10000/20; // (TODO: should be done with timer, investigate)
@@ -217,6 +301,7 @@ void HAL_HCD_HC_NotifyURBChange_Callback(HCD_HandleTypeDef *hhcd, uint8_t chnum,
         }
     }
 }
+#endif
 
 USBHALHost *USBHALHost::instHost;
 

src/targets/TARGET_STM/USBHALHost_STM.h

@@ -365,6 +365,10 @@ USBHALHost::USBHALHost()
     // Set USB interrupt
     HAL_NVIC_SetPriority(USBHAL_IRQn, 0, 0);
     NVIC_SetVector(USBHAL_IRQn, (uint32_t)&_usbisr);
+    
+#if ARC_TICKER_BASED
+    ms_ticker.attach_us(mbed::callback(this, &USBHALHost::tickerCallback), 1000);
+#endif
 }
 
 #endif // USBHALHOST_STM_H