feat(usb_host): Remote wake debug WIP

Author: peter-marcisovsky

host/usb/src/hcd_dwc.c

@@ -832,7 +832,7 @@ static hcd_port_event_t _intr_hdlr_hprt(port_t *port, usb_dwc_hal_port_event_t h
         break;
     }
     case USB_DWC_HAL_PORT_EVENT_REMOTE_WAKEUP: {
-        ESP_EARLY_LOGI(HCD_DWC_TAG, "WAKE");
+        //ESP_EARLY_LOGI(HCD_DWC_TAG, "WAKE");
         //port->state = HCD_PORT_STATE_ENABLED;
         port_event = HCD_PORT_EVENT_REMOTE_WAKEUP;
         break;
@@ -1334,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;
     }
 
@@ -1358,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;
     }
 
@@ -1370,23 +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;
     }
-    HCD_EXIT_CRITICAL();
-    //vTaskDelay(pdMS_TO_TICKS(RESUME_HOLD_MS));
-    vTaskDelay(pdMS_TO_TICKS(500));
-    HCD_ENTER_CRITICAL();
+    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(500));
+    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);
@@ -1396,8 +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(500));
+    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
@@ -1406,14 +1429,7 @@ 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;
 }

host/usb/src/hub.c

@@ -491,7 +491,7 @@ static void root_port_req(hcd_port_handle_t root_port_hdl)
         }
     }
     if (port_reqs & PORT_REQ_SUSPEND) {
-        ESP_LOGI(HUB_DRIVER_TAG, "Suspending the root port");
+        ESP_LOGD(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;
@@ -514,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_LOGI(HUB_DRIVER_TAG, "Resuming the root port");
+        ESP_LOGD(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;

host/usb/test/target_test/common/hcd_common.c

@@ -127,7 +127,7 @@ void test_hcd_expect_port_event(hcd_port_handle_t port_hdl, hcd_port_event_t exp
     // Check the contents of that event message
     TEST_ASSERT_EQUAL(port_hdl, msg.port_hdl);
     TEST_ASSERT_EQUAL_MESSAGE(expected_event, msg.port_event, "Unexpected event");
-    printf("\t-> Port event\n");
+    //printf("\t-> Port event\n");
 }
 
 void test_hcd_expect_pipe_event(hcd_pipe_handle_t pipe_hdl, hcd_pipe_event_t expected_event)

host/usb/test/target_test/hcd/main/test_hcd_port.c

@@ -173,7 +173,7 @@ TEST_CASE("Test HCD port suspend and resume", "[port][low_speed][full_speed][hig
     TEST_ASSERT_EQUAL(ESP_OK, hcd_port_command(port_hdl, HCD_PORT_CMD_SUSPEND));
     TEST_ASSERT_EQUAL(HCD_PORT_STATE_SUSPENDED, hcd_port_get_state(port_hdl));
     printf("Suspended\n");
-    vTaskDelay(pdMS_TO_TICKS(100)); // Give some time for bus to remain suspended
+    vTaskDelay(pdMS_TO_TICKS(5000)); // Give some time for bus to remain suspended
 
     // Resume the port
     TEST_ASSERT_EQUAL(ESP_OK, hcd_port_command(port_hdl, HCD_PORT_CMD_RESUME));
@@ -392,3 +392,96 @@ TEST_CASE("Test HCD port command bailout", "[port][low_speed][full_speed][high_s
     vTaskDelete(task_handle);
     vSemaphoreDelete(sync_sem);
 }
+
+bool test_hcd_check_remote_wake(hcd_pipe_handle_t *pipe, urb_t *get_status_urb)
+{
+    // Initialize with a "Get status request" USB_SETUP_PACKET_INIT_GET_STATUS
+    get_status_urb->transfer.num_bytes = sizeof(usb_setup_packet_t) + sizeof(usb_device_status_t);
+    USB_SETUP_PACKET_INIT_GET_STATUS((usb_setup_packet_t *)get_status_urb->transfer.data_buffer);
+    get_status_urb->transfer.context = URB_CONTEXT_VAL;
+
+    TEST_ASSERT_EQUAL(ESP_OK, hcd_urb_enqueue(pipe, get_status_urb));
+    test_hcd_expect_pipe_event(pipe, HCD_PIPE_EVENT_URB_DONE);
+    urb_t *urb = hcd_urb_dequeue(pipe);
+    TEST_ASSERT_EQUAL(get_status_urb, urb);
+    TEST_ASSERT_EQUAL_MESSAGE(USB_TRANSFER_STATUS_COMPLETED, urb->transfer.status, "Transfer NOT completed");
+    TEST_ASSERT_EQUAL(URB_CONTEXT_VAL, urb->transfer.context);
+
+    TEST_ASSERT_EQUAL(sizeof(usb_setup_packet_t) + sizeof(usb_device_status_t), urb->transfer.actual_num_bytes);
+    TEST_ASSERT_EQUAL(urb->transfer.num_bytes, urb->transfer.actual_num_bytes);
+    usb_device_status_t *device_status = (usb_device_status_t *)(urb->transfer.data_buffer + sizeof(usb_setup_packet_t));
+
+    const bool enabled = device_status->remote_wakeup;
+    printf("Remote wakeup is currently %s\n", ((enabled)) ? ("enabled") : ("disabled") );
+    return enabled;
+}
+
+void test_hcd_set_remote_wake(hcd_pipe_handle_t *pipe, urb_t *set_feature_urb)
+{
+    set_feature_urb->transfer.num_bytes = sizeof(usb_setup_packet_t);
+    USB_SETUP_PACKET_INIT_SET_FEATURE((usb_setup_packet_t *)set_feature_urb->transfer.data_buffer, DEVICE_REMOTE_WAKEUP);
+    set_feature_urb->transfer.context = URB_CONTEXT_VAL;
+
+
+    TEST_ASSERT_EQUAL(ESP_OK, hcd_urb_enqueue(pipe, set_feature_urb));
+    test_hcd_expect_pipe_event(pipe, HCD_PIPE_EVENT_URB_DONE);
+    urb_t *urb = hcd_urb_dequeue(pipe);
+    TEST_ASSERT_EQUAL(set_feature_urb, urb);
+    TEST_ASSERT_EQUAL_MESSAGE(USB_TRANSFER_STATUS_COMPLETED, urb->transfer.status, "Transfer NOT completed");
+    TEST_ASSERT_EQUAL(URB_CONTEXT_VAL, urb->transfer.context);
+
+    TEST_ASSERT_EQUAL(sizeof(usb_setup_packet_t), urb->transfer.actual_num_bytes);
+    TEST_ASSERT_EQUAL(urb->transfer.num_bytes, urb->transfer.actual_num_bytes);
+}
+#define TEST_HID_DEV_SPEED                  USB_SPEED_LOW
+TEST_CASE("Test HCD port remote wakeup", "[port][low_speed][full_speed][high_speed]")
+{
+    usb_speed_t port_speed = test_hcd_wait_for_conn(port_hdl);  // Trigger a connection
+    TEST_ASSERT_EQUAL_MESSAGE(TEST_HID_DEV_SPEED, port_speed, "Connected device is not Low Speed!");
+    vTaskDelay(pdMS_TO_TICKS(100)); // Short delay send of SOF (for FS) or EOPs (for LS)
+
+    hcd_pipe_handle_t default_pipe = test_hcd_pipe_alloc(port_hdl, NULL, 0, port_speed); // Create a default pipe (using a NULL EP descriptor)
+    uint8_t dev_addr = test_hcd_enum_device(default_pipe);
+
+    urb_t *get_status_urb = test_hcd_alloc_urb(0, URB_DATA_BUFF_SIZE);
+    urb_t *set_feature_urb = test_hcd_alloc_urb(0, URB_DATA_BUFF_SIZE);
+
+    test_hcd_check_remote_wake(default_pipe, get_status_urb);
+    test_hcd_set_remote_wake(default_pipe, set_feature_urb);
+    test_hcd_check_remote_wake(default_pipe, get_status_urb);
+
+    // Halt the default pipe before suspending
+    TEST_ASSERT_EQUAL(HCD_PIPE_STATE_ACTIVE, hcd_pipe_get_state(default_pipe));
+    TEST_ASSERT_EQUAL(ESP_OK, hcd_pipe_command(default_pipe, HCD_PIPE_CMD_HALT));
+    TEST_ASSERT_EQUAL(HCD_PIPE_STATE_HALTED, hcd_pipe_get_state(default_pipe));
+
+    // Suspend the port
+    TEST_ASSERT_EQUAL(ESP_OK, hcd_port_command(port_hdl, HCD_PORT_CMD_SUSPEND));
+    TEST_ASSERT_EQUAL(HCD_PORT_STATE_SUSPENDED, hcd_port_get_state(port_hdl));
+    printf("Suspended\n");
+    test_hcd_expect_port_event(port_hdl, HCD_PORT_EVENT_REMOTE_WAKEUP);
+    TEST_ASSERT_EQUAL(HCD_PORT_EVENT_REMOTE_WAKEUP, hcd_port_handle_event(port_hdl));
+    //printf("Waken\n");
+
+    // Resume the port
+    TEST_ASSERT_EQUAL(ESP_OK, hcd_port_command(port_hdl, HCD_PORT_CMD_RESUME));
+    TEST_ASSERT_EQUAL(HCD_PORT_STATE_ENABLED, hcd_port_get_state(port_hdl));
+    printf("Resumed\n");
+
+    vTaskDelay(pdMS_TO_TICKS(5000));
+
+    TEST_ASSERT_EQUAL(HCD_PIPE_STATE_HALTED, hcd_pipe_get_state(default_pipe));
+    TEST_ASSERT_EQUAL(ESP_OK, hcd_pipe_command(default_pipe, HCD_PIPE_CMD_CLEAR));
+    TEST_ASSERT_EQUAL(HCD_PIPE_STATE_ACTIVE, hcd_pipe_get_state(default_pipe));
+
+
+
+    printf("Issue check\n");
+    test_hcd_check_remote_wake(default_pipe, get_status_urb);
+
+    test_hcd_pipe_free(default_pipe);
+    test_hcd_free_urb(get_status_urb);
+    test_hcd_free_urb(set_feature_urb);
+    // Cleanup
+    test_hcd_wait_for_disconn(port_hdl, false);
+}

host/usb/test/target_test/usb_host/main/test_usb_host_async.c

@@ -700,7 +700,7 @@ TEST_CASE("Test USB Host remote wakeup setup", "[usb_host][low_speed][full_speed
     TEST_ASSERT_EQUAL_MESSAGE(
         pdTRUE, xSemaphoreTake(dev_ready_smp, TEST_REMOTE_WAKE_SMP_WAIT_MS), "Remote wake not checked on time");
 
-    printf("Remote wake enabled\n");
+//    printf("Remote wake enabled\n");
     usb_host_lib_root_port_suspend();
     vTaskDelay(pdMS_TO_TICKS(5000));
 //    usb_host_lib_root_port_resume();