feat(usb_host): Remote wakeup WIP

    - HCD and USB Host tests

Author: peter-marcisovsky

host/usb/include/usb/usb_host.h

@@ -548,6 +548,50 @@ esp_err_t usb_host_get_config_desc(usb_host_client_handle_t client_hdl, usb_devi
  */
 esp_err_t usb_host_free_config_desc(const usb_config_desc_t *config_desc);
 
+/**
+ * @brief Set remote wakeup feature on a device
+ *
+ * This function enables, or disables remote wakeup feature on a connected device. Device must support remote wakeup
+ * at fist place
+ *
+ * @note A control transfer is sent to a device, to enable/disable the feature
+ * @note A client must open the device first
+ *
+ * @param[in] client_hdl Handle of a client, that opened the device
+ * @param[in] dev_hdl Handle of a device, on which the remote wakeup is about to be enabled/disabled
+ * @param[in] enable Remote wakeup enable/disable
+ *
+ * @return
+ *    - ESP_OK: Remote wakeup set successfully
+ *    - ESP_ERR_INVALID_ARG: Invalid argument
+ *    - ESP_ERR_INVALID_STATE: Client did not open the device
+ *    - ESP_ERR_NOT_ALLOWED: Device does not support remote wakeup
+ *    - ESP_ERR_NO_MEM: Not enough memory
+ */
+esp_err_t usb_host_device_remote_wakeup_enable(usb_host_client_handle_t client_hdl, usb_device_handle_t dev_hdl, bool enable);
+
+/**
+ * @brief Check if a remote wakeup is currently set
+ *
+ * This function checks if a remote wakeup feature is currently enabled or disabled on a connected device. Device must
+ * support remote wakeup at fist place
+ *
+ * @note A control transfer is sent to a device, get a device status descriptor
+ * @note A client must open the device first
+ *
+ * @param[in] client_hdl Handle of a client, that opened the device
+ * @param[in] dev_hdl Handle of a device, on which the remote wakeup is about to be checked
+ * @param[out] enabled Remote wakeup is currently enabled/disabled
+ *
+ * @return
+ *    - ESP_OK: Remote wakeup status checked successfully
+ *    - ESP_ERR_INVALID_ARG: Invalid argument
+ *    - ESP_ERR_INVALID_STATE: Client did not open the device
+ *    - ESP_ERR_NOT_ALLOWED: Device does not support remote wakeup
+ *    - ESP_ERR_NO_MEM: Not enough memory
+ */
+esp_err_t usb_host_device_remote_wakeup_check(usb_host_client_handle_t client_hdl, usb_device_handle_t dev_hdl, bool *enabled);
+
 // ----------------------------------------------- Interface Functions -------------------------------------------------
 
 /**

host/usb/include/usb/usb_types_ch9.h

@@ -153,10 +153,19 @@ ESP_STATIC_ASSERT(sizeof(usb_device_status_t) == sizeof(uint16_t), "Size of usb_
 #define USB_W_VALUE_DT_OTHER_SPEED_CONFIG   0x07
 #define USB_W_VALUE_DT_INTERFACE_POWER      0x08
 
+/**
+ * @brief Feature selector bit masks belonging to the wValue field of a setup packet
+ *
+ * See Table 9-6 of USB2.0 specification for more details
+ */
+#define ENDPOINT_HALT                       0x00
+#define DEVICE_REMOTE_WAKEUP                0x01
+#define TEST_MODE                           0x02
+
 /**
  * @brief Initializer for a GET_STATUS request
  *
- * Sets the address of a connected device
+ * Gets the status of a connected device
  */
 #define USB_SETUP_PACKET_INIT_GET_STATUS(setup_pkt_ptr) ({  \
     (setup_pkt_ptr)->bmRequestType = USB_BM_REQUEST_TYPE_DIR_IN | USB_BM_REQUEST_TYPE_TYPE_STANDARD | USB_BM_REQUEST_TYPE_RECIP_DEVICE;   \
@@ -166,6 +175,36 @@ ESP_STATIC_ASSERT(sizeof(usb_device_status_t) == sizeof(uint16_t), "Size of usb_
     (setup_pkt_ptr)->wLength = 2;   \
 })
 
+/**
+ * @brief Initializer for a CLEAR_FEATURE request
+ *
+ * Clears the feature of a connected device
+ *
+ * See Chapter 9.4.1 of USB2.0 specification for more details
+ */
+#define USB_SETUP_PACKET_INIT_CLEAR_FEATURE(setup_pkt_ptr, feature_to_clear) ({  \
+    (setup_pkt_ptr)->bmRequestType = USB_BM_REQUEST_TYPE_DIR_OUT | USB_BM_REQUEST_TYPE_TYPE_STANDARD | USB_BM_REQUEST_TYPE_RECIP_DEVICE;   \
+    (setup_pkt_ptr)->bRequest = USB_B_REQUEST_CLEAR_FEATURE;  \
+    (setup_pkt_ptr)->wValue = feature_to_clear;   \
+    (setup_pkt_ptr)->wIndex = 0;    \
+    (setup_pkt_ptr)->wLength = 0;   \
+})
+
+/**
+ * @brief Initializer for a SET_FEATURE request
+ *
+ * Sets the feature of a connected device
+ *
+ * See Chapter 9.4.9 of USB2.0 specification for more details
+ */
+#define USB_SETUP_PACKET_INIT_SET_FEATURE(setup_pkt_ptr, feature_to_set) ({  \
+    (setup_pkt_ptr)->bmRequestType = USB_BM_REQUEST_TYPE_DIR_OUT | USB_BM_REQUEST_TYPE_TYPE_STANDARD | USB_BM_REQUEST_TYPE_RECIP_DEVICE;   \
+    (setup_pkt_ptr)->bRequest = USB_B_REQUEST_SET_FEATURE;  \
+    (setup_pkt_ptr)->wValue = feature_to_set;   \
+    (setup_pkt_ptr)->wIndex = 0;    \
+    (setup_pkt_ptr)->wLength = 0;   \
+})
+
 /**
  * @brief Initializer for a SET_ADDRESS request
  *

host/usb/private_include/hcd.h

@@ -69,6 +69,7 @@ typedef enum {
     HCD_PORT_EVENT_DISCONNECTION,   /**< A device disconnection has been detected */
     HCD_PORT_EVENT_ERROR,           /**< A port error has been detected. Port is now HCD_PORT_STATE_RECOVERY  */
     HCD_PORT_EVENT_OVERCURRENT,     /**< Overcurrent detected on the port. Port is now HCD_PORT_STATE_RECOVERY */
+    HCD_PORT_EVENT_REMOTE_WAKEUP,
 } hcd_port_event_t;
 
 /**

host/usb/src/hcd_dwc.c

@@ -831,6 +831,12 @@ static hcd_port_event_t _intr_hdlr_hprt(port_t *port, usb_dwc_hal_port_event_t h
         port->flags.conn_dev_ena = 0;
         break;
     }
+    case USB_DWC_HAL_PORT_EVENT_REMOTE_WAKEUP: {
+        //ESP_EARLY_LOGI(HCD_DWC_TAG, "WAKE");
+        //port->state = HCD_PORT_STATE_ENABLED;
+        port_event = HCD_PORT_EVENT_REMOTE_WAKEUP;
+        break;
+    }
     default: {
         abort();
         break;
@@ -1231,6 +1237,8 @@ static esp_err_t _port_cmd_power_on(port_t *port)
     } else {
         ret = ESP_ERR_INVALID_STATE;
     }
+    //esp_rom_printf("power on: HPRT = %lx\n", usb_dwc_hal_port_get_hprt_val(port->hal));
+    //esp_rom_printf("power on: GINTSTS = %lx\n", usb_dwc_hal_port_get_gintsts_val(port->hal));
     return ret;
 }
 
@@ -1326,19 +1334,21 @@ static esp_err_t _port_cmd_bus_suspend(port_t *port)
     // Port must have been previously enabled, and all pipes must already be halted
     if (!(port->state == HCD_PORT_STATE_ENABLED && _port_check_all_pipes_halted(port))) {
         ret = ESP_ERR_INVALID_STATE;
+        esp_rom_printf("ERR1\n");
         goto exit;
     }
 
     usb_dwc_hal_port_suspend(port->hal);
     port->state = HCD_PORT_STATE_SUSPENDING;
 
     HCD_EXIT_CRITICAL();
-    vTaskDelay(pdMS_TO_TICKS(SUSPEND_ENTRY_MS));
+    vTaskDelay(pdMS_TO_TICKS(100));
     HCD_ENTER_CRITICAL();
 
     if (port->state != HCD_PORT_STATE_SUSPENDING) {
         // Port state unexpectedly changed
         ret = ESP_ERR_INVALID_RESPONSE;
+        esp_rom_printf("ERR2\n");
         goto exit;
     }
 
@@ -1350,6 +1360,7 @@ static esp_err_t _port_cmd_bus_suspend(port_t *port)
     // Sanity check, the root port should have entered the suspended state after the SUSPEND_ENTRY_MS delay
     if (!usb_dwc_ll_hprt_get_port_suspend(port->hal->dev)) {
         ret = ESP_ERR_NOT_FINISHED;
+        esp_rom_printf("ERR3\n");
         goto exit;
     }
 
@@ -1362,17 +1373,36 @@ static esp_err_t _port_cmd_bus_suspend(port_t *port)
 
 static esp_err_t _port_cmd_bus_resume(port_t *port)
 {
+    uint32_t hprt, gintsts, state;
     esp_err_t ret;
     // Port can only be resumed if it was previously suspended
     if (port->state != HCD_PORT_STATE_SUSPENDED) {
         ret = ESP_ERR_INVALID_STATE;
         goto exit;
     }
+    hprt = usb_dwc_hal_port_get_hprt_val(port->hal);
+    gintsts = usb_dwc_hal_port_get_gintsts_val(port->hal);
+    state = usb_dwc_hal_hprt_get_pwr_line_status(port->hal);
+
+    // Res1 (Wkp1)
+    esp_rom_printf("HPRT: %lx\n", hprt);
+    esp_rom_printf("GINTSTS: %lx\n", gintsts);
+    esp_rom_printf("State %lx\n", state);
+
     // Put and hold the bus in the K state.
     usb_dwc_hal_port_toggle_resume(port->hal, true);
     port->state = HCD_PORT_STATE_RESUMING;
     HCD_EXIT_CRITICAL();
-    vTaskDelay(pdMS_TO_TICKS(RESUME_HOLD_MS));
+    vTaskDelay(pdMS_TO_TICKS(50));
+
+    // Res2 (Wkp2)
+    hprt = usb_dwc_hal_port_get_hprt_val(port->hal);
+    gintsts = usb_dwc_hal_port_get_gintsts_val(port->hal);
+    state = usb_dwc_hal_hprt_get_pwr_line_status(port->hal);
+    esp_rom_printf("HPRT: %lx\n", hprt);
+    esp_rom_printf("GINTSTS: %lx\n", gintsts);
+    esp_rom_printf("State %lx\n", state);
+
     HCD_ENTER_CRITICAL();
     // Return and hold the bus to the J state (as port of the LS EOP)
     usb_dwc_hal_port_toggle_resume(port->hal, false);
@@ -1382,7 +1412,15 @@ static esp_err_t _port_cmd_bus_resume(port_t *port)
         goto exit;
     }
     HCD_EXIT_CRITICAL();
-    vTaskDelay(pdMS_TO_TICKS(RESUME_RECOVERY_MS));
+    vTaskDelay(pdMS_TO_TICKS(100));
+
+    // Res3 (Wkp3)
+    hprt = usb_dwc_hal_port_get_hprt_val(port->hal);
+    gintsts = usb_dwc_hal_port_get_gintsts_val(port->hal);
+    state = usb_dwc_hal_hprt_get_pwr_line_status(port->hal);
+    esp_rom_printf("HPRT: %lx\n", hprt);
+    esp_rom_printf("GINTSTS: %lx\n", gintsts);
+    esp_rom_printf("State %lx\n", state);
     HCD_ENTER_CRITICAL();
     if (port->state != HCD_PORT_STATE_RESUMING || !port->flags.conn_dev_ena) {
         // Port state unexpectedly changed
@@ -1485,8 +1523,11 @@ esp_err_t hcd_port_deinit(hcd_port_handle_t port_hdl)
     return ESP_OK;
 }
 
+static port_t *s_port;
+
 esp_err_t hcd_port_command(hcd_port_handle_t port_hdl, hcd_port_cmd_t command)
 {
+    s_port = (port_t *)port_hdl;
     esp_err_t ret = ESP_ERR_INVALID_STATE;
     port_t *port = (port_t *)port_hdl;
     xSemaphoreTake(port->port_mux, portMAX_DELAY);
@@ -2688,6 +2729,8 @@ static inline bool _check_port_pipe_state(pipe_t *pipe, bool *submit_urb)
 
 esp_err_t hcd_urb_enqueue(hcd_pipe_handle_t pipe_hdl, urb_t *urb)
 {
+    //esp_rom_printf("HPRT: %lx\n", usb_dwc_hal_port_get_hprt_val(s_port->hal));
+    //esp_rom_printf("power on: GINTSTS = %lx\n", usb_dwc_hal_port_get_gintsts_val(s_port->hal));
     // Check that URB has not already been enqueued
     HCD_CHECK(urb->hcd_ptr == NULL && urb->hcd_var == URB_HCD_STATE_IDLE, ESP_ERR_INVALID_STATE);
     pipe_t *pipe = (pipe_t *)pipe_hdl;

host/usb/src/hub.c

@@ -441,6 +441,18 @@ static void root_port_handle_events(hcd_port_handle_t root_port_hdl)
 
         break;
     }
+    case HCD_PORT_EVENT_REMOTE_WAKEUP:
+        // Root port, including all the connected devices were resumed (global resume)
+        // Clear all EPs and propagate the resumed event to clients
+        //usbh_devs_set_pm_actions_all(USBH_DEV_RESUME | USBH_DEV_RESUME_EVT);
+        //esp_rom_printf("p_hub_driver_obj->dynamic.root_port_state = %d\n", p_hub_driver_obj->dynamic.root_port_state);
+
+        // Change Port state
+        //HUB_DRIVER_ENTER_CRITICAL();
+        //p_hub_driver_obj->dynamic.root_port_state = ROOT_PORT_STATE_ENABLED;
+        //HUB_DRIVER_EXIT_CRITICAL();
+        hub_root_mark_resume();
+        break;
     default:
         abort();    // Should never occur
         break;