feat(usb_host): Remote wakeup WIP

peter-marcisovsky · peter-marcisovsky · commit 721c79cc8b26 · 2025-10-16T09:17:21.000+02:00
diff --git a/host/usb/src/hcd_dwc.c b/host/usb/src/hcd_dwc.c
@@ -833,6 +833,7 @@ static hcd_port_event_t _intr_hdlr_hprt(port_t *port, usb_dwc_hal_port_event_t h
     }
     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;
     }
@@ -1236,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;
 }
 
@@ -1373,11 +1376,17 @@ static esp_err_t _port_cmd_bus_resume(port_t *port)
         ret = ESP_ERR_INVALID_STATE;
         goto exit;
     }
+    HCD_EXIT_CRITICAL();
+    //vTaskDelay(pdMS_TO_TICKS(RESUME_HOLD_MS));
+    vTaskDelay(pdMS_TO_TICKS(500));
+    HCD_ENTER_CRITICAL();
+
     // 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(RESUME_HOLD_MS));
+    vTaskDelay(pdMS_TO_TICKS(500));
     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);
@@ -1387,7 +1396,8 @@ 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(RESUME_RECOVERY_MS));
+    vTaskDelay(pdMS_TO_TICKS(500));
     HCD_ENTER_CRITICAL();
     if (port->state != HCD_PORT_STATE_RESUMING || !port->flags.conn_dev_ena) {
         // Port state unexpectedly changed
@@ -1396,7 +1406,14 @@ static esp_err_t _port_cmd_bus_resume(port_t *port)
     }
     port->state = HCD_PORT_STATE_ENABLED;
 
+    if (usb_dwc_hal_port_check_if_suspended(port->hal)) {
+        printf("Again suspended\n");
+    }
+
     ret = ESP_OK;
+//    esp_rom_printf("resume: 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));
+
 exit:
     return ret;
 }
@@ -1490,8 +1507,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);
@@ -2693,6 +2713,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;
diff --git a/host/usb/src/hub.c b/host/usb/src/hub.c
@@ -444,7 +444,14 @@ static void root_port_handle_events(hcd_port_handle_t root_port_hdl)
     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);
+        //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
@@ -484,7 +491,7 @@ static void root_port_req(hcd_port_handle_t root_port_hdl)
         }
     }
     if (port_reqs & PORT_REQ_SUSPEND) {
-        ESP_LOGD(HUB_DRIVER_TAG, "Suspending the root port");
+        ESP_LOGI(HUB_DRIVER_TAG, "Suspending the root port");
 
         HUB_DRIVER_ENTER_CRITICAL();
         const root_port_state_t root_state = p_hub_driver_obj->dynamic.root_port_state;
@@ -507,7 +514,7 @@ static void root_port_req(hcd_port_handle_t root_port_hdl)
         usbh_devs_set_pm_actions_all(USBH_DEV_SUSPEND_EVT);
     }
     if (port_reqs & PORT_REQ_RESUME) {
-        ESP_LOGD(HUB_DRIVER_TAG, "Resuming the root port");
+        ESP_LOGI(HUB_DRIVER_TAG, "Resuming the root port");
 
         HUB_DRIVER_ENTER_CRITICAL();
         const root_port_state_t root_state = p_hub_driver_obj->dynamic.root_port_state;
diff --git a/host/usb/src/usb_host.c b/host/usb/src/usb_host.c
@@ -486,7 +486,14 @@ static bool endpoint_callback(usbh_ep_handle_t ep_hdl, usbh_ep_event_t ep_event,
     return yield;
 }
 
-static void get_config_desc_transfer_cb(usb_transfer_t *transfer)
+/**
+ * @brief Control transfer callback
+ *
+ * This callback is used in ctrl transfers for remote wakeup feature and multiconfig feature
+ *
+ * @param[in] transfer Pointer to ctrl transfer
+ */
+static void ctrl_transfer_cb(usb_transfer_t *transfer)
 {
     SemaphoreHandle_t transfer_done = (SemaphoreHandle_t)transfer->context;
     xSemaphoreGive(transfer_done);
@@ -1333,7 +1340,9 @@ esp_err_t usb_host_get_active_config_descriptor(usb_device_handle_t dev_hdl, con
 static usb_transfer_status_t wait_for_transmission_done(usb_transfer_t *transfer)
 {
     SemaphoreHandle_t transfer_done = (SemaphoreHandle_t)transfer->context;
+    esp_rom_printf("Transfer wait\n");
     xSemaphoreTake(transfer_done, portMAX_DELAY);
+    esp_rom_printf("Transfer done\n");
     usb_transfer_status_t status = transfer->status;
 
     // EP0 halt->flush->clear is managed by USBH and lower layers
@@ -1409,7 +1418,7 @@ esp_err_t usb_host_get_config_desc(usb_host_client_handle_t client_hdl, usb_devi
 
     ctrl_transfer->device_handle = dev_hdl;
     ctrl_transfer->bEndpointAddress = 0;
-    ctrl_transfer->callback = get_config_desc_transfer_cb;
+    ctrl_transfer->callback = ctrl_transfer_cb;
     ctrl_transfer->context = (void *)transfer_done;
 
     // Initiate control transfer for short config descriptor
@@ -1460,7 +1469,7 @@ esp_err_t usb_host_free_config_desc(const usb_config_desc_t *config_desc)
 }
 
 /**
- * @brief Do control transfer
+ * @brief Do control transfer to get/set remote wakeup feature
  *
  * This function: allocates transfer, sets the transfer params, submits the transfer and evaluates it
  *
@@ -1474,10 +1483,12 @@ esp_err_t usb_host_free_config_desc(const usb_config_desc_t *config_desc)
  *
  * @return
  *    - ESP_OK: Transfer successful
- *      TODO
+ *    - ESP_ERR_NO_MEM: Not enough memory
+ *    - ESP_ERR_INVALID_STATE: Control transfer failed
+ *    - ESP_ERR_INVALID_RESPONSE: Invalid number of bytest returned by IN transfer stage
  */
-static esp_err_t do_control_transfer(usb_host_client_handle_t client_hdl, usb_device_handle_t dev_hdl,
-                                     usb_setup_packet_t *setup_packet, void *data_buf, size_t data_len)
+static esp_err_t remote_wake_do_control_transfer(usb_host_client_handle_t client_hdl, usb_device_handle_t dev_hdl,
+                                                 usb_setup_packet_t *setup_packet, void *data_buf, size_t data_len)
 {
     esp_err_t ret;
     usb_transfer_t *ctrl_transfer = NULL;
@@ -1494,7 +1505,7 @@ static esp_err_t do_control_transfer(usb_host_client_handle_t client_hdl, usb_de
 
     ctrl_transfer->device_handle = dev_hdl;
     ctrl_transfer->bEndpointAddress = 0;
-    ctrl_transfer->callback = get_config_desc_transfer_cb;
+    ctrl_transfer->callback = ctrl_transfer_cb;
     ctrl_transfer->context = (void *)transfer_done;
 
     // Copy setup packet
@@ -1512,15 +1523,9 @@ static esp_err_t do_control_transfer(usb_host_client_handle_t client_hdl, usb_de
         goto transfer_error;
     }
 
-    // Wait for completion
-    //wait_for_transmission_done(ctrl_transfer);
-    if (xSemaphoreTake(transfer_done, portMAX_DELAY) != pdTRUE) {
-        ret = ESP_ERR_TIMEOUT; // should not happen, but just in case
-        goto transfer_error;
-    }
-
-    // Check transfer status
-    if (ctrl_transfer->status != USB_TRANSFER_STATUS_COMPLETED) {
+    // Wait for transfer to finish
+    const usb_transfer_status_t status_short_desc = wait_for_transmission_done(ctrl_transfer);
+    if (status_short_desc != USB_TRANSFER_STATUS_COMPLETED) {
         ESP_LOGE(USB_HOST_TAG, "Control transfer failed, status=%d", ctrl_transfer->status);
         ret = ESP_ERR_INVALID_STATE;
         goto transfer_error;
@@ -1602,7 +1607,6 @@ static esp_err_t validate_device_remote_wakeup(usb_host_client_handle_t client_h
 esp_err_t usb_host_device_remote_wakeup_enable(usb_host_client_handle_t client_hdl, usb_device_handle_t dev_hdl, bool enable)
 {
     HOST_CHECK(client_hdl != NULL && dev_hdl != NULL, ESP_ERR_INVALID_ARG);
-    esp_err_t ret;
     ESP_RETURN_ON_ERROR(validate_device_remote_wakeup(client_hdl, dev_hdl), USB_HOST_TAG, "Device remote wakeup validation failed");
 
     usb_setup_packet_t setup_packet = {0};
@@ -1615,25 +1619,22 @@ esp_err_t usb_host_device_remote_wakeup_enable(usb_host_client_handle_t client_h
     }
 
     // Send ctrl transfer enabling/disabling the remote wakeup
-    ESP_RETURN_ON_ERROR(do_control_transfer(client_hdl, dev_hdl, &setup_packet, NULL, 0), USB_HOST_TAG, "CTRL transfer failed");
+    ESP_RETURN_ON_ERROR(remote_wake_do_control_transfer(client_hdl, dev_hdl, &setup_packet, NULL, 0), USB_HOST_TAG, "CTRL transfer failed");
 
     return ESP_OK;
 }
 
 esp_err_t usb_host_device_remote_wakeup_check(usb_host_client_handle_t client_hdl, usb_device_handle_t dev_hdl, bool *enabled)
 {
-    HOST_CHECK(client_hdl != NULL && dev_hdl != NULL, ESP_ERR_INVALID_ARG);
-    esp_err_t ret;
+    HOST_CHECK(client_hdl != NULL && dev_hdl != NULL && enabled != NULL, ESP_ERR_INVALID_ARG);
     ESP_RETURN_ON_ERROR(validate_device_remote_wakeup(client_hdl, dev_hdl), USB_HOST_TAG, "Device remote wakeup validation failed");
 
     usb_setup_packet_t setup_packet = {0};
     usb_device_status_t device_status;
     USB_SETUP_PACKET_INIT_GET_STATUS(&setup_packet);
 
     // Send ctrl transfer checking the remote wakeup
-    ESP_RETURN_ON_ERROR(
-        do_control_transfer(client_hdl, dev_hdl, &setup_packet, &device_status, sizeof(device_status)),
-        USB_HOST_TAG, "CTRL transfer failed");
+    ESP_RETURN_ON_ERROR(remote_wake_do_control_transfer(client_hdl, dev_hdl, &setup_packet, &device_status, sizeof(device_status)), USB_HOST_TAG, "CTRL transfer failed");
 
     // Check current status of remote wakeup
     *enabled = device_status.remote_wakeup;
@@ -2063,7 +2064,7 @@ esp_err_t usb_host_transfer_submit_control(usb_host_client_handle_t client_hdl,
     // Check if the root port is suspended (global suspend)
     if (hub_root_is_suspended()) {
         // Root port is suspended at the time we are submitting a ctrl transfer
-        ESP_LOGD(USB_HOST_TAG, "Resuming the root port");
+        ESP_LOGI(USB_HOST_TAG, "Resuming the root port");
 
         ret = usb_host_lib_root_port_resume();
         if (ret != ESP_OK) {
diff --git a/host/usb/test/target_test/usb_host/main/test_usb_host_async.c b/host/usb/test/target_test/usb_host/main/test_usb_host_async.c
@@ -702,12 +702,19 @@ TEST_CASE("Test USB Host remote wakeup setup", "[usb_host][low_speed][full_speed
 
     printf("Remote wake enabled\n");
     usb_host_lib_root_port_suspend();
-    vTaskDelay(1000);
+    vTaskDelay(pdMS_TO_TICKS(5000));
+//    usb_host_lib_root_port_resume();
 
-//    // Disable remote wakeup on the device
-//    test_remote_wake_disable();
+
+//    // Read the current remote wakeup state from the device, expect it to be enabled from the previous operation
+//    test_remote_wake_check(true);
 //    TEST_ASSERT_EQUAL_MESSAGE(
-//        pdTRUE, xSemaphoreTake(dev_ready_smp, TEST_REMOTE_WAKE_SMP_WAIT_MS), "Remote wake not disabled on time");
+//        pdTRUE, xSemaphoreTake(dev_ready_smp, TEST_REMOTE_WAKE_SMP_WAIT_MS), "Remote wake not checked on time");
+
+    // Disable remote wakeup on the device
+    test_remote_wake_disable();
+    TEST_ASSERT_EQUAL_MESSAGE(
+        pdTRUE, xSemaphoreTake(dev_ready_smp, TEST_REMOTE_WAKE_SMP_WAIT_MS), "Remote wake not disabled on time");
 //
 //    // Read the current remote wakeup state from the device, expect it to be disabled from the previous operation
 //    test_remote_wake_check(false);
