From 1e03fb806dc1ca6fe54ffb2acc6d69928cf97dcf Mon Sep 17 00:00:00 2001 From: David Cermak Date: Thu, 24 Oct 2024 14:34:55 +0200 Subject: [PATCH 1/2] feat(wifi_remote): Add support for IDF-v5.5 --- .github/workflows/build.yml | 2 +- .github/workflows/smoke_compat.yml | 4 +- .../examples/server/sdkconfig.ci.c6 | 1 + .../idf_v5.5/Kconfig.slave_select.in | 21 + .../idf_v5.5/Kconfig.soc_wifi_caps.in | 321 ++++++++ .../esp_wifi_remote/idf_v5.5/Kconfig.wifi.in | 726 ++++++++++++++++++ .../idf_v5.5/esp_wifi_remote_weak.c | 432 +++++++++++ .../idf_v5.5/esp_wifi_with_remote.c | 428 +++++++++++ .../idf_v5.5/include/esp_wifi_remote_api.h | 91 +++ .../idf_v5.5/include/esp_wifi_types_native.h | 134 ++++ .../wifi_apps/roaming_app/src/Kconfig.roaming | 0 .../esp_hosted/idf_v5.5/esp_hosted_mock.c | 428 +++++++++++ .../idf_v5.5/include/esp_hosted_mock.h | 91 +++ .../smoke_test/main/idf_v5.5/all_wifi_calls.c | 450 +++++++++++ .../main/idf_v5.5/all_wifi_remote_calls.c | 450 +++++++++++ 15 files changed, 3576 insertions(+), 3 deletions(-) create mode 100644 components/esp_wifi_remote/idf_v5.5/Kconfig.slave_select.in create mode 100644 components/esp_wifi_remote/idf_v5.5/Kconfig.soc_wifi_caps.in create mode 100644 components/esp_wifi_remote/idf_v5.5/Kconfig.wifi.in create mode 100644 components/esp_wifi_remote/idf_v5.5/esp_wifi_remote_weak.c create mode 100644 components/esp_wifi_remote/idf_v5.5/esp_wifi_with_remote.c create mode 100644 components/esp_wifi_remote/idf_v5.5/include/esp_wifi_remote_api.h create mode 100644 components/esp_wifi_remote/idf_v5.5/include/esp_wifi_types_native.h create mode 100644 components/esp_wifi_remote/idf_v5.5/wifi_apps/roaming_app/src/Kconfig.roaming create mode 100644 components/esp_wifi_remote/test/smoke_test/components/esp_hosted/idf_v5.5/esp_hosted_mock.c create mode 100644 components/esp_wifi_remote/test/smoke_test/components/esp_hosted/idf_v5.5/include/esp_hosted_mock.h create mode 100644 components/esp_wifi_remote/test/smoke_test/main/idf_v5.5/all_wifi_calls.c create mode 100644 components/esp_wifi_remote/test/smoke_test/main/idf_v5.5/all_wifi_remote_calls.c diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 9e5e365..1b611c9 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -12,7 +12,7 @@ jobs: name: Build WiFi Remote Test strategy: matrix: - idf_ver: ["latest", "release-v5.3"] + idf_ver: ["latest", "release-v5.4", "release-v5.3"] test: [ { app: smoke_test, path: "test/smoke_test" }] runs-on: ubuntu-20.04 container: espressif/idf:${{ matrix.idf_ver }} diff --git a/.github/workflows/smoke_compat.yml b/.github/workflows/smoke_compat.yml index 241618c..7439583 100644 --- a/.github/workflows/smoke_compat.yml +++ b/.github/workflows/smoke_compat.yml @@ -14,7 +14,7 @@ jobs: name: Check API compatibility of WiFi Remote strategy: matrix: - idf_ver: ["latest", "release-v5.3"] + idf_ver: ["latest", "release-v5.4", "release-v5.3"] runs-on: ubuntu-20.04 container: espressif/idf:${{ matrix.idf_ver }} steps: @@ -33,7 +33,7 @@ jobs: name: Build IDF examples with WiFi Remote strategy: matrix: - idf_ver: ["latest", "release-v5.3"] + idf_ver: ["latest", "release-v5.4", "release-v5.3"] idf_target: ["esp32p4", "esp32h2", "esp32s3"] test: [ { app: idf_mqtt_example, path: "examples/protocols/mqtt/tcp" }] runs-on: ubuntu-20.04 diff --git a/components/esp_wifi_remote/examples/server/sdkconfig.ci.c6 b/components/esp_wifi_remote/examples/server/sdkconfig.ci.c6 index 58f71a3..2e773d2 100644 --- a/components/esp_wifi_remote/examples/server/sdkconfig.ci.c6 +++ b/components/esp_wifi_remote/examples/server/sdkconfig.ci.c6 @@ -4,3 +4,4 @@ CONFIG_ESP_WIFI_REMOTE_EPPP_UART_RX_PIN=23 CONFIG_ESP_WIFI_REMOTE_EPPP_CLIENT_CA="MIIDIzCCAgugAwIBAgIUTWOEAhITHAm2ixn5i2XlSeL01mowDQYJKoZIhvcNAQELBQAwITELMAkGA1UEBhMCQ1oxEjAQBgNVBAMMCUVzcHJlc3NpZjAeFw0yNDA0MTAxNTEzNTdaFw0yNTA0MTAxNTEzNTdaMCExCzAJBgNVBAYTAkNaMRIwEAYDVQQDDAlFc3ByZXNzaWYwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCSewupiSiyZNfLdVW0/smQB0yJ0Ua0KNU423ZZ7HMSrBPhfHtnQQ6SJqTdfqGCl1lvSsJZN9aT4iaEtyAm6N9trmSbSWVlkn0D8MQuBHwHCT7jRsLnyRYURRPUs11TkQdqvxtsIFqFVFB/8nJqy4IuU6JFTobCbUappQMdHKCyidXJUVHZ5y+KK2kEYFiv26rHlry+D0O/VO5/xl97uFIzP0JVdnGNu5sy9uoRYp+ua0moD3tx12tYe83XIuHKbKHMpIayjPIoaZzhCwomZMh0NETEQ5t7RXYneRGZvXXyIb/O8jPCmbfSqJ6umhPhf757xBXHaC0iG/xlND0dnRIvAgMBAAGjUzBRMB0GA1UdDgQWBBTgqejeFi/5UAgNhNv4aH7UniqmQjAfBgNVHSMEGDAWgBTgqejeFi/5UAgNhNv4aH7UniqmQjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQCQnqIue6KLXkjOXGtO5Bl4TkZpYAPkQuGiM6RgaBhdt3P5J1mF4T6aav8qGXSHShy1E3XkMR5OC3hkhG+FKBVKSaQLsRipuo+CeHp5RfOCNEzNI0RZwKJI92RcdWlhOA+pOTruXSoYuZvj0xnaePEghTrr7PLdgirpzIffLjvgh8BcQAz5QzP0U1XHkAVzbQjUBChiEiXVAlKChk7kKB/wEzwX3cvYKlTc89RB6I3+a+KhYJt3LIAOIDeyVp+Bhmb1JSo3H7zMpJAksG2RMnZCwlHeR6cMbb/OtJYeUKpNUxj0SaeNyHo3y8Q21G8TXcc9suU6sYJi780ArulC3cbQ" CONFIG_ESP_WIFI_REMOTE_EPPP_SERVER_CRT="MIICvzCCAacCFCanehvaDq0bhjZA/3W/h4b0p1VHMA0GCSqGSIb3DQEBCwUAMCExCzAJBgNVBAYTAkNaMRIwEAYDVQQDDAlFc3ByZXNzaWYwHhcNMjQwNDEwMTUxMzU3WhcNMjUwNDEwMTUxMzU3WjAXMRUwEwYDVQQDDAwxOTIuMTY4LjExLjEwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCsyR1FqBhBT3mr9AH/6iYoo1VCHbzB+V/StfCokv6LnMm6t7yiu1GgzqVk1aiHrUJGor5tBfpXywLnfVjFByZSBhhEkI26xQVdK5pZUsU1hMCJ6CWd105CD+0e5tTbGzF0PNH2KzFdg2YUqOSWBsfmgSNtnp3az8XmZN5i4958Sxe1kMN3f6EQwvkxZHGVgXCrUsdsHAEyV5NVfYq7P2nBxz3HJSGkTScFd+PRp3nfVFbBbCQDmqwoPZ7E/gUXjoLIFf7zjIMzCXTsZd/dKgXWWEFHq8SPWmLtAEvPCProT5QUaZ3gJSHup9Wmh+ok9W8wrwMj1sHlfiZWo3tatFmvAgMBAAEwDQYJKoZIhvcNAQELBQADggEBAAeWiWyTTyNbZRHq8X9qbr7oG6SYWOqDR3lPfs8wB8B+1Hez/JCrI/8quNqVAjhoTtebtp/2mcEseQDj5BOx8NBCDAmUOwB+ZKPzUoGiALy5XFGqUXzTv9tBMotC6dAMTIbT2Ql1mPJgtg2+Qv7vg6hsk4rlPMoICqN3lW6zXo2GOuJ56Tj5NkvVxv6MOVN2e3p67c92rRBysAxP6MaV8S9s2+VvnENuxpU5cq8sfzaxFkTn4UD9PoQSYGPNL9kv7Y/h7H5wlKiFY24KowPTHjulaH/DC9Fk4F1gNWjnkFcOgepzhiw/ibLrivMptUFtplFFbxGuwY5PaA26yhliBv8=" CONFIG_ESP_WIFI_REMOTE_EPPP_SERVER_KEY="MIIEowIBAAKCAQEArMkdRagYQU95q/QB/+omKKNVQh28wflf0rXwqJL+i5zJure8ortRoM6lZNWoh61CRqK+bQX6V8sC531YxQcmUgYYRJCNusUFXSuaWVLFNYTAieglnddOQg/tHubU2xsxdDzR9isxXYNmFKjklgbH5oEjbZ6d2s/F5mTeYuPefEsXtZDDd3+hEML5MWRxlYFwq1LHbBwBMleTVX2Kuz9pwcc9xyUhpE0nBXfj0ad531RWwWwkA5qsKD2exP4FF46CyBX+84yDMwl07GXf3SoF1lhBR6vEj1pi7QBLzwj66E+UFGmd4CUh7qfVpofqJPVvMK8DI9bB5X4mVqN7WrRZrwIDAQABAoIBAHDh833OlAoXIiZ1A9lt4AAstUa8ptUTVscSlmeLoUEU7bZO0659MpccanG2JKR/TQ1YxY/0l9lDiGI0Qgp24VI1KSWiSvX6Qcbc9bnlmXGdiSyPvgOg5j/Cp+fIZse+vFB0a7eoAFhXwBk/PhfF1lOBiuPS/M43b9NVkvSIapJIaS4pvmkBvKSzHEvSArDHcr+1vFuFssZyHTnXmVgB4WiYPX4ACE8S18cnjXIQDfx8zpBbF/itnqeHDC5echnto63UDB7qHZa+DVvakhEtv50rzAuhq3/uspBClucuQUhlAAimd4OeKuwB1UC0K9AamDZRCnsf0O/Bo8/W4SWYAgECgYEA5LpRmcQ9ghW8V6bzwYvK8XGWyeNy94qOpZysFeOjxqe2sUTHVY2Ty1s44RbDd/bm0n3xcxMtLof/6Oz4TX+JseskQWBQlRiwuqc46CcHHjUQ8qokfWtASwWYgb6AzLa4B/D+H91wP/AzRfYNdRB9xhSCr7AOk9Vo5KmEPRLN/VMCgYEAwWM3oDaCkMicoMgngz/9dZ2/1yohfYdrupC0pGPhtBFNKghP+9S+e6cwWKzwQJbbRjGgt1OA3e4UEuTHJjp1tw+BRkNQ/1FI0psJGwmOtveAE7yiHf7Tw7mNDk+j32vpAPWnL7I3222Kv4G8xi2vSbn3IaI2sl7M0RHLJc/JCrUCgYBh4dI16aMg3khhglLiSv6oYKHU9/8lLChreyaxn19hDjjCl9puJE5RQlKPEPzJg+G3xqnjQxucxBqiBXclQyUb/LLhP2R8ybonxpQ11S3YoYEFOAaxnYpAEL75Fxtrf+41h85YuJzm39YxZGDR7iLE99YNdVxnq3ZeFKVAtaFtfQKBgEalPRvc7eOANZ+SnsSWqru9regnLubRgqw70pG/HyONsnepY7amaBN55vJt8rJVqbLBzGlMKuZn45NnWc0ATCJcmqgVTVCH3Cd7lV74Jdd3IKWVIk/82FVGwl25AC9NF2hPVQzaeQdCxA3jkhd/dupi8gGqZXrRoNa7PlAI0POFAoGBAJDlvddpEYcKhT3pncXIorVfYR67TlXVcKZHvL9XljwgDuf1j52ZhAs8UuoWW+NSgOdWVxocAshrLbu5fjSIN92oDAq6YVeXvxis6e8l79xd6A5iFH9Po+dEuQSaOR8XgW56n39oVR2hfaFwqijawIEzDNlYpiXAD3qNyW5e0MKA" +CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE=y diff --git a/components/esp_wifi_remote/idf_v5.5/Kconfig.slave_select.in b/components/esp_wifi_remote/idf_v5.5/Kconfig.slave_select.in new file mode 100644 index 0000000..5e31536 --- /dev/null +++ b/components/esp_wifi_remote/idf_v5.5/Kconfig.slave_select.in @@ -0,0 +1,21 @@ +# This file is auto-generated + choice SLAVE_IDF_TARGET + prompt "choose slave target" + default SLAVE_IDF_TARGET_ESP32 + config SLAVE_IDF_TARGET_ESP32 + bool "esp32" + config SLAVE_IDF_TARGET_ESP32S2 + bool "esp32s2" + config SLAVE_IDF_TARGET_ESP32C3 + bool "esp32c3" + config SLAVE_IDF_TARGET_ESP32S3 + bool "esp32s3" + config SLAVE_IDF_TARGET_ESP32C2 + bool "esp32c2" + config SLAVE_IDF_TARGET_ESP32C6 + bool "esp32c6" + config SLAVE_IDF_TARGET_ESP32C5 + bool "esp32c5" + config SLAVE_IDF_TARGET_ESP32C61 + bool "esp32c61" + endchoice diff --git a/components/esp_wifi_remote/idf_v5.5/Kconfig.soc_wifi_caps.in b/components/esp_wifi_remote/idf_v5.5/Kconfig.soc_wifi_caps.in new file mode 100644 index 0000000..d01366a --- /dev/null +++ b/components/esp_wifi_remote/idf_v5.5/Kconfig.soc_wifi_caps.in @@ -0,0 +1,321 @@ +# This file is auto-generated + +if SLAVE_IDF_TARGET_ESP32 + + config SLAVE_SOC_WIFI_SUPPORTED + bool + default y + + config SLAVE_SOC_WIFI_WAPI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_CSI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_MESH_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW + bool + default y + + config SLAVE_SOC_WIFI_NAN_SUPPORT + bool + default y + +endif # ESP32 + +if SLAVE_IDF_TARGET_ESP32S2 + + config SLAVE_SOC_WIFI_SUPPORTED + bool + default y + + config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH + int + default 12 + + config SLAVE_SOC_WIFI_HW_TSF + bool + default y + + config SLAVE_SOC_WIFI_FTM_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_WAPI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_CSI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_MESH_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW + bool + default y + + config SLAVE_SOC_WIFI_NAN_SUPPORT + bool + default y + +endif # ESP32S2 + +if SLAVE_IDF_TARGET_ESP32C3 + + config SLAVE_SOC_WIFI_SUPPORTED + bool + default y + + config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH + int + default 12 + + config SLAVE_SOC_WIFI_HW_TSF + bool + default y + + config SLAVE_SOC_WIFI_FTM_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_GCMP_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_WAPI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_CSI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_MESH_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW + bool + default y + + config SLAVE_SOC_WIFI_PHY_NEEDS_USB_WORKAROUND + bool + default y + +endif # ESP32C3 + +if SLAVE_IDF_TARGET_ESP32S3 + + config SLAVE_SOC_WIFI_SUPPORTED + bool + default y + + config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH + int + default 12 + + config SLAVE_SOC_WIFI_HW_TSF + bool + default y + + config SLAVE_SOC_WIFI_FTM_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_GCMP_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_WAPI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_CSI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_MESH_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW + bool + default y + + config SLAVE_SOC_WIFI_PHY_NEEDS_USB_WORKAROUND + bool + default y + +endif # ESP32S3 + +if SLAVE_IDF_TARGET_ESP32C2 + + config SLAVE_SOC_WIFI_SUPPORTED + bool + default y + + config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH + int + default 12 + + config SLAVE_SOC_WIFI_HW_TSF + bool + default y + + config SLAVE_SOC_WIFI_FTM_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW + bool + default y + + config SLAVE_SOC_WIFI_PHY_NEEDS_USB_WORKAROUND + bool + default y + +endif # ESP32C2 + +if SLAVE_IDF_TARGET_ESP32C6 + + config SLAVE_SOC_WIFI_SUPPORTED + bool + default y + + config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH + int + default 12 + + config SLAVE_SOC_WIFI_HW_TSF + bool + default y + + config SLAVE_SOC_WIFI_FTM_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_GCMP_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_WAPI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_CSI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_MESH_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_HE_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_MAC_VERSION_NUM + int + default 2 + +endif # ESP32C6 + +if SLAVE_IDF_TARGET_ESP32C5 + + config SLAVE_SOC_WIFI_SUPPORTED + bool + default y + + config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH + int + default 12 + + config SLAVE_SOC_WIFI_HW_TSF + bool + default y + + config SLAVE_SOC_WIFI_FTM_SUPPORT + bool + default n + + config SLAVE_SOC_WIFI_GCMP_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_WAPI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_CSI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_MESH_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_HE_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_SUPPORT_5G + bool + default y + + config SLAVE_SOC_WIFI_MAC_VERSION_NUM + int + default 3 + +endif # ESP32C5 + +if SLAVE_IDF_TARGET_ESP32C61 + + config SLAVE_SOC_WIFI_SUPPORTED + bool + default y + + config SLAVE_SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH + int + default 12 + + config SLAVE_SOC_WIFI_HW_TSF + bool + default y + + config SLAVE_SOC_WIFI_FTM_SUPPORT + bool + default n + + config SLAVE_SOC_WIFI_GCMP_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_WAPI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_CSI_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_MESH_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_HE_SUPPORT + bool + default y + + config SLAVE_SOC_WIFI_MAC_VERSION_NUM + int + default 3 + +endif # ESP32C61 diff --git a/components/esp_wifi_remote/idf_v5.5/Kconfig.wifi.in b/components/esp_wifi_remote/idf_v5.5/Kconfig.wifi.in new file mode 100644 index 0000000..d82c6aa --- /dev/null +++ b/components/esp_wifi_remote/idf_v5.5/Kconfig.wifi.in @@ -0,0 +1,726 @@ +# Wi-Fi configuration +# This file is auto-generated + + config ESP_WIFI_STATIC_RX_BUFFER_NUM + int "Max number of WiFi static RX buffers" + range 2 25 if !SLAVE_SOC_WIFI_HE_SUPPORT + range 2 128 if SLAVE_SOC_WIFI_HE_SUPPORT + default 10 if !SPIRAM_TRY_ALLOCATE_WIFI_LWIP + default 16 if SPIRAM_TRY_ALLOCATE_WIFI_LWIP + help + Set the number of WiFi static RX buffers. Each buffer takes approximately 1.6KB of RAM. + The static rx buffers are allocated when esp_wifi_init is called, they are not freed + until esp_wifi_deinit is called. + + WiFi hardware use these buffers to receive all 802.11 frames. + A higher number may allow higher throughput but increases memory use. If ESP_WIFI_AMPDU_RX_ENABLED + is enabled, this value is recommended to set equal or bigger than ESP_WIFI_RX_BA_WIN in order to + achieve better throughput and compatibility with both stations and APs. + + config ESP_WIFI_DYNAMIC_RX_BUFFER_NUM + int "Max number of WiFi dynamic RX buffers" + range 0 128 if !LWIP_WND_SCALE + range 0 1024 if LWIP_WND_SCALE + default 32 + help + Set the number of WiFi dynamic RX buffers, 0 means unlimited RX buffers will be allocated + (provided sufficient free RAM). The size of each dynamic RX buffer depends on the size of + the received data frame. + + For each received data frame, the WiFi driver makes a copy to an RX buffer and then delivers + it to the high layer TCP/IP stack. The dynamic RX buffer is freed after the higher layer has + successfully received the data frame. + + For some applications, WiFi data frames may be received faster than the application can + process them. In these cases we may run out of memory if RX buffer number is unlimited (0). + + If a dynamic RX buffer limit is set, it should be at least the number of static RX buffers. + + choice ESP_WIFI_TX_BUFFER + prompt "Type of WiFi TX buffers" + default ESP_WIFI_DYNAMIC_TX_BUFFER + help + Select type of WiFi TX buffers: + + If "Static" is selected, WiFi TX buffers are allocated when WiFi is initialized and released + when WiFi is de-initialized. The size of each static TX buffer is fixed to about 1.6KB. + + If "Dynamic" is selected, each WiFi TX buffer is allocated as needed when a data frame is + delivered to the Wifi driver from the TCP/IP stack. The buffer is freed after the data frame + has been sent by the WiFi driver. The size of each dynamic TX buffer depends on the length + of each data frame sent by the TCP/IP layer. + + If PSRAM is enabled, "Static" should be selected to guarantee enough WiFi TX buffers. + If PSRAM is disabled, "Dynamic" should be selected to improve the utilization of RAM. + + config ESP_WIFI_STATIC_TX_BUFFER + bool "Static" + config ESP_WIFI_DYNAMIC_TX_BUFFER + bool "Dynamic" + depends on !SPIRAM_USE_MALLOC + endchoice + + config ESP_WIFI_TX_BUFFER_TYPE + int + default 0 if ESP_WIFI_STATIC_TX_BUFFER + default 1 if ESP_WIFI_DYNAMIC_TX_BUFFER + + config ESP_WIFI_STATIC_TX_BUFFER_NUM + int "Max number of WiFi static TX buffers" + depends on ESP_WIFI_STATIC_TX_BUFFER + range 1 64 + default 16 + help + Set the number of WiFi static TX buffers. Each buffer takes approximately 1.6KB of RAM. + The static RX buffers are allocated when esp_wifi_init() is called, they are not released + until esp_wifi_deinit() is called. + + For each transmitted data frame from the higher layer TCP/IP stack, the WiFi driver makes a + copy of it in a TX buffer. For some applications especially UDP applications, the upper + layer can deliver frames faster than WiFi layer can transmit. In these cases, we may run out + of TX buffers. + + config ESP_WIFI_CACHE_TX_BUFFER_NUM + int "Max number of WiFi cache TX buffers" + depends on SPIRAM + range 16 128 + default 32 + help + Set the number of WiFi cache TX buffer number. + + For each TX packet from uplayer, such as LWIP etc, WiFi driver needs to allocate a static TX + buffer and makes a copy of uplayer packet. If WiFi driver fails to allocate the static TX buffer, + it caches the uplayer packets to a dedicated buffer queue, this option is used to configure the + size of the cached TX queue. + + config ESP_WIFI_DYNAMIC_TX_BUFFER_NUM + int "Max number of WiFi dynamic TX buffers" + depends on ESP_WIFI_DYNAMIC_TX_BUFFER + range 1 128 + default 32 + help + Set the number of WiFi dynamic TX buffers. The size of each dynamic TX buffer is not fixed, + it depends on the size of each transmitted data frame. + + For each transmitted frame from the higher layer TCP/IP stack, the WiFi driver makes a copy + of it in a TX buffer. For some applications, especially UDP applications, the upper layer + can deliver frames faster than WiFi layer can transmit. In these cases, we may run out of TX + buffers. + + choice ESP_WIFI_MGMT_RX_BUFFER + prompt "Type of WiFi RX MGMT buffers" + default ESP_WIFI_STATIC_RX_MGMT_BUFFER + help + Select type of WiFi RX MGMT buffers: + + If "Static" is selected, WiFi RX MGMT buffers are allocated when WiFi is initialized and released + when WiFi is de-initialized. The size of each static RX MGMT buffer is fixed to about 500 Bytes. + + If "Dynamic" is selected, each WiFi RX MGMT buffer is allocated as needed when a MGMT data frame is + received. The MGMT buffer is freed after the MGMT data frame has been processed by the WiFi driver. + + + config ESP_WIFI_STATIC_RX_MGMT_BUFFER + bool "Static" + config ESP_WIFI_DYNAMIC_RX_MGMT_BUFFER + bool "Dynamic" + endchoice + + config ESP_WIFI_DYNAMIC_RX_MGMT_BUF + int + default 0 if ESP_WIFI_STATIC_RX_MGMT_BUFFER + default 1 if ESP_WIFI_DYNAMIC_RX_MGMT_BUFFER + + config ESP_WIFI_RX_MGMT_BUF_NUM_DEF + int "Max number of WiFi RX MGMT buffers" + range 1 10 + default 5 + help + Set the number of WiFi RX_MGMT buffers. + + For Management buffers, the number of dynamic and static management buffers is the same. + In order to prevent memory fragmentation, the management buffer type should be set to static first. + + config ESP_WIFI_CSI_ENABLED + bool "WiFi CSI(Channel State Information)" + depends on SLAVE_SOC_WIFI_CSI_SUPPORT + default n + help + Select this option to enable CSI(Channel State Information) feature. CSI takes about + CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM KB of RAM. If CSI is not used, it is better to disable + this feature in order to save memory. + + config ESP_WIFI_AMPDU_TX_ENABLED + bool "WiFi AMPDU TX" + default y + help + Select this option to enable AMPDU TX feature + + + config ESP_WIFI_TX_BA_WIN + int "WiFi AMPDU TX BA window size" + depends on ESP_WIFI_AMPDU_TX_ENABLED + range 2 32 if !SLAVE_SOC_WIFI_HE_SUPPORT + range 2 64 if SLAVE_SOC_WIFI_HE_SUPPORT + default 6 + help + Set the size of WiFi Block Ack TX window. Generally a bigger value means higher throughput but + more memory. Most of time we should NOT change the default value unless special reason, e.g. + test the maximum UDP TX throughput with iperf etc. For iperf test in shieldbox, the recommended + value is 9~12. + + config ESP_WIFI_AMPDU_RX_ENABLED + bool "WiFi AMPDU RX" + default y + help + Select this option to enable AMPDU RX feature + + config ESP_WIFI_RX_BA_WIN + int "WiFi AMPDU RX BA window size" + depends on ESP_WIFI_AMPDU_RX_ENABLED + range 2 32 if !SLAVE_SOC_WIFI_HE_SUPPORT + range 2 64 if SLAVE_SOC_WIFI_HE_SUPPORT + default 6 if !SPIRAM_TRY_ALLOCATE_WIFI_LWIP + default 16 if SPIRAM_TRY_ALLOCATE_WIFI_LWIP + help + Set the size of WiFi Block Ack RX window. Generally a bigger value means higher throughput and better + compatibility but more memory. Most of time we should NOT change the default value unless special + reason, e.g. test the maximum UDP RX throughput with iperf etc. For iperf test in shieldbox, the + recommended value is 9~12. If PSRAM is used and WiFi memory is preferred to allocate in PSRAM first, + the default and minimum value should be 16 to achieve better throughput and compatibility with both + stations and APs. + + config ESP_WIFI_AMSDU_TX_ENABLED + bool "WiFi AMSDU TX" + depends on SPIRAM + default n + help + Select this option to enable AMSDU TX feature + + config ESP_WIFI_NVS_ENABLED + bool "WiFi NVS flash" + default y + help + Select this option to enable WiFi NVS flash + + choice ESP_WIFI_TASK_CORE_ID + depends on !FREERTOS_UNICORE + prompt "WiFi Task Core ID" + default ESP_WIFI_TASK_PINNED_TO_CORE_0 + help + Pinned WiFi task to core 0 or core 1. + + config ESP_WIFI_TASK_PINNED_TO_CORE_0 + bool "Core 0" + config ESP_WIFI_TASK_PINNED_TO_CORE_1 + bool "Core 1" + endchoice + + config ESP_WIFI_SOFTAP_BEACON_MAX_LEN + int "Max length of WiFi SoftAP Beacon" + range 752 1256 + default 752 + help + ESP-MESH utilizes beacon frames to detect and resolve root node conflicts (see documentation). However + the default length of a beacon frame can simultaneously hold only five root node identifier structures, + meaning that a root node conflict of up to five nodes can be detected at one time. In the occurrence of + more root nodes conflict involving more than five root nodes, the conflict resolution process will + detect five of the root nodes, resolve the conflict, and re-detect more root nodes. This process will + repeat until all root node conflicts are resolved. However this process can generally take a very long + time. + + To counter this situation, the beacon frame length can be increased such that more root nodes can be + detected simultaneously. Each additional root node will require 36 bytes and should be added on top of + the default beacon frame length of + 752 bytes. For example, if you want to detect 10 root nodes simultaneously, you need to set the beacon + frame length as + 932 (752+36*5). + + Setting a longer beacon length also assists with debugging as the conflicting root nodes can be + identified more quickly. + + config ESP_WIFI_MGMT_SBUF_NUM + int "WiFi mgmt short buffer number" + range 6 32 + default 32 + help + Set the maximum number of Wi-Fi management short buffers. These buffers are dynamically allocated, + with their size determined by the length of the management packet to be sent. When a management + packet is less than 64 bytes, the Wi-Fi driver classifies it as a short management packet and + assigns it to one of these buffers. + + config ESP_WIFI_IRAM_OPT + bool "WiFi IRAM speed optimization" + default n if (BT_ENABLED && SPIRAM && SLAVE_IDF_TARGET_ESP32) + default y + help + Select this option to place frequently called Wi-Fi library functions in IRAM. + When this option is disabled, more than 10Kbytes of IRAM memory will be saved + but Wi-Fi throughput will be reduced. + + config ESP_WIFI_EXTRA_IRAM_OPT + bool "WiFi EXTRA IRAM speed optimization" + default y if SLAVE_SOC_WIFI_HE_SUPPORT + default n + help + Select this option to place additional frequently called Wi-Fi library functions + in IRAM. When this option is disabled, more than 5Kbytes of IRAM memory will be saved + but Wi-Fi throughput will be reduced. + + config ESP_WIFI_RX_IRAM_OPT + bool "WiFi RX IRAM speed optimization" + default n if (BT_ENABLED && SPIRAM && SLAVE_IDF_TARGET_ESP32) + default y + help + Select this option to place frequently called Wi-Fi library RX functions in IRAM. + When this option is disabled, more than 17Kbytes of IRAM memory will be saved + but Wi-Fi performance will be reduced. + + config ESP_WIFI_ENABLE_WPA3_SAE + bool "Enable WPA3-Personal" + default y + select ESP_WIFI_MBEDTLS_CRYPTO + help + Select this option to allow the device to establish a WPA3-Personal connection with eligible AP's. + PMF (Protected Management Frames) is a prerequisite feature for a WPA3 connection, it needs to be + explicitly configured before attempting connection. Please refer to the Wi-Fi Driver API Guide + for details. + + config ESP_WIFI_ENABLE_SAE_PK + bool "Enable SAE-PK" + default y + depends on ESP_WIFI_ENABLE_WPA3_SAE + help + Select this option to enable SAE-PK + + config ESP_WIFI_SOFTAP_SAE_SUPPORT + bool "Enable WPA3 Personal(SAE) SoftAP" + default y + depends on ESP_WIFI_ENABLE_WPA3_SAE + depends on ESP_WIFI_SOFTAP_SUPPORT + help + Select this option to enable SAE support in softAP mode. + + config ESP_WIFI_ENABLE_WPA3_OWE_STA + bool "Enable OWE STA" + default y + select ESP_WIFI_MBEDTLS_CRYPTO + help + Select this option to allow the device to establish OWE connection with eligible AP's. + PMF (Protected Management Frames) is a prerequisite feature for a WPA3 connection, it needs to be + explicitly configured before attempting connection. Please refer to the Wi-Fi Driver API Guide + for details. + + config ESP_WIFI_SLP_IRAM_OPT + bool "WiFi SLP IRAM speed optimization" + select PM_SLP_DEFAULT_PARAMS_OPT + select PERIPH_CTRL_FUNC_IN_IRAM + default y if SLAVE_SOC_WIFI_HE_SUPPORT + help + Select this option to place called Wi-Fi library TBTT process and receive beacon functions in IRAM. + Some functions can be put in IRAM either by ESP_WIFI_IRAM_OPT and ESP_WIFI_RX_IRAM_OPT, or this one. + If already enabled ESP_WIFI_IRAM_OPT, the other 7.3KB IRAM memory would be taken by this option. + If already enabled ESP_WIFI_RX_IRAM_OPT, the other 1.3KB IRAM memory would be taken by this option. + If neither of them are enabled, the other 7.4KB IRAM memory would be taken by this option. + Wi-Fi power-save mode average current would be reduced if this option is enabled. + + config ESP_WIFI_SLP_DEFAULT_MIN_ACTIVE_TIME + int "Minimum active time" + range 8 60 + default 50 + help + Only for station in WIFI_PS_MIN_MODEM or WIFI_PS_MAX_MODEM. When the station enters the active state, + it will work for at least ESP_WIFI_SLP_DEFAULT_MIN_ACTIVE_TIME. If a data packet is received or sent + during this period, the time will be refreshed. If the time is up, but the station still has packets + to receive or send, the time will also be refreshed. unit: milliseconds. + + config ESP_WIFI_SLP_DEFAULT_MAX_ACTIVE_TIME + int "Maximum keep alive time" + range 10 60 + default 10 + help + Only for station in WIFI_PS_MIN_MODEM or WIFI_PS_MAX_MODEM. If no packet has been + sent within ESP_WIFI_SLP_DEFAULT_MAX_ACTIVE_TIME, a null data packet will be sent + to maintain the connection with the AP. unit: seconds. + + config ESP_WIFI_SLP_DEFAULT_WAIT_BROADCAST_DATA_TIME + int "Minimum wait broadcast data time" + range 10 30 + default 15 + help + Only for station in WIFI_PS_MIN_MODEM or WIFI_PS_MAX_MODEM. When the station knows through the beacon + that AP will send broadcast packet, it will wait for ESP_WIFI_SLP_DEFAULT_WAIT_BROADCAST_DATA_TIME + before entering the sleep process. If a broadcast packet is received with more data bits, the time + will refreshed. unit: milliseconds. + + config ESP_WIFI_FTM_ENABLE + bool "WiFi FTM" + default n + depends on SLAVE_SOC_WIFI_FTM_SUPPORT + help + Enable feature Fine Timing Measurement for calculating WiFi Round-Trip-Time (RTT). + + config ESP_WIFI_FTM_INITIATOR_SUPPORT + bool "FTM Initiator support" + default y + depends on ESP_WIFI_FTM_ENABLE + + config ESP_WIFI_FTM_RESPONDER_SUPPORT + bool "FTM Responder support" + default y + depends on ESP_WIFI_FTM_ENABLE + + config ESP_WIFI_STA_DISCONNECTED_PM_ENABLE + bool "Power Management for station at disconnected" + default y + help + Select this option to enable power_management for station when disconnected. + Chip will do modem-sleep when rf module is not in use any more. + + config ESP_WIFI_GCMP_SUPPORT + bool "WiFi GCMP Support(GCMP128 and GCMP256)" + default n + depends on SLAVE_SOC_WIFI_GCMP_SUPPORT + help + Select this option to enable GCMP support. GCMP support is compulsory for WiFi Suite-B support. + + config ESP_WIFI_GMAC_SUPPORT + bool "WiFi GMAC Support(GMAC128 and GMAC256)" + default y + help + Select this option to enable GMAC support. GMAC support is compulsory for WiFi 192 bit certification. + + config ESP_WIFI_SOFTAP_SUPPORT + bool "WiFi SoftAP Support" + default y + help + WiFi module can be compiled without SoftAP to save code size. + + config ESP_WIFI_ENHANCED_LIGHT_SLEEP + bool "WiFi modem automatically receives the beacon" + default n + depends on ESP_PHY_MAC_BB_PD && SOC_PM_SUPPORT_BEACON_WAKEUP + help + The wifi modem automatically receives the beacon frame during light sleep. + + config ESP_WIFI_SLP_BEACON_LOST_OPT + bool "Wifi sleep optimize when beacon lost" + help + Enable wifi sleep optimization when beacon loss occurs and immediately enter + sleep mode when the WiFi module detects beacon loss. + + config ESP_WIFI_SLP_BEACON_LOST_TIMEOUT + int "Beacon loss timeout" + range 5 100 + default 10 + depends on ESP_WIFI_SLP_BEACON_LOST_OPT + help + Timeout time for close rf phy when beacon loss occurs, Unit: 1024 microsecond. + + config ESP_WIFI_SLP_BEACON_LOST_THRESHOLD + int "Maximum number of consecutive lost beacons allowed" + range 0 8 + default 3 + depends on ESP_WIFI_SLP_BEACON_LOST_OPT + help + Maximum number of consecutive lost beacons allowed, WiFi keeps Rx state when + the number of consecutive beacons lost is greater than the given threshold. + + config ESP_WIFI_SLP_PHY_ON_DELTA_EARLY_TIME + int "Delta early time for RF PHY on" + range 0 100 + default 2 + depends on ESP_WIFI_SLP_BEACON_LOST_OPT && SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW + help + Delta early time for rf phy on, When the beacon is lost, the next rf phy on will + be earlier the time specified by the configuration item, Unit: 32 microsecond. + + config ESP_WIFI_SLP_PHY_OFF_DELTA_TIMEOUT_TIME + int "Delta timeout time for RF PHY off" + range 0 8 + default 2 + depends on ESP_WIFI_SLP_BEACON_LOST_OPT && SLAVE_SOC_WIFI_SUPPORT_VARIABLE_BEACON_WINDOW + help + Delta timeout time for rf phy off, When the beacon is lost, the next rf phy off will + be delayed for the time specified by the configuration item. Unit: 1024 microsecond. + + config ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM + int "Maximum espnow encrypt peers number" + range 0 4 if SLAVE_IDF_TARGET_ESP32C2 + range 0 17 if (!SLAVE_IDF_TARGET_ESP32C2) + default 2 if SLAVE_IDF_TARGET_ESP32C2 + default 7 if (!SLAVE_IDF_TARGET_ESP32C2) + help + Maximum number of encrypted peers supported by espnow. + The number of hardware keys for encryption is fixed. And the espnow and SoftAP share the same + hardware keys. So this configuration will affect the maximum connection number of SoftAP. + Maximum espnow encrypted peers number + maximum number of connections of SoftAP = Max hardware + keys number. When using ESP mesh, this value should be set to a maximum of 6. + + config ESP_WIFI_NAN_ENABLE + bool "WiFi Aware" + default n + depends on SLAVE_SOC_WIFI_NAN_SUPPORT + help + Enable WiFi Aware (NAN) feature. + + config ESP_WIFI_MBEDTLS_CRYPTO + bool "Use MbedTLS crypto APIs" + default y + select MBEDTLS_AES_C + select MBEDTLS_ECP_C + select MBEDTLS_ECDH_C + select MBEDTLS_ECDSA_C + select MBEDTLS_CMAC_C + select MBEDTLS_ECP_DP_SECP256R1_ENABLED + help + Select this option to enable the use of MbedTLS crypto APIs. + The internal crypto support within the supplicant is limited + and may not suffice for all new security features, including WPA3. + + It is recommended to always keep this option enabled. Additionally, + note that MbedTLS can leverage hardware acceleration if available, + resulting in significantly faster cryptographic operations. + + if ESP_WIFI_MBEDTLS_CRYPTO + config ESP_WIFI_MBEDTLS_TLS_CLIENT + bool "Use MbedTLS TLS client for WiFi Enterprise connection" + depends on ESP_WIFI_ENTERPRISE_SUPPORT + default y + select MBEDTLS_TLS_ENABLED + help + Select this option to use MbedTLS TLS client for WPA2 enterprise connection. + Please note that from MbedTLS-3.0 onwards, MbedTLS does not support SSL-3.0 + TLS-v1.0, TLS-v1.1 versions. In case your server is using one of these version, + it is advisable to update your server. + Please disable this option for compatibility with older TLS versions. + + config ESP_WIFI_EAP_TLS1_3 + bool "Enable EAP-TLS v1.3 Support for WiFi Enterprise connection" + default n + select MBEDTLS_SSL_PROTO_TLS1_3 + depends on ESP_WIFI_MBEDTLS_TLS_CLIENT && IDF_EXPERIMENTAL_FEATURES + help + Select this option to support EAP with TLS v1.3. + This configuration still supports compatibility with EAP-TLS v1.2. + Please note that enabling this configuration will cause every application which + uses TLS go for TLS1.3 if server supports that. TLS1.3 is still in development in mbedtls + and there may be interoperability issues with this. Please modify your application to set + max version as TLS1.2 if you want to enable TLS1.3 only for WiFi connection. + + endif + + config ESP_WIFI_WAPI_PSK + bool "Enable WAPI PSK support" + depends on SLAVE_SOC_WIFI_WAPI_SUPPORT + default n + help + Select this option to enable WAPI-PSK + which is a Chinese National Standard Encryption for Wireless LANs (GB 15629.11-2003). + + config ESP_WIFI_SUITE_B_192 + bool "Enable NSA suite B support with 192 bit key" + default n + depends on SLAVE_SOC_WIFI_GCMP_SUPPORT + select ESP_WIFI_GCMP_SUPPORT + select ESP_WIFI_GMAC_SUPPORT + help + Select this option to enable 192 bit NSA suite-B. + This is necessary to support WPA3 192 bit security. + + config ESP_WIFI_11KV_SUPPORT + bool "Enable 802.11k, 802.11v APIs Support" + default n + help + Select this option to enable 802.11k 802.11v APIs(RRM and BTM support). + Only APIs which are helpful for network assisted roaming + are supported for now. + Enable this option with BTM and RRM enabled in sta config + to make device ready for network assisted roaming. + BTM: BSS transition management enables an AP to request a station to transition + to a specific AP, or to indicate to a station a set of preferred APs. + RRM: Radio measurements enable STAs to understand the radio environment, + it enables STAs to observe and gather data on radio link performance + and on the radio environment. Current implementation adds beacon report, + link measurement, neighbor report. + + config ESP_WIFI_SCAN_CACHE + bool "Keep scan results in cache" + depends on ESP_WIFI_11KV_SUPPORT + default n + help + Keep scan results in cache, if not enabled, those + will be flushed immediately. + + config ESP_WIFI_MBO_SUPPORT + bool "Enable Multi Band Operation Certification Support" + default n + select ESP_WIFI_11KV_SUPPORT + select ESP_WIFI_SCAN_CACHE + help + Select this option to enable WiFi Multiband operation certification support. + + config ESP_WIFI_ENABLE_ROAMING_APP + bool "Advanced support for Wi-Fi Roaming (Experimental)" + depends on IDF_EXPERIMENTAL_FEATURES + default n + select ESP_WIFI_SCAN_CACHE + help + Enable Espressif's roaming app to allow for efficient Wi-Fi roaming. + This includes configurable periodic environment scans, maintaining a cache of the + best APs, handling low rssi events etc. + + Risk Warning + Please note that this feature is still experimental and enabling this potentially can + lead to unpredictable scanning, connection and roaming attempts. + We are still working on tuning and optimising this feature to ensure reliable and stable use. + + menu "Configure roaming App" + depends on ESP_WIFI_ENABLE_ROAMING_APP + rsource "wifi_apps/roaming_app/src/Kconfig.roaming" + endmenu + + config ESP_WIFI_DPP_SUPPORT + bool "Enable DPP support" + default n + select ESP_WIFI_MBEDTLS_CRYPTO + help + Select this option to enable WiFi Easy Connect Support. + + config ESP_WIFI_11R_SUPPORT + bool "Enable 802.11R (Fast Transition) Support" + default n + help + Select this option to enable WiFi Fast Transition Support. + + config ESP_WIFI_WPS_SOFTAP_REGISTRAR + bool "Add WPS Registrar support in SoftAP mode" + depends on ESP_WIFI_SOFTAP_SUPPORT + default n + help + Select this option to enable WPS registrar support in softAP mode. + + config ESP_WIFI_ENABLE_WIFI_TX_STATS + bool "Enable Wi-Fi transmission statistics" + depends on SLAVE_SOC_WIFI_HE_SUPPORT + default n + help + Enable Wi-Fi transmission statistics. Total support 4 access category. Each access category + will use 346 bytes memory. + + config ESP_WIFI_ENABLE_WIFI_RX_STATS + bool "Enable Wi-Fi reception statistics" + depends on SLAVE_SOC_WIFI_HE_SUPPORT + default n + help + Enable Wi-Fi reception statistics. Total support 2 access category. Each access category + will use 190 bytes memory. + + config ESP_WIFI_ENABLE_WIFI_RX_MU_STATS + bool "Enable Wi-Fi DL MU-MIMO and DL OFDMA reception statistics" + depends on ESP_WIFI_ENABLE_WIFI_RX_STATS + default n + help + Enable Wi-Fi DL MU-MIMO and DL OFDMA reception statistics. Will use 10932 bytes memory. + + config ESP_WIFI_TX_HETB_QUEUE_NUM + int "WiFi TX HE TB QUEUE number for STA HE TB PPDU transmission" + depends on SLAVE_SOC_WIFI_HE_SUPPORT + range 1 4 + default 3 + help + Set the maximum number of queue that can be aggregated by the STA in the A-MPDU carried in the + HE TB PPDU. + + config ESP_WIFI_ENABLE_DUMP_HESIGB + bool "Enable Wi-Fi dump HE-SIGB which is contained in DL HE MU PPDUs" + depends on SLAVE_SOC_WIFI_SUPPORT_5G + default "n" + help + Enable Wi-Fi dump HE-SIGB which is contained in DL HE MU PPDUs. + + config ESP_WIFI_ENABLE_DUMP_MU_CFO + bool "Enable Wi-Fi dump MU CFO" + depends on SLAVE_SOC_WIFI_SUPPORT_5G + default "n" + help + Enable Wi-Fi dump MU CFO. + + config ESP_WIFI_ENABLE_DUMP_CTRL_NDPA + bool "Enable Wi-Fi dump NDPA frames" + depends on SLAVE_SOC_WIFI_SUPPORT_5G + default "n" + help + Enable Wi-Fi dump NDPA frames. + + config ESP_WIFI_ENABLE_DUMP_CTRL_BFRP + bool "Enable Wi-Fi dump BFRP frames" + depends on SLAVE_SOC_WIFI_SUPPORT_5G + default "n" + help + Enable Wi-Fi dump BFRP frames. + + menu "WPS Configuration Options" + config ESP_WIFI_WPS_STRICT + bool "Strictly validate all WPS attributes" + default n + help + Select this option to enable validate each WPS attribute + rigorously. Disabling this add the workarounds with various APs. + Enabling this may cause inter operability issues with some APs. + + config ESP_WIFI_WPS_PASSPHRASE + bool "Get WPA2 passphrase in WPS config" + default n + help + Select this option to get passphrase during WPS configuration. + This option fakes the virtual display capabilities to get the + configuration in passphrase mode. + Not recommended to be used since WPS credentials should not + be shared to other devices, making it in readable format increases + that risk, also passphrase requires pbkdf2 to convert in psk. + + endmenu # "WPS Configuration Options" + + + config ESP_WIFI_DEBUG_PRINT + bool "Print debug messages from WPA Supplicant" + default n + help + Select this option to print logging information from WPA supplicant, + this includes handshake information and key hex dumps depending + on the project logging level. + + Enabling this could increase the build size ~60kb + depending on the project logging level. + + config ESP_WIFI_TESTING_OPTIONS + bool "Add DPP testing code" + default n + help + Select this to enable unity test for DPP. + + config ESP_WIFI_ENTERPRISE_SUPPORT + bool "Enable enterprise option" + default y + help + Select this to enable/disable enterprise connection support. + + disabling this will reduce binary size. + disabling this will disable the use of any esp_wifi_sta_wpa2_ent_* (as APIs will be meaningless) + + Note that when using bigger certificates on low-power chips without crypto + hardware acceleration, it is recommended to adjust the task watchdog timer (TWDT) + if it is enabled. For precise information on timing requirements, you can check + performance numbers at https://github.com/espressif/mbedtls/wiki/Performance-Numbers. + + config ESP_WIFI_ENT_FREE_DYNAMIC_BUFFER + bool "Free dynamic buffers during WiFi enterprise connection" + depends on ESP_WIFI_ENTERPRISE_SUPPORT + default y if SLAVE_IDF_TARGET_ESP32C2 + default n if !SLAVE_IDF_TARGET_ESP32C2 + help + Select this configuration to free dynamic buffers during WiFi enterprise connection. + This will enable chip to reduce heap consumption during WiFi enterprise connection. + +# Wi-Fi configuration end diff --git a/components/esp_wifi_remote/idf_v5.5/esp_wifi_remote_weak.c b/components/esp_wifi_remote/idf_v5.5/esp_wifi_remote_weak.c new file mode 100644 index 0000000..96979df --- /dev/null +++ b/components/esp_wifi_remote/idf_v5.5/esp_wifi_remote_weak.c @@ -0,0 +1,432 @@ +/* + * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +// This file is auto-generated +#include "esp_wifi_remote.h" +#include "esp_log.h" + +#define WEAK __attribute__((weak)) +#define LOG_UNSUPPORTED_AND_RETURN(ret) ESP_LOGW("esp_wifi_remote_weak", "%s unsupported", __func__); \ + return ret; + +WEAK esp_err_t esp_wifi_remote_init(const wifi_init_config_t *config) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_deinit(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_mode(wifi_mode_t mode) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_mode(wifi_mode_t *mode) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_start(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_stop(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_restore(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_connect(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_disconnect(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_clear_fast_connect(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_deauth_sta(uint16_t aid) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_scan_start(const wifi_scan_config_t *config, _Bool block) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_scan_parameters(const wifi_scan_default_params_t *config) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_scan_parameters(wifi_scan_default_params_t *config) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_scan_stop(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_scan_get_ap_num(uint16_t *number) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_scan_get_ap_record(wifi_ap_record_t *ap_record) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_clear_ap_list(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_sta_get_ap_info(wifi_ap_record_t *ap_info) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_ps(wifi_ps_type_t type) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_ps(wifi_ps_type_t *type) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_channel(uint8_t primary, wifi_second_chan_t second) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_channel(uint8_t *primary, wifi_second_chan_t *second) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_country(const wifi_country_t *country) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_country(wifi_country_t *country) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_mac(wifi_interface_t ifx, const uint8_t mac[6]) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_mac(wifi_interface_t ifx, uint8_t mac[6]) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_promiscuous(_Bool en) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_promiscuous(_Bool *en) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_promiscuous_filter(const wifi_promiscuous_filter_t *filter) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_promiscuous_filter(wifi_promiscuous_filter_t *filter) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_promiscuous_ctrl_filter(const wifi_promiscuous_filter_t *filter) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_promiscuous_ctrl_filter(wifi_promiscuous_filter_t *filter) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_config(wifi_interface_t interface, wifi_config_t *conf) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_config(wifi_interface_t interface, wifi_config_t *conf) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_ap_get_sta_list(wifi_sta_list_t *sta) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_ap_get_sta_aid(const uint8_t mac[6], uint16_t *aid) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_storage(wifi_storage_t storage) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_vendor_ie(_Bool enable, wifi_vendor_ie_type_t type, wifi_vendor_ie_id_t idx, const void *vnd_ie) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_vendor_ie_cb(esp_vendor_ie_cb_t cb, void *ctx) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_max_tx_power(int8_t power) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_max_tx_power(int8_t *power) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_event_mask(uint32_t mask) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_event_mask(uint32_t *mask) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_80211_tx(wifi_interface_t ifx, const void *buffer, int len, _Bool en_sys_seq) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_csi_rx_cb(wifi_csi_cb_t cb, void *ctx) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_csi_config(const wifi_csi_config_t *config) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_csi_config(wifi_csi_config_t *config) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_csi(_Bool en) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK int64_t esp_wifi_remote_get_tsf_time(wifi_interface_t interface) +{ + LOG_UNSUPPORTED_AND_RETURN(-1); +} + +WEAK esp_err_t esp_wifi_remote_set_inactive_time(wifi_interface_t ifx, uint16_t sec) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_inactive_time(wifi_interface_t ifx, uint16_t *sec) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_statis_dump(uint32_t modules) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_rssi_threshold(int32_t rssi) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_ftm_initiate_session(wifi_ftm_initiator_cfg_t *cfg) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_ftm_end_session(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_ftm_resp_set_offset(int16_t offset_cm) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_ftm_get_report(wifi_ftm_report_entry_t *report, uint8_t num_entries) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_config_11b_rate(wifi_interface_t ifx, _Bool disable) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_connectionless_module_set_wake_interval(uint16_t wake_interval) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_force_wakeup_acquire(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_force_wakeup_release(void) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_country_code(const char *country, _Bool ieee80211d_enabled) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_country_code(char *country) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_config_80211_tx_rate(wifi_interface_t ifx, wifi_phy_rate_t rate) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_disable_pmf_config(wifi_interface_t ifx) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_sta_get_aid(uint16_t *aid) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_dynamic_cs(_Bool enabled) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_sta_get_rssi(int *rssi) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_band(wifi_band_t band) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_band(wifi_band_t *band) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_band_mode(wifi_band_mode_t band_mode) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_band_mode(wifi_band_mode_t *band_mode) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_set_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} + +WEAK esp_err_t esp_wifi_remote_get_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw) +{ + LOG_UNSUPPORTED_AND_RETURN(ESP_ERR_NOT_SUPPORTED); +} diff --git a/components/esp_wifi_remote/idf_v5.5/esp_wifi_with_remote.c b/components/esp_wifi_remote/idf_v5.5/esp_wifi_with_remote.c new file mode 100644 index 0000000..ad97643 --- /dev/null +++ b/components/esp_wifi_remote/idf_v5.5/esp_wifi_with_remote.c @@ -0,0 +1,428 @@ +/* + * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +// This file is auto-generated +#include "esp_wifi.h" +#include "esp_wifi_remote.h" + +esp_err_t esp_wifi_init(const wifi_init_config_t *config) +{ + return esp_wifi_remote_init(config); +} + +esp_err_t esp_wifi_deinit(void) +{ + return esp_wifi_remote_deinit(); +} + +esp_err_t esp_wifi_set_mode(wifi_mode_t mode) +{ + return esp_wifi_remote_set_mode(mode); +} + +esp_err_t esp_wifi_get_mode(wifi_mode_t *mode) +{ + return esp_wifi_remote_get_mode(mode); +} + +esp_err_t esp_wifi_start(void) +{ + return esp_wifi_remote_start(); +} + +esp_err_t esp_wifi_stop(void) +{ + return esp_wifi_remote_stop(); +} + +esp_err_t esp_wifi_restore(void) +{ + return esp_wifi_remote_restore(); +} + +esp_err_t esp_wifi_connect(void) +{ + return esp_wifi_remote_connect(); +} + +esp_err_t esp_wifi_disconnect(void) +{ + return esp_wifi_remote_disconnect(); +} + +esp_err_t esp_wifi_clear_fast_connect(void) +{ + return esp_wifi_remote_clear_fast_connect(); +} + +esp_err_t esp_wifi_deauth_sta(uint16_t aid) +{ + return esp_wifi_remote_deauth_sta(aid); +} + +esp_err_t esp_wifi_scan_start(const wifi_scan_config_t *config, _Bool block) +{ + return esp_wifi_remote_scan_start(config, block); +} + +esp_err_t esp_wifi_set_scan_parameters(const wifi_scan_default_params_t *config) +{ + return esp_wifi_remote_set_scan_parameters(config); +} + +esp_err_t esp_wifi_get_scan_parameters(wifi_scan_default_params_t *config) +{ + return esp_wifi_remote_get_scan_parameters(config); +} + +esp_err_t esp_wifi_scan_stop(void) +{ + return esp_wifi_remote_scan_stop(); +} + +esp_err_t esp_wifi_scan_get_ap_num(uint16_t *number) +{ + return esp_wifi_remote_scan_get_ap_num(number); +} + +esp_err_t esp_wifi_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records) +{ + return esp_wifi_remote_scan_get_ap_records(number, ap_records); +} + +esp_err_t esp_wifi_scan_get_ap_record(wifi_ap_record_t *ap_record) +{ + return esp_wifi_remote_scan_get_ap_record(ap_record); +} + +esp_err_t esp_wifi_clear_ap_list(void) +{ + return esp_wifi_remote_clear_ap_list(); +} + +esp_err_t esp_wifi_sta_get_ap_info(wifi_ap_record_t *ap_info) +{ + return esp_wifi_remote_sta_get_ap_info(ap_info); +} + +esp_err_t esp_wifi_set_ps(wifi_ps_type_t type) +{ + return esp_wifi_remote_set_ps(type); +} + +esp_err_t esp_wifi_get_ps(wifi_ps_type_t *type) +{ + return esp_wifi_remote_get_ps(type); +} + +esp_err_t esp_wifi_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap) +{ + return esp_wifi_remote_set_protocol(ifx, protocol_bitmap); +} + +esp_err_t esp_wifi_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap) +{ + return esp_wifi_remote_get_protocol(ifx, protocol_bitmap); +} + +esp_err_t esp_wifi_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw) +{ + return esp_wifi_remote_set_bandwidth(ifx, bw); +} + +esp_err_t esp_wifi_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw) +{ + return esp_wifi_remote_get_bandwidth(ifx, bw); +} + +esp_err_t esp_wifi_set_channel(uint8_t primary, wifi_second_chan_t second) +{ + return esp_wifi_remote_set_channel(primary, second); +} + +esp_err_t esp_wifi_get_channel(uint8_t *primary, wifi_second_chan_t *second) +{ + return esp_wifi_remote_get_channel(primary, second); +} + +esp_err_t esp_wifi_set_country(const wifi_country_t *country) +{ + return esp_wifi_remote_set_country(country); +} + +esp_err_t esp_wifi_get_country(wifi_country_t *country) +{ + return esp_wifi_remote_get_country(country); +} + +esp_err_t esp_wifi_set_mac(wifi_interface_t ifx, const uint8_t mac[6]) +{ + return esp_wifi_remote_set_mac(ifx, mac); +} + +esp_err_t esp_wifi_get_mac(wifi_interface_t ifx, uint8_t mac[6]) +{ + return esp_wifi_remote_get_mac(ifx, mac); +} + +esp_err_t esp_wifi_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb) +{ + return esp_wifi_remote_set_promiscuous_rx_cb(cb); +} + +esp_err_t esp_wifi_set_promiscuous(_Bool en) +{ + return esp_wifi_remote_set_promiscuous(en); +} + +esp_err_t esp_wifi_get_promiscuous(_Bool *en) +{ + return esp_wifi_remote_get_promiscuous(en); +} + +esp_err_t esp_wifi_set_promiscuous_filter(const wifi_promiscuous_filter_t *filter) +{ + return esp_wifi_remote_set_promiscuous_filter(filter); +} + +esp_err_t esp_wifi_get_promiscuous_filter(wifi_promiscuous_filter_t *filter) +{ + return esp_wifi_remote_get_promiscuous_filter(filter); +} + +esp_err_t esp_wifi_set_promiscuous_ctrl_filter(const wifi_promiscuous_filter_t *filter) +{ + return esp_wifi_remote_set_promiscuous_ctrl_filter(filter); +} + +esp_err_t esp_wifi_get_promiscuous_ctrl_filter(wifi_promiscuous_filter_t *filter) +{ + return esp_wifi_remote_get_promiscuous_ctrl_filter(filter); +} + +esp_err_t esp_wifi_set_config(wifi_interface_t interface, wifi_config_t *conf) +{ + return esp_wifi_remote_set_config(interface, conf); +} + +esp_err_t esp_wifi_get_config(wifi_interface_t interface, wifi_config_t *conf) +{ + return esp_wifi_remote_get_config(interface, conf); +} + +esp_err_t esp_wifi_ap_get_sta_list(wifi_sta_list_t *sta) +{ + return esp_wifi_remote_ap_get_sta_list(sta); +} + +esp_err_t esp_wifi_ap_get_sta_aid(const uint8_t mac[6], uint16_t *aid) +{ + return esp_wifi_remote_ap_get_sta_aid(mac, aid); +} + +esp_err_t esp_wifi_set_storage(wifi_storage_t storage) +{ + return esp_wifi_remote_set_storage(storage); +} + +esp_err_t esp_wifi_set_vendor_ie(_Bool enable, wifi_vendor_ie_type_t type, wifi_vendor_ie_id_t idx, const void *vnd_ie) +{ + return esp_wifi_remote_set_vendor_ie(enable, type, idx, vnd_ie); +} + +esp_err_t esp_wifi_set_vendor_ie_cb(esp_vendor_ie_cb_t cb, void *ctx) +{ + return esp_wifi_remote_set_vendor_ie_cb(cb, ctx); +} + +esp_err_t esp_wifi_set_max_tx_power(int8_t power) +{ + return esp_wifi_remote_set_max_tx_power(power); +} + +esp_err_t esp_wifi_get_max_tx_power(int8_t *power) +{ + return esp_wifi_remote_get_max_tx_power(power); +} + +esp_err_t esp_wifi_set_event_mask(uint32_t mask) +{ + return esp_wifi_remote_set_event_mask(mask); +} + +esp_err_t esp_wifi_get_event_mask(uint32_t *mask) +{ + return esp_wifi_remote_get_event_mask(mask); +} + +esp_err_t esp_wifi_80211_tx(wifi_interface_t ifx, const void *buffer, int len, _Bool en_sys_seq) +{ + return esp_wifi_remote_80211_tx(ifx, buffer, len, en_sys_seq); +} + +esp_err_t esp_wifi_set_csi_rx_cb(wifi_csi_cb_t cb, void *ctx) +{ + return esp_wifi_remote_set_csi_rx_cb(cb, ctx); +} + +esp_err_t esp_wifi_set_csi_config(const wifi_csi_config_t *config) +{ + return esp_wifi_remote_set_csi_config(config); +} + +esp_err_t esp_wifi_get_csi_config(wifi_csi_config_t *config) +{ + return esp_wifi_remote_get_csi_config(config); +} + +esp_err_t esp_wifi_set_csi(_Bool en) +{ + return esp_wifi_remote_set_csi(en); +} + +int64_t esp_wifi_get_tsf_time(wifi_interface_t interface) +{ + return esp_wifi_remote_get_tsf_time(interface); +} + +esp_err_t esp_wifi_set_inactive_time(wifi_interface_t ifx, uint16_t sec) +{ + return esp_wifi_remote_set_inactive_time(ifx, sec); +} + +esp_err_t esp_wifi_get_inactive_time(wifi_interface_t ifx, uint16_t *sec) +{ + return esp_wifi_remote_get_inactive_time(ifx, sec); +} + +esp_err_t esp_wifi_statis_dump(uint32_t modules) +{ + return esp_wifi_remote_statis_dump(modules); +} + +esp_err_t esp_wifi_set_rssi_threshold(int32_t rssi) +{ + return esp_wifi_remote_set_rssi_threshold(rssi); +} + +esp_err_t esp_wifi_ftm_initiate_session(wifi_ftm_initiator_cfg_t *cfg) +{ + return esp_wifi_remote_ftm_initiate_session(cfg); +} + +esp_err_t esp_wifi_ftm_end_session(void) +{ + return esp_wifi_remote_ftm_end_session(); +} + +esp_err_t esp_wifi_ftm_resp_set_offset(int16_t offset_cm) +{ + return esp_wifi_remote_ftm_resp_set_offset(offset_cm); +} + +esp_err_t esp_wifi_ftm_get_report(wifi_ftm_report_entry_t *report, uint8_t num_entries) +{ + return esp_wifi_remote_ftm_get_report(report, num_entries); +} + +esp_err_t esp_wifi_config_11b_rate(wifi_interface_t ifx, _Bool disable) +{ + return esp_wifi_remote_config_11b_rate(ifx, disable); +} + +esp_err_t esp_wifi_connectionless_module_set_wake_interval(uint16_t wake_interval) +{ + return esp_wifi_remote_connectionless_module_set_wake_interval(wake_interval); +} + +esp_err_t esp_wifi_force_wakeup_acquire(void) +{ + return esp_wifi_remote_force_wakeup_acquire(); +} + +esp_err_t esp_wifi_force_wakeup_release(void) +{ + return esp_wifi_remote_force_wakeup_release(); +} + +esp_err_t esp_wifi_set_country_code(const char *country, _Bool ieee80211d_enabled) +{ + return esp_wifi_remote_set_country_code(country, ieee80211d_enabled); +} + +esp_err_t esp_wifi_get_country_code(char *country) +{ + return esp_wifi_remote_get_country_code(country); +} + +esp_err_t esp_wifi_config_80211_tx_rate(wifi_interface_t ifx, wifi_phy_rate_t rate) +{ + return esp_wifi_remote_config_80211_tx_rate(ifx, rate); +} + +esp_err_t esp_wifi_disable_pmf_config(wifi_interface_t ifx) +{ + return esp_wifi_remote_disable_pmf_config(ifx); +} + +esp_err_t esp_wifi_sta_get_aid(uint16_t *aid) +{ + return esp_wifi_remote_sta_get_aid(aid); +} + +esp_err_t esp_wifi_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode) +{ + return esp_wifi_remote_sta_get_negotiated_phymode(phymode); +} + +esp_err_t esp_wifi_set_dynamic_cs(_Bool enabled) +{ + return esp_wifi_remote_set_dynamic_cs(enabled); +} + +esp_err_t esp_wifi_sta_get_rssi(int *rssi) +{ + return esp_wifi_remote_sta_get_rssi(rssi); +} + +esp_err_t esp_wifi_set_band(wifi_band_t band) +{ + return esp_wifi_remote_set_band(band); +} + +esp_err_t esp_wifi_get_band(wifi_band_t *band) +{ + return esp_wifi_remote_get_band(band); +} + +esp_err_t esp_wifi_set_band_mode(wifi_band_mode_t band_mode) +{ + return esp_wifi_remote_set_band_mode(band_mode); +} + +esp_err_t esp_wifi_get_band_mode(wifi_band_mode_t *band_mode) +{ + return esp_wifi_remote_get_band_mode(band_mode); +} + +esp_err_t esp_wifi_set_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols) +{ + return esp_wifi_remote_set_protocols(ifx, protocols); +} + +esp_err_t esp_wifi_get_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols) +{ + return esp_wifi_remote_get_protocols(ifx, protocols); +} + +esp_err_t esp_wifi_set_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw) +{ + return esp_wifi_remote_set_bandwidths(ifx, bw); +} + +esp_err_t esp_wifi_get_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw) +{ + return esp_wifi_remote_get_bandwidths(ifx, bw); +} diff --git a/components/esp_wifi_remote/idf_v5.5/include/esp_wifi_remote_api.h b/components/esp_wifi_remote/idf_v5.5/include/esp_wifi_remote_api.h new file mode 100644 index 0000000..9704c15 --- /dev/null +++ b/components/esp_wifi_remote/idf_v5.5/include/esp_wifi_remote_api.h @@ -0,0 +1,91 @@ +/* + * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +// This file is auto-generated +#pragma once +esp_err_t esp_wifi_remote_init(const wifi_init_config_t *config); +esp_err_t esp_wifi_remote_deinit(void); +esp_err_t esp_wifi_remote_set_mode(wifi_mode_t mode); +esp_err_t esp_wifi_remote_get_mode(wifi_mode_t *mode); +esp_err_t esp_wifi_remote_start(void); +esp_err_t esp_wifi_remote_stop(void); +esp_err_t esp_wifi_remote_restore(void); +esp_err_t esp_wifi_remote_connect(void); +esp_err_t esp_wifi_remote_disconnect(void); +esp_err_t esp_wifi_remote_clear_fast_connect(void); +esp_err_t esp_wifi_remote_deauth_sta(uint16_t aid); +esp_err_t esp_wifi_remote_scan_start(const wifi_scan_config_t *config, _Bool block); +esp_err_t esp_wifi_remote_set_scan_parameters(const wifi_scan_default_params_t *config); +esp_err_t esp_wifi_remote_get_scan_parameters(wifi_scan_default_params_t *config); +esp_err_t esp_wifi_remote_scan_stop(void); +esp_err_t esp_wifi_remote_scan_get_ap_num(uint16_t *number); +esp_err_t esp_wifi_remote_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records); +esp_err_t esp_wifi_remote_scan_get_ap_record(wifi_ap_record_t *ap_record); +esp_err_t esp_wifi_remote_clear_ap_list(void); +esp_err_t esp_wifi_remote_sta_get_ap_info(wifi_ap_record_t *ap_info); +esp_err_t esp_wifi_remote_set_ps(wifi_ps_type_t type); +esp_err_t esp_wifi_remote_get_ps(wifi_ps_type_t *type); +esp_err_t esp_wifi_remote_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap); +esp_err_t esp_wifi_remote_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap); +esp_err_t esp_wifi_remote_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw); +esp_err_t esp_wifi_remote_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw); +esp_err_t esp_wifi_remote_set_channel(uint8_t primary, wifi_second_chan_t second); +esp_err_t esp_wifi_remote_get_channel(uint8_t *primary, wifi_second_chan_t *second); +esp_err_t esp_wifi_remote_set_country(const wifi_country_t *country); +esp_err_t esp_wifi_remote_get_country(wifi_country_t *country); +esp_err_t esp_wifi_remote_set_mac(wifi_interface_t ifx, const uint8_t mac[6]); +esp_err_t esp_wifi_remote_get_mac(wifi_interface_t ifx, uint8_t mac[6]); +esp_err_t esp_wifi_remote_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb); +esp_err_t esp_wifi_remote_set_promiscuous(_Bool en); +esp_err_t esp_wifi_remote_get_promiscuous(_Bool *en); +esp_err_t esp_wifi_remote_set_promiscuous_filter(const wifi_promiscuous_filter_t *filter); +esp_err_t esp_wifi_remote_get_promiscuous_filter(wifi_promiscuous_filter_t *filter); +esp_err_t esp_wifi_remote_set_promiscuous_ctrl_filter(const wifi_promiscuous_filter_t *filter); +esp_err_t esp_wifi_remote_get_promiscuous_ctrl_filter(wifi_promiscuous_filter_t *filter); +esp_err_t esp_wifi_remote_set_config(wifi_interface_t interface, wifi_config_t *conf); +esp_err_t esp_wifi_remote_get_config(wifi_interface_t interface, wifi_config_t *conf); +esp_err_t esp_wifi_remote_ap_get_sta_list(wifi_sta_list_t *sta); +esp_err_t esp_wifi_remote_ap_get_sta_aid(const uint8_t mac[6], uint16_t *aid); +esp_err_t esp_wifi_remote_set_storage(wifi_storage_t storage); +esp_err_t esp_wifi_remote_set_vendor_ie(_Bool enable, wifi_vendor_ie_type_t type, wifi_vendor_ie_id_t idx, const void *vnd_ie); +esp_err_t esp_wifi_remote_set_vendor_ie_cb(esp_vendor_ie_cb_t cb, void *ctx); +esp_err_t esp_wifi_remote_set_max_tx_power(int8_t power); +esp_err_t esp_wifi_remote_get_max_tx_power(int8_t *power); +esp_err_t esp_wifi_remote_set_event_mask(uint32_t mask); +esp_err_t esp_wifi_remote_get_event_mask(uint32_t *mask); +esp_err_t esp_wifi_remote_80211_tx(wifi_interface_t ifx, const void *buffer, int len, _Bool en_sys_seq); +esp_err_t esp_wifi_remote_set_csi_rx_cb(wifi_csi_cb_t cb, void *ctx); +esp_err_t esp_wifi_remote_set_csi_config(const wifi_csi_config_t *config); +esp_err_t esp_wifi_remote_get_csi_config(wifi_csi_config_t *config); +esp_err_t esp_wifi_remote_set_csi(_Bool en); +int64_t esp_wifi_remote_get_tsf_time(wifi_interface_t interface); +esp_err_t esp_wifi_remote_set_inactive_time(wifi_interface_t ifx, uint16_t sec); +esp_err_t esp_wifi_remote_get_inactive_time(wifi_interface_t ifx, uint16_t *sec); +esp_err_t esp_wifi_remote_statis_dump(uint32_t modules); +esp_err_t esp_wifi_remote_set_rssi_threshold(int32_t rssi); +esp_err_t esp_wifi_remote_ftm_initiate_session(wifi_ftm_initiator_cfg_t *cfg); +esp_err_t esp_wifi_remote_ftm_end_session(void); +esp_err_t esp_wifi_remote_ftm_resp_set_offset(int16_t offset_cm); +esp_err_t esp_wifi_remote_ftm_get_report(wifi_ftm_report_entry_t *report, uint8_t num_entries); +esp_err_t esp_wifi_remote_config_11b_rate(wifi_interface_t ifx, _Bool disable); +esp_err_t esp_wifi_remote_connectionless_module_set_wake_interval(uint16_t wake_interval); +esp_err_t esp_wifi_remote_force_wakeup_acquire(void); +esp_err_t esp_wifi_remote_force_wakeup_release(void); +esp_err_t esp_wifi_remote_set_country_code(const char *country, _Bool ieee80211d_enabled); +esp_err_t esp_wifi_remote_get_country_code(char *country); +esp_err_t esp_wifi_remote_config_80211_tx_rate(wifi_interface_t ifx, wifi_phy_rate_t rate); +esp_err_t esp_wifi_remote_disable_pmf_config(wifi_interface_t ifx); +esp_err_t esp_wifi_remote_sta_get_aid(uint16_t *aid); +esp_err_t esp_wifi_remote_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode); +esp_err_t esp_wifi_remote_set_dynamic_cs(_Bool enabled); +esp_err_t esp_wifi_remote_sta_get_rssi(int *rssi); +esp_err_t esp_wifi_remote_set_band(wifi_band_t band); +esp_err_t esp_wifi_remote_get_band(wifi_band_t *band); +esp_err_t esp_wifi_remote_set_band_mode(wifi_band_mode_t band_mode); +esp_err_t esp_wifi_remote_get_band_mode(wifi_band_mode_t *band_mode); +esp_err_t esp_wifi_remote_set_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols); +esp_err_t esp_wifi_remote_get_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols); +esp_err_t esp_wifi_remote_set_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw); +esp_err_t esp_wifi_remote_get_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw); diff --git a/components/esp_wifi_remote/idf_v5.5/include/esp_wifi_types_native.h b/components/esp_wifi_remote/idf_v5.5/include/esp_wifi_types_native.h new file mode 100644 index 0000000..0963572 --- /dev/null +++ b/components/esp_wifi_remote/idf_v5.5/include/esp_wifi_types_native.h @@ -0,0 +1,134 @@ +/* + * SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once + +#include "sdkconfig.h" +#include "esp_wifi_types_generic.h" +#if CONFIG_SLAVE_SOC_WIFI_HE_SUPPORT +#include "esp_wifi_he_types.h" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#if CONFIG_SLAVE_IDF_TARGET_ESP32C2 +#define ESP_WIFI_MAX_CONN_NUM (4) /**< max number of stations which can connect to ESP32C2 soft-AP */ +#elif CONFIG_SLAVE_IDF_TARGET_ESP32C3 || CONFIG_SLAVE_IDF_TARGET_ESP32C6 || CONFIG_SLAVE_IDF_TARGET_ESP32C5 || CONFIG_SLAVE_IDF_TARGET_ESP32C61 +#define ESP_WIFI_MAX_CONN_NUM (10) /**< max number of stations which can connect to ESP32C3/ESP32C6/ESP32C5/ESP32C61 soft-AP */ +#else +#define ESP_WIFI_MAX_CONN_NUM (15) /**< max number of stations which can connect to ESP32/ESP32S3/ESP32S2 soft-AP */ +#endif + +/** @brief List of stations associated with the Soft-AP */ +typedef struct wifi_sta_list_t { + wifi_sta_info_t sta[ESP_WIFI_MAX_CONN_NUM]; /**< station list */ + int num; /**< number of stations in the list (other entries are invalid) */ +} wifi_sta_list_t; + +#if CONFIG_SLAVE_SOC_WIFI_HE_SUPPORT +typedef esp_wifi_rxctrl_t wifi_pkt_rx_ctrl_t; +#else +/** @brief Received packet radio metadata header, this is the common header at the beginning of all promiscuous mode RX callback buffers */ +typedef struct { + signed rssi: 8; /**< Received Signal Strength Indicator(RSSI) of packet. unit: dBm */ + unsigned rate: 5; /**< PHY rate encoding of the packet. Only valid for non HT(11bg) packet */ + unsigned : 1; /**< reserved */ + unsigned sig_mode: 2; /**< Protocol of the received packet, 0: non HT(11bg) packet; 1: HT(11n) packet; 3: VHT(11ac) packet */ + unsigned : 16; /**< reserved */ + unsigned mcs: 7; /**< Modulation Coding Scheme. If is HT(11n) packet, shows the modulation, range from 0 to 76(MSC0 ~ MCS76) */ + unsigned cwb: 1; /**< Channel Bandwidth of the packet. 0: 20MHz; 1: 40MHz */ + unsigned : 16; /**< reserved */ + unsigned smoothing: 1; /**< Set to 1 indicates that channel estimate smoothing is recommended. + Set to 0 indicates that only per-carrierindependent (unsmoothed) channel estimate is recommended. */ + unsigned not_sounding: 1; /**< Set to 0 indicates that PPDU is a sounding PPDU. Set to 1indicates that the PPDU is not a sounding PPDU. + sounding PPDU is used for channel estimation by the request receiver */ + unsigned : 1; /**< reserved */ + unsigned aggregation: 1; /**< Aggregation. 0: MPDU packet; 1: AMPDU packet */ + unsigned stbc: 2; /**< Space Time Block Code(STBC). 0: non STBC packet; 1: STBC packet */ + unsigned fec_coding: 1; /**< Forward Error Correction(FEC). Flag is set for 11n packets which are LDPC */ + unsigned sgi: 1; /**< Short Guide Interval(SGI). 0: Long GI; 1: Short GI */ +#if CONFIG_SLAVE_IDF_TARGET_ESP32 + signed noise_floor: 8; /**< noise floor of Radio Frequency Module(RF). unit: dBm*/ +#elif CONFIG_SLAVE_IDF_TARGET_ESP32S2 || CONFIG_SLAVE_IDF_TARGET_ESP32S3 || CONFIG_SLAVE_IDF_TARGET_ESP32C3 || CONFIG_SLAVE_IDF_TARGET_ESP32C2 + unsigned : 8; /**< reserved */ +#endif + unsigned ampdu_cnt: 8; /**< the number of subframes aggregated in AMPDU */ + unsigned channel: 4; /**< primary channel on which this packet is received */ + unsigned secondary_channel: 4; /**< secondary channel on which this packet is received. 0: none; 1: above; 2: below */ + unsigned : 8; /**< reserved */ + unsigned timestamp: 32; /**< timestamp. The local time when this packet is received. It is precise only if modem sleep or light sleep is not enabled. unit: microsecond */ + unsigned : 32; /**< reserved */ +#if CONFIG_SLAVE_IDF_TARGET_ESP32S2 + unsigned : 32; /**< reserved */ +#elif CONFIG_SLAVE_IDF_TARGET_ESP32S3 || CONFIG_SLAVE_IDF_TARGET_ESP32C3 || CONFIG_SLAVE_IDF_TARGET_ESP32C2 + signed noise_floor: 8; /**< noise floor of Radio Frequency Module(RF). unit: dBm*/ + unsigned : 24; /**< reserved */ + unsigned : 32; /**< reserved */ +#endif + unsigned : 31; /**< reserved */ + unsigned ant: 1; /**< antenna number from which this packet is received. 0: WiFi antenna 0; 1: WiFi antenna 1 */ +#if CONFIG_SLAVE_IDF_TARGET_ESP32S2 + signed noise_floor: 8; /**< noise floor of Radio Frequency Module(RF). unit: dBm*/ + unsigned : 24; /**< reserved */ +#elif CONFIG_SLAVE_IDF_TARGET_ESP32S3 || CONFIG_SLAVE_IDF_TARGET_ESP32C3 || CONFIG_SLAVE_IDF_TARGET_ESP32C2 + unsigned : 32; /**< reserved */ + unsigned : 32; /**< reserved */ + unsigned : 32; /**< reserved */ +#endif + unsigned sig_len: 12; /**< length of packet including Frame Check Sequence(FCS) */ + unsigned : 12; /**< reserved */ + unsigned rx_state: 8; /**< state of the packet. 0: no error; others: error numbers which are not public */ +} wifi_pkt_rx_ctrl_t; +#endif + +/** + * @brief Channel state information(CSI) configuration type + * + */ +#if CONFIG_SLAVE_SOC_WIFI_HE_SUPPORT +typedef wifi_csi_acquire_config_t wifi_csi_config_t; +#else +typedef struct { + bool lltf_en; /**< enable to receive legacy long training field(lltf) data. Default enabled */ + bool htltf_en; /**< enable to receive HT long training field(htltf) data. Default enabled */ + bool stbc_htltf2_en; /**< enable to receive space time block code HT long training field(stbc-htltf2) data. Default enabled */ + bool ltf_merge_en; /**< enable to generate htlft data by averaging lltf and ht_ltf data when receiving HT packet. Otherwise, use ht_ltf data directly. Default enabled */ + bool channel_filter_en; /**< enable to turn on channel filter to smooth adjacent sub-carrier. Disable it to keep independence of adjacent sub-carrier. Default enabled */ + bool manu_scale; /**< manually scale the CSI data by left shifting or automatically scale the CSI data. If set true, please set the shift bits. false: automatically. true: manually. Default false */ + uint8_t shift; /**< manually left shift bits of the scale of the CSI data. The range of the left shift bits is 0~15 */ + bool dump_ack_en; /**< enable to dump 802.11 ACK frame, default disabled */ +} wifi_csi_config_t; +#endif // !CONFIG_SLAVE_SOC_WIFI_HE_SUPPORT + +/** @brief Payload passed to 'buf' parameter of promiscuous mode RX callback. + */ +typedef struct { + wifi_pkt_rx_ctrl_t rx_ctrl; /**< metadata header */ + uint8_t payload[0]; /**< Data or management payload. Length of payload is described by rx_ctrl.sig_len. Type of content determined by packet type argument of callback. */ +} wifi_promiscuous_pkt_t; + +/** + * @brief CSI data type + * + */ +typedef struct wifi_csi_info_t { + wifi_pkt_rx_ctrl_t rx_ctrl;/**< received packet radio metadata header of the CSI data */ + uint8_t mac[6]; /**< source MAC address of the CSI data */ + uint8_t dmac[6]; /**< destination MAC address of the CSI data */ + bool first_word_invalid; /**< first four bytes of the CSI data is invalid or not, true indicates the first four bytes is invalid due to hardware limitation */ + int8_t *buf; /**< valid buffer of CSI data */ + uint16_t len; /**< valid length of CSI data */ + uint8_t *hdr; /**< header of the wifi packet */ + uint8_t *payload; /**< payload of the wifi packet */ + uint16_t payload_len; /**< payload len of the wifi packet */ + uint16_t rx_seq; /**< rx sequence number of the wifi packet */ +} wifi_csi_info_t; + +#ifdef __cplusplus +} +#endif diff --git a/components/esp_wifi_remote/idf_v5.5/wifi_apps/roaming_app/src/Kconfig.roaming b/components/esp_wifi_remote/idf_v5.5/wifi_apps/roaming_app/src/Kconfig.roaming new file mode 100644 index 0000000..e69de29 diff --git a/components/esp_wifi_remote/test/smoke_test/components/esp_hosted/idf_v5.5/esp_hosted_mock.c b/components/esp_wifi_remote/test/smoke_test/components/esp_hosted/idf_v5.5/esp_hosted_mock.c new file mode 100644 index 0000000..c490148 --- /dev/null +++ b/components/esp_wifi_remote/test/smoke_test/components/esp_hosted/idf_v5.5/esp_hosted_mock.c @@ -0,0 +1,428 @@ +/* + * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +// This file is auto-generated +#include "esp_wifi.h" +#include "esp_wifi_remote.h" + +esp_err_t esp_wifi_remote_init(const wifi_init_config_t *config) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_deinit(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_mode(wifi_mode_t mode) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_mode(wifi_mode_t *mode) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_start(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_stop(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_restore(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_connect(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_disconnect(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_clear_fast_connect(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_deauth_sta(uint16_t aid) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_scan_start(const wifi_scan_config_t *config, _Bool block) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_scan_parameters(const wifi_scan_default_params_t *config) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_scan_parameters(wifi_scan_default_params_t *config) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_scan_stop(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_scan_get_ap_num(uint16_t *number) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_scan_get_ap_record(wifi_ap_record_t *ap_record) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_clear_ap_list(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_sta_get_ap_info(wifi_ap_record_t *ap_info) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_ps(wifi_ps_type_t type) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_ps(wifi_ps_type_t *type) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_channel(uint8_t primary, wifi_second_chan_t second) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_channel(uint8_t *primary, wifi_second_chan_t *second) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_country(const wifi_country_t *country) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_country(wifi_country_t *country) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_mac(wifi_interface_t ifx, const uint8_t mac[6]) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_mac(wifi_interface_t ifx, uint8_t mac[6]) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_promiscuous(_Bool en) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_promiscuous(_Bool *en) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_promiscuous_filter(const wifi_promiscuous_filter_t *filter) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_promiscuous_filter(wifi_promiscuous_filter_t *filter) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_promiscuous_ctrl_filter(const wifi_promiscuous_filter_t *filter) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_promiscuous_ctrl_filter(wifi_promiscuous_filter_t *filter) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_config(wifi_interface_t interface, wifi_config_t *conf) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_config(wifi_interface_t interface, wifi_config_t *conf) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_ap_get_sta_list(wifi_sta_list_t *sta) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_ap_get_sta_aid(const uint8_t mac[6], uint16_t *aid) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_storage(wifi_storage_t storage) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_vendor_ie(_Bool enable, wifi_vendor_ie_type_t type, wifi_vendor_ie_id_t idx, const void *vnd_ie) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_vendor_ie_cb(esp_vendor_ie_cb_t cb, void *ctx) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_max_tx_power(int8_t power) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_max_tx_power(int8_t *power) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_event_mask(uint32_t mask) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_event_mask(uint32_t *mask) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_80211_tx(wifi_interface_t ifx, const void *buffer, int len, _Bool en_sys_seq) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_csi_rx_cb(wifi_csi_cb_t cb, void *ctx) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_csi_config(const wifi_csi_config_t *config) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_csi_config(wifi_csi_config_t *config) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_csi(_Bool en) +{ + return ESP_OK; +} + +int64_t esp_wifi_remote_get_tsf_time(wifi_interface_t interface) +{ + return 0; +} + +esp_err_t esp_wifi_remote_set_inactive_time(wifi_interface_t ifx, uint16_t sec) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_inactive_time(wifi_interface_t ifx, uint16_t *sec) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_statis_dump(uint32_t modules) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_rssi_threshold(int32_t rssi) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_ftm_initiate_session(wifi_ftm_initiator_cfg_t *cfg) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_ftm_end_session(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_ftm_resp_set_offset(int16_t offset_cm) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_ftm_get_report(wifi_ftm_report_entry_t *report, uint8_t num_entries) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_config_11b_rate(wifi_interface_t ifx, _Bool disable) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_connectionless_module_set_wake_interval(uint16_t wake_interval) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_force_wakeup_acquire(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_force_wakeup_release(void) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_country_code(const char *country, _Bool ieee80211d_enabled) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_country_code(char *country) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_config_80211_tx_rate(wifi_interface_t ifx, wifi_phy_rate_t rate) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_disable_pmf_config(wifi_interface_t ifx) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_sta_get_aid(uint16_t *aid) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_dynamic_cs(_Bool enabled) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_sta_get_rssi(int *rssi) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_band(wifi_band_t band) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_band(wifi_band_t *band) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_band_mode(wifi_band_mode_t band_mode) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_band_mode(wifi_band_mode_t *band_mode) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_set_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw) +{ + return ESP_OK; +} + +esp_err_t esp_wifi_remote_get_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw) +{ + return ESP_OK; +} diff --git a/components/esp_wifi_remote/test/smoke_test/components/esp_hosted/idf_v5.5/include/esp_hosted_mock.h b/components/esp_wifi_remote/test/smoke_test/components/esp_hosted/idf_v5.5/include/esp_hosted_mock.h new file mode 100644 index 0000000..9704c15 --- /dev/null +++ b/components/esp_wifi_remote/test/smoke_test/components/esp_hosted/idf_v5.5/include/esp_hosted_mock.h @@ -0,0 +1,91 @@ +/* + * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +// This file is auto-generated +#pragma once +esp_err_t esp_wifi_remote_init(const wifi_init_config_t *config); +esp_err_t esp_wifi_remote_deinit(void); +esp_err_t esp_wifi_remote_set_mode(wifi_mode_t mode); +esp_err_t esp_wifi_remote_get_mode(wifi_mode_t *mode); +esp_err_t esp_wifi_remote_start(void); +esp_err_t esp_wifi_remote_stop(void); +esp_err_t esp_wifi_remote_restore(void); +esp_err_t esp_wifi_remote_connect(void); +esp_err_t esp_wifi_remote_disconnect(void); +esp_err_t esp_wifi_remote_clear_fast_connect(void); +esp_err_t esp_wifi_remote_deauth_sta(uint16_t aid); +esp_err_t esp_wifi_remote_scan_start(const wifi_scan_config_t *config, _Bool block); +esp_err_t esp_wifi_remote_set_scan_parameters(const wifi_scan_default_params_t *config); +esp_err_t esp_wifi_remote_get_scan_parameters(wifi_scan_default_params_t *config); +esp_err_t esp_wifi_remote_scan_stop(void); +esp_err_t esp_wifi_remote_scan_get_ap_num(uint16_t *number); +esp_err_t esp_wifi_remote_scan_get_ap_records(uint16_t *number, wifi_ap_record_t *ap_records); +esp_err_t esp_wifi_remote_scan_get_ap_record(wifi_ap_record_t *ap_record); +esp_err_t esp_wifi_remote_clear_ap_list(void); +esp_err_t esp_wifi_remote_sta_get_ap_info(wifi_ap_record_t *ap_info); +esp_err_t esp_wifi_remote_set_ps(wifi_ps_type_t type); +esp_err_t esp_wifi_remote_get_ps(wifi_ps_type_t *type); +esp_err_t esp_wifi_remote_set_protocol(wifi_interface_t ifx, uint8_t protocol_bitmap); +esp_err_t esp_wifi_remote_get_protocol(wifi_interface_t ifx, uint8_t *protocol_bitmap); +esp_err_t esp_wifi_remote_set_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t bw); +esp_err_t esp_wifi_remote_get_bandwidth(wifi_interface_t ifx, wifi_bandwidth_t *bw); +esp_err_t esp_wifi_remote_set_channel(uint8_t primary, wifi_second_chan_t second); +esp_err_t esp_wifi_remote_get_channel(uint8_t *primary, wifi_second_chan_t *second); +esp_err_t esp_wifi_remote_set_country(const wifi_country_t *country); +esp_err_t esp_wifi_remote_get_country(wifi_country_t *country); +esp_err_t esp_wifi_remote_set_mac(wifi_interface_t ifx, const uint8_t mac[6]); +esp_err_t esp_wifi_remote_get_mac(wifi_interface_t ifx, uint8_t mac[6]); +esp_err_t esp_wifi_remote_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb); +esp_err_t esp_wifi_remote_set_promiscuous(_Bool en); +esp_err_t esp_wifi_remote_get_promiscuous(_Bool *en); +esp_err_t esp_wifi_remote_set_promiscuous_filter(const wifi_promiscuous_filter_t *filter); +esp_err_t esp_wifi_remote_get_promiscuous_filter(wifi_promiscuous_filter_t *filter); +esp_err_t esp_wifi_remote_set_promiscuous_ctrl_filter(const wifi_promiscuous_filter_t *filter); +esp_err_t esp_wifi_remote_get_promiscuous_ctrl_filter(wifi_promiscuous_filter_t *filter); +esp_err_t esp_wifi_remote_set_config(wifi_interface_t interface, wifi_config_t *conf); +esp_err_t esp_wifi_remote_get_config(wifi_interface_t interface, wifi_config_t *conf); +esp_err_t esp_wifi_remote_ap_get_sta_list(wifi_sta_list_t *sta); +esp_err_t esp_wifi_remote_ap_get_sta_aid(const uint8_t mac[6], uint16_t *aid); +esp_err_t esp_wifi_remote_set_storage(wifi_storage_t storage); +esp_err_t esp_wifi_remote_set_vendor_ie(_Bool enable, wifi_vendor_ie_type_t type, wifi_vendor_ie_id_t idx, const void *vnd_ie); +esp_err_t esp_wifi_remote_set_vendor_ie_cb(esp_vendor_ie_cb_t cb, void *ctx); +esp_err_t esp_wifi_remote_set_max_tx_power(int8_t power); +esp_err_t esp_wifi_remote_get_max_tx_power(int8_t *power); +esp_err_t esp_wifi_remote_set_event_mask(uint32_t mask); +esp_err_t esp_wifi_remote_get_event_mask(uint32_t *mask); +esp_err_t esp_wifi_remote_80211_tx(wifi_interface_t ifx, const void *buffer, int len, _Bool en_sys_seq); +esp_err_t esp_wifi_remote_set_csi_rx_cb(wifi_csi_cb_t cb, void *ctx); +esp_err_t esp_wifi_remote_set_csi_config(const wifi_csi_config_t *config); +esp_err_t esp_wifi_remote_get_csi_config(wifi_csi_config_t *config); +esp_err_t esp_wifi_remote_set_csi(_Bool en); +int64_t esp_wifi_remote_get_tsf_time(wifi_interface_t interface); +esp_err_t esp_wifi_remote_set_inactive_time(wifi_interface_t ifx, uint16_t sec); +esp_err_t esp_wifi_remote_get_inactive_time(wifi_interface_t ifx, uint16_t *sec); +esp_err_t esp_wifi_remote_statis_dump(uint32_t modules); +esp_err_t esp_wifi_remote_set_rssi_threshold(int32_t rssi); +esp_err_t esp_wifi_remote_ftm_initiate_session(wifi_ftm_initiator_cfg_t *cfg); +esp_err_t esp_wifi_remote_ftm_end_session(void); +esp_err_t esp_wifi_remote_ftm_resp_set_offset(int16_t offset_cm); +esp_err_t esp_wifi_remote_ftm_get_report(wifi_ftm_report_entry_t *report, uint8_t num_entries); +esp_err_t esp_wifi_remote_config_11b_rate(wifi_interface_t ifx, _Bool disable); +esp_err_t esp_wifi_remote_connectionless_module_set_wake_interval(uint16_t wake_interval); +esp_err_t esp_wifi_remote_force_wakeup_acquire(void); +esp_err_t esp_wifi_remote_force_wakeup_release(void); +esp_err_t esp_wifi_remote_set_country_code(const char *country, _Bool ieee80211d_enabled); +esp_err_t esp_wifi_remote_get_country_code(char *country); +esp_err_t esp_wifi_remote_config_80211_tx_rate(wifi_interface_t ifx, wifi_phy_rate_t rate); +esp_err_t esp_wifi_remote_disable_pmf_config(wifi_interface_t ifx); +esp_err_t esp_wifi_remote_sta_get_aid(uint16_t *aid); +esp_err_t esp_wifi_remote_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode); +esp_err_t esp_wifi_remote_set_dynamic_cs(_Bool enabled); +esp_err_t esp_wifi_remote_sta_get_rssi(int *rssi); +esp_err_t esp_wifi_remote_set_band(wifi_band_t band); +esp_err_t esp_wifi_remote_get_band(wifi_band_t *band); +esp_err_t esp_wifi_remote_set_band_mode(wifi_band_mode_t band_mode); +esp_err_t esp_wifi_remote_get_band_mode(wifi_band_mode_t *band_mode); +esp_err_t esp_wifi_remote_set_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols); +esp_err_t esp_wifi_remote_get_protocols(wifi_interface_t ifx, wifi_protocols_t *protocols); +esp_err_t esp_wifi_remote_set_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw); +esp_err_t esp_wifi_remote_get_bandwidths(wifi_interface_t ifx, wifi_bandwidths_t *bw); diff --git a/components/esp_wifi_remote/test/smoke_test/main/idf_v5.5/all_wifi_calls.c b/components/esp_wifi_remote/test/smoke_test/main/idf_v5.5/all_wifi_calls.c new file mode 100644 index 0000000..a5a4e8b --- /dev/null +++ b/components/esp_wifi_remote/test/smoke_test/main/idf_v5.5/all_wifi_calls.c @@ -0,0 +1,450 @@ +/* + * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +// This file is auto-generated +#include "esp_wifi.h" + +void run_all_wifi_apis(void) +{ + { + const wifi_init_config_t *config = NULL; + esp_wifi_init(config); + } + + { + esp_wifi_deinit(); + } + + { + wifi_mode_t mode = 0; + esp_wifi_set_mode(mode); + } + + { + wifi_mode_t *mode = NULL; + esp_wifi_get_mode(mode); + } + + { + esp_wifi_start(); + } + + { + esp_wifi_stop(); + } + + { + esp_wifi_restore(); + } + + { + esp_wifi_connect(); + } + + { + esp_wifi_disconnect(); + } + + { + esp_wifi_clear_fast_connect(); + } + + { + uint16_t aid = 0; + esp_wifi_deauth_sta(aid); + } + + { + const wifi_scan_config_t *config = NULL; + _Bool block = 0; + esp_wifi_scan_start(config, block); + } + + { + const wifi_scan_default_params_t *config = NULL; + esp_wifi_set_scan_parameters(config); + } + + { + wifi_scan_default_params_t *config = NULL; + esp_wifi_get_scan_parameters(config); + } + + { + esp_wifi_scan_stop(); + } + + { + uint16_t *number = NULL; + esp_wifi_scan_get_ap_num(number); + } + + { + uint16_t *number = NULL; + wifi_ap_record_t *ap_records = NULL; + esp_wifi_scan_get_ap_records(number, ap_records); + } + + { + wifi_ap_record_t *ap_record = NULL; + esp_wifi_scan_get_ap_record(ap_record); + } + + { + esp_wifi_clear_ap_list(); + } + + { + wifi_ap_record_t *ap_info = NULL; + esp_wifi_sta_get_ap_info(ap_info); + } + + { + wifi_ps_type_t type = 0; + esp_wifi_set_ps(type); + } + + { + wifi_ps_type_t *type = NULL; + esp_wifi_get_ps(type); + } + + { + wifi_interface_t ifx = 0; + uint8_t protocol_bitmap = 0; + esp_wifi_set_protocol(ifx, protocol_bitmap); + } + + { + wifi_interface_t ifx = 0; + uint8_t *protocol_bitmap = NULL; + esp_wifi_get_protocol(ifx, protocol_bitmap); + } + + { + wifi_interface_t ifx = 0; + wifi_bandwidth_t bw = 0; + esp_wifi_set_bandwidth(ifx, bw); + } + + { + wifi_interface_t ifx = 0; + wifi_bandwidth_t *bw = NULL; + esp_wifi_get_bandwidth(ifx, bw); + } + + { + uint8_t primary = 0; + wifi_second_chan_t second = 0; + esp_wifi_set_channel(primary, second); + } + + { + uint8_t *primary = NULL; + wifi_second_chan_t *second = NULL; + esp_wifi_get_channel(primary, second); + } + + { + const wifi_country_t *country = NULL; + esp_wifi_set_country(country); + } + + { + wifi_country_t *country = NULL; + esp_wifi_get_country(country); + } + + { + wifi_interface_t ifx = 0; + const uint8_t mac[6] = {}; + esp_wifi_set_mac(ifx, mac); + } + + { + wifi_interface_t ifx = 0; + uint8_t mac[6] = {}; + esp_wifi_get_mac(ifx, mac); + } + + { + wifi_promiscuous_cb_t cb = 0; + esp_wifi_set_promiscuous_rx_cb(cb); + } + + { + _Bool en = 0; + esp_wifi_set_promiscuous(en); + } + + { + _Bool *en = NULL; + esp_wifi_get_promiscuous(en); + } + + { + const wifi_promiscuous_filter_t *filter = NULL; + esp_wifi_set_promiscuous_filter(filter); + } + + { + wifi_promiscuous_filter_t *filter = NULL; + esp_wifi_get_promiscuous_filter(filter); + } + + { + const wifi_promiscuous_filter_t *filter = NULL; + esp_wifi_set_promiscuous_ctrl_filter(filter); + } + + { + wifi_promiscuous_filter_t *filter = NULL; + esp_wifi_get_promiscuous_ctrl_filter(filter); + } + + { + wifi_interface_t interface = 0; + wifi_config_t *conf = NULL; + esp_wifi_set_config(interface, conf); + } + + { + wifi_interface_t interface = 0; + wifi_config_t *conf = NULL; + esp_wifi_get_config(interface, conf); + } + + { + wifi_sta_list_t *sta = NULL; + esp_wifi_ap_get_sta_list(sta); + } + + { + const uint8_t mac[6] = {}; + uint16_t *aid = NULL; + esp_wifi_ap_get_sta_aid(mac, aid); + } + + { + wifi_storage_t storage = 0; + esp_wifi_set_storage(storage); + } + + { + _Bool enable = 0; + wifi_vendor_ie_type_t type = 0; + wifi_vendor_ie_id_t idx = 0; + const void *vnd_ie = NULL; + esp_wifi_set_vendor_ie(enable, type, idx, vnd_ie); + } + + { + esp_vendor_ie_cb_t cb = 0; + void *ctx = NULL; + esp_wifi_set_vendor_ie_cb(cb, ctx); + } + + { + int8_t power = 0; + esp_wifi_set_max_tx_power(power); + } + + { + int8_t *power = NULL; + esp_wifi_get_max_tx_power(power); + } + + { + uint32_t mask = 0; + esp_wifi_set_event_mask(mask); + } + + { + uint32_t *mask = NULL; + esp_wifi_get_event_mask(mask); + } + + { + wifi_interface_t ifx = 0; + const void *buffer = NULL; + int len = 0; + _Bool en_sys_seq = 0; + esp_wifi_80211_tx(ifx, buffer, len, en_sys_seq); + } + + { + wifi_csi_cb_t cb = 0; + void *ctx = NULL; + esp_wifi_set_csi_rx_cb(cb, ctx); + } + + { + const wifi_csi_config_t *config = NULL; + esp_wifi_set_csi_config(config); + } + + { + wifi_csi_config_t *config = NULL; + esp_wifi_get_csi_config(config); + } + + { + _Bool en = 0; + esp_wifi_set_csi(en); + } + + { + wifi_interface_t interface = 0; + esp_wifi_get_tsf_time(interface); + } + + { + wifi_interface_t ifx = 0; + uint16_t sec = 0; + esp_wifi_set_inactive_time(ifx, sec); + } + + { + wifi_interface_t ifx = 0; + uint16_t *sec = NULL; + esp_wifi_get_inactive_time(ifx, sec); + } + + { + uint32_t modules = 0; + esp_wifi_statis_dump(modules); + } + + { + int32_t rssi = 0; + esp_wifi_set_rssi_threshold(rssi); + } + + { + wifi_ftm_initiator_cfg_t *cfg = NULL; + esp_wifi_ftm_initiate_session(cfg); + } + + { + esp_wifi_ftm_end_session(); + } + + { + int16_t offset_cm = 0; + esp_wifi_ftm_resp_set_offset(offset_cm); + } + + { + wifi_ftm_report_entry_t *report = NULL; + uint8_t num_entries = 0; + esp_wifi_ftm_get_report(report, num_entries); + } + + { + wifi_interface_t ifx = 0; + _Bool disable = 0; + esp_wifi_config_11b_rate(ifx, disable); + } + + { + uint16_t wake_interval = 0; + esp_wifi_connectionless_module_set_wake_interval(wake_interval); + } + + { + esp_wifi_force_wakeup_acquire(); + } + + { + esp_wifi_force_wakeup_release(); + } + + { + const char *country = NULL; + _Bool ieee80211d_enabled = 0; + esp_wifi_set_country_code(country, ieee80211d_enabled); + } + + { + char *country = NULL; + esp_wifi_get_country_code(country); + } + + { + wifi_interface_t ifx = 0; + wifi_phy_rate_t rate = 0; + esp_wifi_config_80211_tx_rate(ifx, rate); + } + + { + wifi_interface_t ifx = 0; + esp_wifi_disable_pmf_config(ifx); + } + + { + uint16_t *aid = NULL; + esp_wifi_sta_get_aid(aid); + } + + { + wifi_phy_mode_t *phymode = NULL; + esp_wifi_sta_get_negotiated_phymode(phymode); + } + + { + _Bool enabled = 0; + esp_wifi_set_dynamic_cs(enabled); + } + + { + int *rssi = NULL; + esp_wifi_sta_get_rssi(rssi); + } + + { + wifi_band_t band = 0; + esp_wifi_set_band(band); + } + + { + wifi_band_t *band = NULL; + esp_wifi_get_band(band); + } + + { + wifi_band_mode_t band_mode = 0; + esp_wifi_set_band_mode(band_mode); + } + + { + wifi_band_mode_t *band_mode = NULL; + esp_wifi_get_band_mode(band_mode); + } + + { + wifi_interface_t ifx = 0; + wifi_protocols_t *protocols = NULL; + esp_wifi_set_protocols(ifx, protocols); + } + + { + wifi_interface_t ifx = 0; + wifi_protocols_t *protocols = NULL; + esp_wifi_get_protocols(ifx, protocols); + } + + { + wifi_interface_t ifx = 0; + wifi_bandwidths_t *bw = NULL; + esp_wifi_set_bandwidths(ifx, bw); + } + + { + wifi_interface_t ifx = 0; + wifi_bandwidths_t *bw = NULL; + esp_wifi_get_bandwidths(ifx, bw); + } + +} diff --git a/components/esp_wifi_remote/test/smoke_test/main/idf_v5.5/all_wifi_remote_calls.c b/components/esp_wifi_remote/test/smoke_test/main/idf_v5.5/all_wifi_remote_calls.c new file mode 100644 index 0000000..8861531 --- /dev/null +++ b/components/esp_wifi_remote/test/smoke_test/main/idf_v5.5/all_wifi_remote_calls.c @@ -0,0 +1,450 @@ +/* + * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +// This file is auto-generated +#include "esp_wifi_remote.h" + +void run_all_wifi_remote_apis(void) +{ + { + const wifi_init_config_t *config = NULL; + esp_wifi_remote_init(config); + } + + { + esp_wifi_remote_deinit(); + } + + { + wifi_mode_t mode = 0; + esp_wifi_remote_set_mode(mode); + } + + { + wifi_mode_t *mode = NULL; + esp_wifi_remote_get_mode(mode); + } + + { + esp_wifi_remote_start(); + } + + { + esp_wifi_remote_stop(); + } + + { + esp_wifi_remote_restore(); + } + + { + esp_wifi_remote_connect(); + } + + { + esp_wifi_remote_disconnect(); + } + + { + esp_wifi_remote_clear_fast_connect(); + } + + { + uint16_t aid = 0; + esp_wifi_remote_deauth_sta(aid); + } + + { + const wifi_scan_config_t *config = NULL; + _Bool block = 0; + esp_wifi_remote_scan_start(config, block); + } + + { + const wifi_scan_default_params_t *config = NULL; + esp_wifi_remote_set_scan_parameters(config); + } + + { + wifi_scan_default_params_t *config = NULL; + esp_wifi_remote_get_scan_parameters(config); + } + + { + esp_wifi_remote_scan_stop(); + } + + { + uint16_t *number = NULL; + esp_wifi_remote_scan_get_ap_num(number); + } + + { + uint16_t *number = NULL; + wifi_ap_record_t *ap_records = NULL; + esp_wifi_remote_scan_get_ap_records(number, ap_records); + } + + { + wifi_ap_record_t *ap_record = NULL; + esp_wifi_remote_scan_get_ap_record(ap_record); + } + + { + esp_wifi_remote_clear_ap_list(); + } + + { + wifi_ap_record_t *ap_info = NULL; + esp_wifi_remote_sta_get_ap_info(ap_info); + } + + { + wifi_ps_type_t type = 0; + esp_wifi_remote_set_ps(type); + } + + { + wifi_ps_type_t *type = NULL; + esp_wifi_remote_get_ps(type); + } + + { + wifi_interface_t ifx = 0; + uint8_t protocol_bitmap = 0; + esp_wifi_remote_set_protocol(ifx, protocol_bitmap); + } + + { + wifi_interface_t ifx = 0; + uint8_t *protocol_bitmap = NULL; + esp_wifi_remote_get_protocol(ifx, protocol_bitmap); + } + + { + wifi_interface_t ifx = 0; + wifi_bandwidth_t bw = 0; + esp_wifi_remote_set_bandwidth(ifx, bw); + } + + { + wifi_interface_t ifx = 0; + wifi_bandwidth_t *bw = NULL; + esp_wifi_remote_get_bandwidth(ifx, bw); + } + + { + uint8_t primary = 0; + wifi_second_chan_t second = 0; + esp_wifi_remote_set_channel(primary, second); + } + + { + uint8_t *primary = NULL; + wifi_second_chan_t *second = NULL; + esp_wifi_remote_get_channel(primary, second); + } + + { + const wifi_country_t *country = NULL; + esp_wifi_remote_set_country(country); + } + + { + wifi_country_t *country = NULL; + esp_wifi_remote_get_country(country); + } + + { + wifi_interface_t ifx = 0; + const uint8_t mac[6] = {}; + esp_wifi_remote_set_mac(ifx, mac); + } + + { + wifi_interface_t ifx = 0; + uint8_t mac[6] = {}; + esp_wifi_remote_get_mac(ifx, mac); + } + + { + wifi_promiscuous_cb_t cb = 0; + esp_wifi_remote_set_promiscuous_rx_cb(cb); + } + + { + _Bool en = 0; + esp_wifi_remote_set_promiscuous(en); + } + + { + _Bool *en = NULL; + esp_wifi_remote_get_promiscuous(en); + } + + { + const wifi_promiscuous_filter_t *filter = NULL; + esp_wifi_remote_set_promiscuous_filter(filter); + } + + { + wifi_promiscuous_filter_t *filter = NULL; + esp_wifi_remote_get_promiscuous_filter(filter); + } + + { + const wifi_promiscuous_filter_t *filter = NULL; + esp_wifi_remote_set_promiscuous_ctrl_filter(filter); + } + + { + wifi_promiscuous_filter_t *filter = NULL; + esp_wifi_remote_get_promiscuous_ctrl_filter(filter); + } + + { + wifi_interface_t interface = 0; + wifi_config_t *conf = NULL; + esp_wifi_remote_set_config(interface, conf); + } + + { + wifi_interface_t interface = 0; + wifi_config_t *conf = NULL; + esp_wifi_remote_get_config(interface, conf); + } + + { + wifi_sta_list_t *sta = NULL; + esp_wifi_remote_ap_get_sta_list(sta); + } + + { + const uint8_t mac[6] = {}; + uint16_t *aid = NULL; + esp_wifi_remote_ap_get_sta_aid(mac, aid); + } + + { + wifi_storage_t storage = 0; + esp_wifi_remote_set_storage(storage); + } + + { + _Bool enable = 0; + wifi_vendor_ie_type_t type = 0; + wifi_vendor_ie_id_t idx = 0; + const void *vnd_ie = NULL; + esp_wifi_remote_set_vendor_ie(enable, type, idx, vnd_ie); + } + + { + esp_vendor_ie_cb_t cb = 0; + void *ctx = NULL; + esp_wifi_remote_set_vendor_ie_cb(cb, ctx); + } + + { + int8_t power = 0; + esp_wifi_remote_set_max_tx_power(power); + } + + { + int8_t *power = NULL; + esp_wifi_remote_get_max_tx_power(power); + } + + { + uint32_t mask = 0; + esp_wifi_remote_set_event_mask(mask); + } + + { + uint32_t *mask = NULL; + esp_wifi_remote_get_event_mask(mask); + } + + { + wifi_interface_t ifx = 0; + const void *buffer = NULL; + int len = 0; + _Bool en_sys_seq = 0; + esp_wifi_remote_80211_tx(ifx, buffer, len, en_sys_seq); + } + + { + wifi_csi_cb_t cb = 0; + void *ctx = NULL; + esp_wifi_remote_set_csi_rx_cb(cb, ctx); + } + + { + const wifi_csi_config_t *config = NULL; + esp_wifi_remote_set_csi_config(config); + } + + { + wifi_csi_config_t *config = NULL; + esp_wifi_remote_get_csi_config(config); + } + + { + _Bool en = 0; + esp_wifi_remote_set_csi(en); + } + + { + wifi_interface_t interface = 0; + esp_wifi_remote_get_tsf_time(interface); + } + + { + wifi_interface_t ifx = 0; + uint16_t sec = 0; + esp_wifi_remote_set_inactive_time(ifx, sec); + } + + { + wifi_interface_t ifx = 0; + uint16_t *sec = NULL; + esp_wifi_remote_get_inactive_time(ifx, sec); + } + + { + uint32_t modules = 0; + esp_wifi_remote_statis_dump(modules); + } + + { + int32_t rssi = 0; + esp_wifi_remote_set_rssi_threshold(rssi); + } + + { + wifi_ftm_initiator_cfg_t *cfg = NULL; + esp_wifi_remote_ftm_initiate_session(cfg); + } + + { + esp_wifi_remote_ftm_end_session(); + } + + { + int16_t offset_cm = 0; + esp_wifi_remote_ftm_resp_set_offset(offset_cm); + } + + { + wifi_ftm_report_entry_t *report = NULL; + uint8_t num_entries = 0; + esp_wifi_remote_ftm_get_report(report, num_entries); + } + + { + wifi_interface_t ifx = 0; + _Bool disable = 0; + esp_wifi_remote_config_11b_rate(ifx, disable); + } + + { + uint16_t wake_interval = 0; + esp_wifi_remote_connectionless_module_set_wake_interval(wake_interval); + } + + { + esp_wifi_remote_force_wakeup_acquire(); + } + + { + esp_wifi_remote_force_wakeup_release(); + } + + { + const char *country = NULL; + _Bool ieee80211d_enabled = 0; + esp_wifi_remote_set_country_code(country, ieee80211d_enabled); + } + + { + char *country = NULL; + esp_wifi_remote_get_country_code(country); + } + + { + wifi_interface_t ifx = 0; + wifi_phy_rate_t rate = 0; + esp_wifi_remote_config_80211_tx_rate(ifx, rate); + } + + { + wifi_interface_t ifx = 0; + esp_wifi_remote_disable_pmf_config(ifx); + } + + { + uint16_t *aid = NULL; + esp_wifi_remote_sta_get_aid(aid); + } + + { + wifi_phy_mode_t *phymode = NULL; + esp_wifi_remote_sta_get_negotiated_phymode(phymode); + } + + { + _Bool enabled = 0; + esp_wifi_remote_set_dynamic_cs(enabled); + } + + { + int *rssi = NULL; + esp_wifi_remote_sta_get_rssi(rssi); + } + + { + wifi_band_t band = 0; + esp_wifi_remote_set_band(band); + } + + { + wifi_band_t *band = NULL; + esp_wifi_remote_get_band(band); + } + + { + wifi_band_mode_t band_mode = 0; + esp_wifi_remote_set_band_mode(band_mode); + } + + { + wifi_band_mode_t *band_mode = NULL; + esp_wifi_remote_get_band_mode(band_mode); + } + + { + wifi_interface_t ifx = 0; + wifi_protocols_t *protocols = NULL; + esp_wifi_remote_set_protocols(ifx, protocols); + } + + { + wifi_interface_t ifx = 0; + wifi_protocols_t *protocols = NULL; + esp_wifi_remote_get_protocols(ifx, protocols); + } + + { + wifi_interface_t ifx = 0; + wifi_bandwidths_t *bw = NULL; + esp_wifi_remote_set_bandwidths(ifx, bw); + } + + { + wifi_interface_t ifx = 0; + wifi_bandwidths_t *bw = NULL; + esp_wifi_remote_get_bandwidths(ifx, bw); + } + +} From 414587a7ce77c9ecd113ff7738bcab9167b6b7e6 Mon Sep 17 00:00:00 2001 From: David Cermak Date: Thu, 24 Oct 2024 14:56:43 +0200 Subject: [PATCH 2/2] bump(wifi_remote): 0.4.1 -> 0.5.0 0.5.0 Features - Add support for IDF-v5.5 (1e03fb8) --- components/esp_wifi_remote/.cz.yaml | 2 +- components/esp_wifi_remote/CHANGELOG.md | 6 ++++++ components/esp_wifi_remote/idf_component.yml | 2 +- 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/components/esp_wifi_remote/.cz.yaml b/components/esp_wifi_remote/.cz.yaml index fe8cfb1..6f6dd84 100644 --- a/components/esp_wifi_remote/.cz.yaml +++ b/components/esp_wifi_remote/.cz.yaml @@ -3,6 +3,6 @@ commitizen: bump_message: 'bump(wifi_remote): $current_version -> $new_version' pre_bump_hooks: python ../../ci/changelog.py esp_wifi_remote tag_format: wifi_remote-v$version - version: 0.4.1 + version: 0.5.0 version_files: - idf_component.yml diff --git a/components/esp_wifi_remote/CHANGELOG.md b/components/esp_wifi_remote/CHANGELOG.md index 18ebe2a..d27c8b4 100644 --- a/components/esp_wifi_remote/CHANGELOG.md +++ b/components/esp_wifi_remote/CHANGELOG.md @@ -1,5 +1,11 @@ # Changelog +## [0.5.0](https://github.com/espressif/esp-wifi-remote/commits/wifi_remote-v0.5.0) + +### Features + +- Add support for IDF-v5.5 ([1e03fb8](https://github.com/espressif/esp-wifi-remote/commit/1e03fb8)) + ## [0.4.1](https://github.com/espressif/esp-wifi-remote/commits/wifi_remote-v0.4.1) ### Bug Fixes diff --git a/components/esp_wifi_remote/idf_component.yml b/components/esp_wifi_remote/idf_component.yml index 93e24d8..3763f41 100644 --- a/components/esp_wifi_remote/idf_component.yml +++ b/components/esp_wifi_remote/idf_component.yml @@ -1,4 +1,4 @@ -version: 0.4.1 +version: 0.5.0 url: https://github.com/espressif/esp-wifi-remote description: Utility wrapper for esp_wifi functionality on remote targets dependencies: