pbdrv/usb: Configure USB device and process pybricks commands

Add initial implementation of the Pybricks USB interface.

This can process commands but doesn't send a response yet.

Signed-off-by: Nate Karstens <[email protected]>

Author: nkarstens

lib/pbio/drv/usb/stm32_usbd/usbd_pybricks.c

@@ -379,8 +379,7 @@ static USBD_StatusTypeDef USBD_Pybricks_EP0_RxReady(USBD_HandleTypeDef *pdev) {
   * @param  fops: CD  Interface callback
   * @retval status
   */
-USBD_StatusTypeDef USBD_Pybricks_RegisterInterface(USBD_HandleTypeDef *pdev,
-    USBD_Pybricks_ItfTypeDef *fops) {
+USBD_StatusTypeDef USBD_Pybricks_RegisterInterface(USBD_HandleTypeDef *pdev, USBD_Pybricks_ItfTypeDef *fops) {
     if (fops == NULL) {
         return USBD_FAIL;
     }
@@ -416,7 +415,6 @@ USBD_StatusTypeDef USBD_Pybricks_SetRxBuffer(USBD_HandleTypeDef *pdev, uint8_t *
   */
 USBD_StatusTypeDef USBD_Pybricks_TransmitPacket(USBD_HandleTypeDef *pdev, uint8_t *pbuf, uint32_t length) {
     USBD_Pybricks_HandleTypeDef *hPybricks = pdev->pClassData;
-    USBD_StatusTypeDef ret = USBD_BUSY;
 
     if (hPybricks == NULL) {
         return USBD_FAIL;

lib/pbio/drv/usb/stm32_usbd/usbd_pybricks.h

@@ -49,11 +49,32 @@ extern "C" {
 #define USBD_PYBRICKS_OUT_EP               0x01U  /* EP1 for data OUT */
 
 #define USBD_PYBRICKS_MAX_PACKET_SIZE      64U
-
 /**
   * @}
   */
 
+// NOTE: These enums values are sent over the wire, so cannot be changed. Also,
+// 0 is skipped to avoid a zeroed buffer from being misinterpreted as a message.
+
+/** Hub to host messages via the Pybricks interface IN endpoint. */
+enum {
+    /**
+     * Analog of BLE status response. Emitted in response to every OUT message
+     * received.
+     */
+    USBD_PYBRICKS_IN_EP_MSG_RESPONSE = 1,
+    /**Analog to BLE notification. Only emitted if subscribed. */
+    USBD_PYBRICKS_IN_EP_MSG_EVENT = 2,
+};
+
+/** Host to hub messages via the Pybricks USB interface OUT endpoint. */
+enum {
+    /** Analog of BLE Client Characteristic Configuration Descriptor (CCCD). */
+    USBD_PYBRICKS_OUT_EP_MSG_SUBSCRIBE = 1,
+    /** Analog of BLE Client Characteristic Write with response. */
+    USBD_PYBRICKS_OUT_EP_MSG_COMMAND = 2,
+};
+
 
 /** @defgroup USBD_Pybricks_Exported_TypesDefinitions
   * @{
@@ -96,6 +117,7 @@ typedef struct
 extern USBD_ClassTypeDef USBD_Pybricks_ClassDriver;
 
 extern const uint8_t USBD_OSDescSet[USBD_SIZ_MS_OS_DSCRPTR_SET];
+
 /**
   * @}
   */

lib/pbio/drv/usb/usb_stm32.c

@@ -8,22 +8,33 @@
 #if PBDRV_CONFIG_USB_STM32F4
 
 #include <stdbool.h>
+#include <string.h>
 
 #include <contiki.h>
 #include <stm32f4xx_hal.h>
 #include <stm32f4xx_hal_pcd_ex.h>
 #include <usbd_core.h>
+#include <usbd_desc.h>
+#include <usbd_pybricks.h>
 
 #include <pbdrv/usb.h>
 #include <pbio/util.h>
+#include <pbsys/command.h>
+#include <pbsys/status.h>
 
 #include "../charger/charger.h"
 #include "./usb_stm32.h"
 
 PROCESS(pbdrv_usb_process, "USB");
 
+// These buffers need to be 32-bit aligned because the USB driver moves data
+// to/from FIFOs in 32-bit chunks.
+static uint8_t usb_in_buf[USBD_PYBRICKS_MAX_PACKET_SIZE] __aligned(4);
+static volatile uint32_t usb_in_sz;
+
 static USBD_HandleTypeDef husbd;
 static PCD_HandleTypeDef hpcd;
+
 static volatile bool vbus_active;
 static pbdrv_usb_bcd_t pbdrv_usb_bcd;
 
@@ -121,14 +132,81 @@ void pbdrv_usb_stm32_handle_vbus_irq(bool active) {
     process_poll(&pbdrv_usb_process);
 }
 
+/**
+  * @brief  Pybricks_Itf_Init
+  *         Initializes the Pybricks media low layer
+  * @param  None
+  * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
+  */
+static USBD_StatusTypeDef Pybricks_Itf_Init(void) {
+    USBD_Pybricks_SetRxBuffer(&husbd, usb_in_buf);
+    usb_in_sz = 0;
+
+    return USBD_OK;
+}
+
+/**
+  * @brief  Pybricks_Itf_DeInit
+  *         DeInitializes the Pybricks media low layer
+  * @param  None
+  * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
+  */
+static USBD_StatusTypeDef Pybricks_Itf_DeInit(void) {
+    return USBD_OK;
+}
+
+/**
+  * @brief  Pybricks_Itf_DataRx
+  *         Data received over USB OUT endpoint are sent over Pybricks interface
+  *         through this function.
+  * @param  Buf: Buffer of data to be transmitted
+  * @param  Len: Number of data received (in bytes)
+  * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
+  */
+static USBD_StatusTypeDef Pybricks_Itf_Receive(uint8_t *Buf, uint32_t Len) {
+
+    usb_in_sz = Len;
+    process_poll(&pbdrv_usb_process);
+    return USBD_OK;
+}
+
+/**
+  * @brief  Pybricks_Itf_TransmitCplt
+  *         Data transmitted callback
+  *
+  * @note
+  *         This function is IN transfer complete callback used to inform user that
+  *         the submitted Data is successfully sent over USB.
+  *
+  * @param  Buf: Buffer of data that was transmitted
+  * @param  Len: Number of data transmitted (in bytes)
+  * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
+  */
+static USBD_StatusTypeDef Pybricks_Itf_TransmitCplt(uint8_t *Buf, uint32_t Len, uint8_t epnum) {
+    process_poll(&pbdrv_usb_process);
+    return USBD_OK;
+}
+
+static USBD_Pybricks_ItfTypeDef USBD_Pybricks_fops = {
+    .Init = Pybricks_Itf_Init,
+    .DeInit = Pybricks_Itf_DeInit,
+    .Receive = Pybricks_Itf_Receive,
+    .TransmitCplt = Pybricks_Itf_TransmitCplt,
+};
+
 // Common USB driver implementation.
 
 void pbdrv_usb_init(void) {
     // Link the driver data structures
     husbd.pData = &hpcd;
     hpcd.pData = &husbd;
 
-    USBD_Init(&husbd, NULL, 0);
+    USBD_Pybricks_Desc_Init();
+    USBD_Init(&husbd, &USBD_Pybricks_Desc, 0);
+    USBD_RegisterClass(&husbd, &USBD_Pybricks_ClassDriver);
+    USBD_Pybricks_RegisterInterface(&husbd, &USBD_Pybricks_fops);
+    USBD_Start(&husbd);
+
     process_start(&pbdrv_usb_process);
 
     // VBUS may already be active
@@ -145,6 +223,7 @@ PROCESS_THREAD(pbdrv_usb_process, ev, data) {
     static struct pt bcd_pt;
     static PBIO_ONESHOT(no_vbus_oneshot);
     static PBIO_ONESHOT(bcd_oneshot);
+    static PBIO_ONESHOT(pwrdn_oneshot);
     static bool bcd_busy;
 
     PROCESS_POLLHANDLER({
@@ -169,6 +248,34 @@ PROCESS_THREAD(pbdrv_usb_process, ev, data) {
 
         if (bcd_busy) {
             bcd_busy = PT_SCHEDULE(pbdrv_usb_stm32_bcd_detect(&bcd_pt));
+
+            if (bcd_busy) {
+                // All other USB functions are halted if BCD is busy
+                continue;
+            }
+        }
+
+        if (pbsys_status_test(PBIO_PYBRICKS_STATUS_SHUTDOWN)) {
+            if (pbio_oneshot(true, &pwrdn_oneshot)) {
+                USBD_Stop(&husbd);
+                USBD_DeInit(&husbd);
+            }
+
+            // USB communication is stopped after a shutdown, but
+            // the process is still needed to track the BCD state
+            continue;
+        }
+
+        if (usb_in_sz) {
+            switch (usb_in_buf[0]) {
+            case USBD_PYBRICKS_OUT_EP_MSG_COMMAND:
+                pbsys_command(usb_in_buf + 1, usb_in_sz - 1);
+                break;
+            }
+
+            // Prepare to receive the next packet
+            usb_in_sz = 0;
+            USBD_Pybricks_ReceivePacket(&husbd);
         }
     }
 

lib/pbio/platform/essential_hub/platform.c

@@ -670,8 +670,13 @@ void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd) {
 }
 
 void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd) {
-    HAL_NVIC_DisableIRQ(EXTI9_5_IRQn);
     HAL_NVIC_DisableIRQ(OTG_FS_IRQn);
+
+    // The VBUS IRQ remains enabled so that it can still
+    // be triggered if the device is shut down but left
+    // connected to charge. When the charging cable is
+    // disconnected, the IRQ will trigger and lead to the
+    // device fully powering down.
 }
 
 void OTG_FS_IRQHandler(void) {

lib/pbio/platform/prime_hub/platform.c

@@ -970,8 +970,13 @@ void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd) {
 }
 
 void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd) {
-    HAL_NVIC_DisableIRQ(EXTI9_5_IRQn);
     HAL_NVIC_DisableIRQ(OTG_FS_IRQn);
+
+    // The VBUS IRQ remains enabled so that it can still
+    // be triggered if the device is shut down but left
+    // connected to charge. When the charging cable is
+    // disconnected, the IRQ will trigger and lead to the
+    // device fully powering down.
 }
 
 void OTG_FS_IRQHandler(void) {