From e754510cce7e128985d0e439e5b23a8ea19751d8 Mon Sep 17 00:00:00 2001 From: Dustin Crossman Date: Mon, 2 Mar 2020 15:04:56 -0800 Subject: [PATCH] Add COMPONENT_SCL. --- .../interface/SclSTAInterface.cpp | 347 +++++++++++++++ .../COMPONENT_SCL/interface/SclSTAInterface.h | 183 ++++++++ .../interface/default_wifi_interface.cpp | 39 ++ .../COMPONENT_SCL/interface/emac_eapol.h | 78 ++++ .../COMPONENT_SCL/interface/scl_emac.cpp | 249 +++++++++++ .../COMPONENT_SCL/interface/scl_emac.h | 189 +++++++++ features/netsocket/ppp/mbed_lib.json | 3 + .../COMPONENT_SCL/generated_mac_address.txt | 9 + .../COMPONENT_SCL/inc/scl_common.h | 217 ++++++++++ .../TARGET_PSOC6/COMPONENT_SCL/inc/scl_ipc.h | 113 +++++ .../COMPONENT_SCL/inc/scl_types.h | 132 ++++++ .../COMPONENT_SCL/inc/scl_wifi_api.h | 168 ++++++++ .../COMPONENT_SCL/src/IPC/scl_ipc.c | 399 ++++++++++++++++++ .../src/include/scl_buffer_api.h | 143 +++++++ .../COMPONENT_SCL/src/scl_buffer_api.c | 162 +++++++ .../COMPONENT_SCL/src/scl_wifi_api.c | 181 ++++++++ 16 files changed, 2612 insertions(+) create mode 100644 features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/SclSTAInterface.cpp create mode 100644 features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/SclSTAInterface.h create mode 100644 features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/default_wifi_interface.cpp create mode 100644 features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/emac_eapol.h create mode 100644 features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/scl_emac.cpp create mode 100644 features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/scl_emac.h create mode 100644 targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/generated_mac_address.txt create mode 100644 targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_common.h create mode 100644 targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_ipc.h create mode 100644 targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_types.h create mode 100644 targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_wifi_api.h create mode 100644 targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/IPC/scl_ipc.c create mode 100644 targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/include/scl_buffer_api.h create mode 100644 targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/scl_buffer_api.c create mode 100644 targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/scl_wifi_api.c diff --git a/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/SclSTAInterface.cpp b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/SclSTAInterface.cpp new file mode 100644 index 0000000000..ec56989990 --- /dev/null +++ b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/SclSTAInterface.cpp @@ -0,0 +1,347 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +#include +#include +#include +#include "SclSTAInterface.h" +#include "nsapi.h" +#include "lwipopts.h" +#include "lwip/etharp.h" +#include "lwip/ethip6.h" +#include "rtos.h" +#include "scl_emac.h" +#include "scl_ipc.h" +#include "mbed_wait_api.h" + +#define PARAM_LEN (20) + +struct network_params_t { + char ip_address[PARAM_LEN]; + char netmask[PARAM_LEN]; + char gateway[PARAM_LEN]; + int connection_status; +}; + +struct scl_tx_nw_credentials { + nsapi_security_t network_security_type; + int ssid_len; + int pass_len; + const char* network_ssid; + const char* network_passphrase; +} scl_tx_nw_credentials_t; +struct network_params_t network_parameter; + +int scl_toerror(scl_result_t res) +{ + switch (res) { + case SCL_SUCCESS: + return NSAPI_ERROR_OK; + case SCL_UNSUPPORTED: + return NSAPI_ERROR_UNSUPPORTED; + case SCL_BADARG: + return NSAPI_ERROR_PARAMETER; + case SCL_INVALID_JOIN_STATUS: + return NSAPI_ERROR_NO_CONNECTION; + case SCL_BUFFER_UNAVAILABLE_PERMANENT: + case SCL_BUFFER_UNAVAILABLE_TEMPORARY: + case SCL_RX_BUFFER_ALLOC_FAIL: + case SCL_BUFFER_ALLOC_FAIL: + case SCL_MALLOC_FAILURE: + return NSAPI_ERROR_NO_MEMORY; + case SCL_ACCESS_POINT_NOT_FOUND: + case SCL_NETWORK_NOT_FOUND: + return NSAPI_ERROR_NO_SSID; + case SCL_NOT_AUTHENTICATED: + case SCL_INVALID_KEY: + case SCL_NOT_KEYED: + return NSAPI_ERROR_AUTH_FAILURE; + case SCL_PENDING: + case SCL_JOIN_IN_PROGRESS: + return NSAPI_ERROR_IN_PROGRESS; + case SCL_CONNECTION_LOST: + return NSAPI_ERROR_CONNECTION_LOST; + case SCL_TIMEOUT: + case SCL_EAPOL_KEY_PACKET_M1_TIMEOUT: + case SCL_EAPOL_KEY_PACKET_M3_TIMEOUT: + case SCL_EAPOL_KEY_PACKET_G1_TIMEOUT: + return NSAPI_ERROR_CONNECTION_TIMEOUT; + default: + return -res; + } +} + +nsapi_security_t scl_tosecurity(scl_security_t sec) +{ + switch (sec) { + case SCL_SECURITY_OPEN: + return NSAPI_SECURITY_NONE; + case SCL_SECURITY_WEP_PSK: + case SCL_SECURITY_WEP_SHARED: + return NSAPI_SECURITY_WEP; + case SCL_SECURITY_WPA_TKIP_PSK: + case SCL_SECURITY_WPA_TKIP_ENT: + return NSAPI_SECURITY_WPA; + case SCL_SECURITY_WPA2_MIXED_PSK: + return NSAPI_SECURITY_WPA_WPA2; + case SCL_SECURITY_WPA2_AES_PSK: + case SCL_SECURITY_WPA2_AES_ENT: + case SCL_SECURITY_WPA2_FBT_PSK: + case SCL_SECURITY_WPA2_FBT_ENT: + return NSAPI_SECURITY_WPA2; + default: + return NSAPI_SECURITY_UNKNOWN; + } +} + +scl_security_t scl_fromsecurity(nsapi_security_t sec) +{ + switch (sec) { + case NSAPI_SECURITY_NONE: + return SCL_SECURITY_OPEN; + case NSAPI_SECURITY_WEP: + return SCL_SECURITY_WEP_PSK; + case NSAPI_SECURITY_WPA: + return SCL_SECURITY_WPA_MIXED_PSK; + case NSAPI_SECURITY_WPA2: + return SCL_SECURITY_WPA2_AES_PSK; + case NSAPI_SECURITY_WPA_WPA2: + return SCL_SECURITY_WPA2_MIXED_PSK; + default: + return SCL_SECURITY_UNKNOWN; + } +} + +SclSTAInterface::SclSTAInterface(SCL_EMAC &emac, OnboardNetworkStack &stack) + : EMACInterface(emac, stack), + _ssid("\0"), + _pass("\0"), + _security(NSAPI_SECURITY_NONE), + _scl_emac(emac) +{ +} + +nsapi_error_t SclSTAInterface::connect(const char *ssid, const char *pass, nsapi_security_t security, uint8_t channel) +{ + int err = set_channel(channel); + if (err) { + return err; + } + + err = set_credentials(ssid, pass, security); + if (err) { + return err; + } + + return connect(); +} + +nsapi_error_t SclSTAInterface::set_credentials(const char *ssid, const char *pass, nsapi_security_t security) +{ + if ((ssid == NULL) || + (strlen(ssid) == 0) || + (pass == NULL && (security != NSAPI_SECURITY_NONE)) || + (strlen(pass) == 0 && (security != NSAPI_SECURITY_NONE)) || + (strlen(pass) > 63 && (security == NSAPI_SECURITY_WPA2 || security == NSAPI_SECURITY_WPA || security == NSAPI_SECURITY_WPA_WPA2)) + ) { + return NSAPI_ERROR_PARAMETER; + } + + memset(_ssid, 0, sizeof(_ssid)); + strncpy(_ssid, ssid, sizeof(_ssid)); + + memset(_pass, 0, sizeof(_pass)); + strncpy(_pass, pass, sizeof(_pass)); + + _security = security; + + return NSAPI_ERROR_OK; +} + +nsapi_error_t SclSTAInterface::connect() +{ + + uint32_t delay_timeout = 0; + scl_result_t ret_val; + nsapi_error_t interface_status; + uint32_t connection_status = 0; + + scl_tx_nw_credentials_t.network_ssid = _ssid; + if (strlen(_ssid) < MAX_SSID_LENGTH) { + scl_tx_nw_credentials_t.ssid_len = strlen(_ssid); + } + scl_tx_nw_credentials_t.network_passphrase = _pass; + if (strlen(_pass) < MAX_PASSWORD_LENGTH) { + scl_tx_nw_credentials_t.pass_len = strlen(_pass); + } + scl_tx_nw_credentials_t.network_security_type = _security; + + ret_val = scl_send_data(SCL_TX_CONNECT, (char*)&scl_tx_nw_credentials_t, TIMER_DEFAULT_VALUE); + + if (ret_val == SCL_SUCCESS) { + SCL_LOG(("wifi provisioning in progress")); + } + + network_parameter.connection_status = NSAPI_STATUS_DISCONNECTED; + + + //Get the network parameter from NP + while ((network_parameter.connection_status != NSAPI_STATUS_GLOBAL_UP) && delay_timeout < NW_CONNECT_TIMEOUT) { + ret_val = scl_get_nw_parameters(&network_parameter); + wait_us(NW_DELAY_TIME); + delay_timeout++; + } + + if (delay_timeout >= NW_CONNECT_TIMEOUT || ret_val != SCL_SUCCESS) { + return NSAPI_ERROR_NO_CONNECTION; + } + + if (!_scl_emac.powered_up) { + _scl_emac.power_up(); + } + + if (!_interface) { + nsapi_error_t err = _stack.add_ethernet_interface(_emac, true, &_interface); + if (err != NSAPI_ERROR_OK) { + _interface = NULL; + return err; + } + _interface->attach(_connection_status_cb); + } + + if (!scl_wifi_is_ready_to_transceive()) { + scl_emac_wifi_link_state_changed(true); + } + + interface_status = _interface->bringup(false, + network_parameter.ip_address, + network_parameter.netmask, + network_parameter.gateway, + DEFAULT_STACK); + + scl_send_data(SCL_TX_CONNECTION_STATUS, (char*)&connection_status, TIMER_DEFAULT_VALUE); + + return interface_status; +} + +void SclSTAInterface::wifi_on() +{ + if (!_scl_emac.powered_up) { + _scl_emac.power_up(); + } +} + +nsapi_error_t SclSTAInterface::disconnect() +{ + scl_result_t ret_val; + nsapi_error_t disconnect_status; + ret_val = scl_send_data(SCL_TX_DISCONNECT, (char*)&disconnect_status, TIMER_DEFAULT_VALUE); + + if (ret_val == SCL_ERROR) { + return NSAPI_ERROR_TIMEOUT; + } + + if (!_interface) { + return NSAPI_STATUS_DISCONNECTED; + } + + // bring down + int err = _interface->bringdown(); + if (err) { + return err; + } + + scl_emac_wifi_link_state_changed(false); + + return NSAPI_ERROR_OK; +} + +int SclSTAInterface::scan(WiFiAccessPoint *res, unsigned count) +{ + /* To Do */ + return NSAPI_ERROR_UNSUPPORTED; +} + +int8_t SclSTAInterface::get_rssi() +{ + int32_t rssi; + scl_result_t res; + + if (!_scl_emac.powered_up) { + _scl_emac.power_up(); + } + + res = (scl_result_t) scl_wifi_get_rssi(&rssi); + if (res == SCL_ERROR) { + return SCL_ERROR; + } + + return (int8_t)rssi; +} + +int SclSTAInterface::is_interface_connected(void) +{ + if (scl_wifi_is_ready_to_transceive() == SCL_SUCCESS) { + return SCL_SUCCESS; + } else { + return SCL_CONNECTION_LOST; + } +} + +int SclSTAInterface::get_bssid(uint8_t *bssid) +{ + scl_mac_t ap_mac; + scl_result_t res = SCL_SUCCESS; + + if (bssid == NULL) { + return SCL_BADARG; + } + + memset(&ap_mac, 0, sizeof(ap_mac)); + if (scl_wifi_is_ready_to_transceive() == SCL_SUCCESS) { + res = (scl_result_t) scl_wifi_get_bssid(&ap_mac); + if (res == SCL_SUCCESS) { + memcpy(bssid, ap_mac.octet, sizeof(ap_mac.octet)); + } + } + else { + return SCL_CONNECTION_LOST; + } + return res; +} + +int SclSTAInterface::wifi_set_up(void) +{ + int res = SCL_SUCCESS; + res = scl_wifi_set_up(); + return res; +} diff --git a/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/SclSTAInterface.h b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/SclSTAInterface.h new file mode 100644 index 0000000000..92511a3458 --- /dev/null +++ b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/SclSTAInterface.h @@ -0,0 +1,183 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +#ifndef SCL_STA_INTERFACE_H +#define SCL_STA_INTERFACE_H + + +/** @file + * Provides SCL interface functions to be used with WiFiInterface or NetworkInterface Objects + */ + +#include "netsocket/WiFiInterface.h" +#include "netsocket/EMACInterface.h" +#include "netsocket/OnboardNetworkStack.h" +#include "scl_emac.h" +#include "scl_wifi_api.h" +#include "scl_types.h" +#define MAX_SSID_LENGTH (33) +#define MAX_PASSWORD_LENGTH (64) + +/** SclSTAInterface class + * Implementation of the NetworkStack for the SCL + */ +class SclSTAInterface : public WiFiInterface, public EMACInterface { +public: + + SclSTAInterface( + SCL_EMAC &emac = SCL_EMAC::get_instance(), + OnboardNetworkStack &stack = OnboardNetworkStack::get_default_instance()); + + /** Get current instance of the SclSTAInterface + * + * @return pointer to the object of class SclSTAInterface + */ + static SclSTAInterface *get_default_instance(); + + /** Turn on the WiFi device + * + * @return void + */ + /* Turn on the wifi device*/ + void wifi_on(); + + /** Start the interface + * + * Attempts to connect to a WiFi network. Requires ssid and passphrase to be set. + * If passphrase is invalid, NSAPI_ERROR_AUTH_ERROR is returned. + * + * @return 0 on success, negative error code on failure + */ + nsapi_error_t connect(); + + /** Start the interface + * + * Attempts to connect to a WiFi network. + * + * @param ssid Name of the network to connect to + * @param pass Security passphrase to connect to the network + * @param security Type of encryption for connection (Default: NSAPI_SECURITY_NONE) + * @param channel This parameter is not supported, setting it to anything else than 0 will result in NSAPI_ERROR_UNSUPPORTED + * @return 0 on success, or error code on failure + */ + nsapi_error_t connect(const char *ssid, const char *pass, nsapi_security_t security = NSAPI_SECURITY_NONE, uint8_t channel = 0); + + /** Stop the interface + * @return 0 on success, negative on failure + */ + nsapi_error_t disconnect(); + + /** Set the WiFi network credentials + * + * @param ssid Name of the network to connect to + * @param pass Security passphrase to connect to the network + * @param security Type of encryption for connection + * (defaults to NSAPI_SECURITY_NONE) + * @return 0 on success, or error code on failure + */ + nsapi_error_t set_credentials(const char *ssid, const char *pass, nsapi_security_t security = NSAPI_SECURITY_NONE); + + /** Set the WiFi network channel - NOT SUPPORTED + * + * This function is not supported and will return NSAPI_ERROR_UNSUPPORTED + * + * @param channel Channel on which the connection is to be made, or 0 for any (Default: 0) + * @return Not supported, returns NSAPI_ERROR_UNSUPPORTED + */ + nsapi_error_t set_channel(uint8_t channel) + { + if (channel != 0) { + return NSAPI_ERROR_UNSUPPORTED; + } + return 0; + } + + /** Set blocking status of interface. + * Nonblocking mode unsupported. + * + * @param blocking true if connect is blocking + * @return 0 on success, negative error code on failure + */ + nsapi_error_t set_blocking(bool blocking) + { + if (blocking) { + _blocking = blocking; + return NSAPI_ERROR_OK; + } else { + return NSAPI_ERROR_UNSUPPORTED; + } + } + /** Gets the current radio signal strength for active connection + * + * @return Connection strength in dBm (negative value) + */ + int8_t get_rssi(); + + /** Scan for available networks + * + * This function will block. + * + * @param ap Pointer to allocated array to store discovered AP + * @param count Size of allocated @a res array, or 0 to only count available AP + * @param timeout Timeout in milliseconds; 0 for no timeout (Default: 0) + * @return Number of entries in @a, or if @a count was 0 number of available networks, negative on error + * see @a nsapi_error + */ + int scan(WiFiAccessPoint *res, unsigned count); + + /** This function is used to know if the device is connected to the network + * @return SCL_SUCCESS if device is connected + */ + int is_interface_connected(); + + /** Get the BSSID (MAC address of device connected to) + * + * @param bssid pointer to the BSSID value + * @return SCL_SUCCESS if BSSID is obtained successfully + * @return SCL_BADARG if input parameter is NULL + * @return SCL_ERROR if unable to fetch BSSID + */ + int get_bssid(uint8_t *bssid); + + /** This function is used to set up the wifi interface after wifi on + * @return SCL_SUCCESS if wifi interface is up successfully + */ + int wifi_set_up(void); + +private: + + char _ssid[MAX_SSID_LENGTH]; /* The longest possible name (defined in 802.11) +1 for the \0 */ + char _pass[MAX_PASSWORD_LENGTH]; /* The longest allowed passphrase + 1 */ + nsapi_security_t _security; + SCL_EMAC &_scl_emac; +}; +#endif diff --git a/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/default_wifi_interface.cpp b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/default_wifi_interface.cpp new file mode 100644 index 0000000000..40f5fca682 --- /dev/null +++ b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/default_wifi_interface.cpp @@ -0,0 +1,39 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +#include "SclSTAInterface.h" + +WiFiInterface *WiFiInterface::get_target_default_instance() +{ + static SclSTAInterface wifi; + return &wifi; +} \ No newline at end of file diff --git a/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/emac_eapol.h b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/emac_eapol.h new file mode 100644 index 0000000000..5b88160a23 --- /dev/null +++ b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/emac_eapol.h @@ -0,0 +1,78 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ +#ifndef INCLUDED_EMAC_EAPOL_H_ +#define INCLUDED_EMAC_EAPOL_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +/****************************************************** + * Macros + ******************************************************/ + +/****************************************************** + * Constants + ******************************************************/ +#define EAPOL_PACKET_TYPE (0x888E) + +/****************************************************** + * Enumerations + ******************************************************/ + +/****************************************************** + * Type Definitions + ******************************************************/ + +typedef scl_buffer_t scl_eapol_packet_t; + +typedef void (*eapol_packet_handler_t)(scl_buffer_t buffer); + +/****************************************************** + * Structures + ******************************************************/ + +/****************************************************** + * Global Variables + ******************************************************/ + +/****************************************************** + * Function Declarations + ******************************************************/ +scl_result_t emac_register_eapol_packet_handler(eapol_packet_handler_t eapol_packet_handler); +void emac_unregister_eapol_packet_handler(void); + +#ifdef __cplusplus +} /* extern "C" */ +#endif +#endif /* ifndef INCLUDED_EMAC_EAPOL_H_ */ diff --git a/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/scl_emac.cpp b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/scl_emac.cpp new file mode 100644 index 0000000000..83f65dfa8a --- /dev/null +++ b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/scl_emac.cpp @@ -0,0 +1,249 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +#include +#include +#include +#include + +#include "cmsis_os.h" +#include "scl_emac.h" +#include "lwip/etharp.h" +#include "lwip/ethip6.h" +#include "mbed_shared_queues.h" +#include "scl_buffer_api.h" +#include "emac_eapol.h" +#include "cy_result.h" +#include "cy_pdl.h" +#include "scl_ipc.h" + +extern "C" +{ + eapol_packet_handler_t emac_eapol_packet_handler = NULL; +} // extern "C" + +SCL_EMAC::SCL_EMAC(scl_interface_role_t role) + : interface_type(role) +{ +} + +SCL_EMAC::SCL_EMAC() + : interface_type(SCL_STA_ROLE) +{ +} + +SCL_EMAC &SCL_EMAC::get_instance() +{ + return get_instance(SCL_STA_ROLE); +} + +SCL_EMAC &SCL_EMAC::get_instance(scl_interface_role_t role) +{ + static SCL_EMAC emac_sta(SCL_STA_ROLE); + static SCL_EMAC emac_ap(SCL_AP_ROLE); + return role == SCL_AP_ROLE ? emac_ap : emac_sta; +} + +uint32_t SCL_EMAC::get_mtu_size() const +{ + return SCL_PAYLOAD_MTU; +} + +uint32_t SCL_EMAC::get_align_preference() const +{ + return 0; +} + +void SCL_EMAC::add_multicast_group(const uint8_t *addr) +{ + memcpy(multicast_addr.octet, addr, sizeof(multicast_addr.octet)); + scl_wifi_register_multicast_address(&multicast_addr); +} + +void SCL_EMAC::remove_multicast_group(const uint8_t *address) +{ + /* To Do */ +} +void SCL_EMAC::set_all_multicast(bool all) +{ + /* No-op at this stage */ +} + +void SCL_EMAC::power_down() +{ + /* No-op at this stage */ +} + +bool SCL_EMAC::power_up() +{ + if (!powered_up) { + if (scl_wifi_on() != true) { + SCL_LOG(("returning false in scl_wifi_on()\n")); + return false; + } + powered_up = true; + if (link_state && emac_link_state_cb) { + emac_link_state_cb(link_state); + } + } + return true; +} + +bool SCL_EMAC::get_hwaddr(uint8_t *addr) const +{ + scl_mac_t mac; + scl_result_t res = scl_wifi_get_mac_address(&mac); + if (res == SCL_SUCCESS) { + memcpy(addr, mac.octet, sizeof(mac.octet)); + return true; + } + else { + SCL_LOG(("return false in SCL_EMAC::gethwaddr\n")); + return false; + } + +} + +void SCL_EMAC::set_hwaddr(const uint8_t *addr) +{ + /* No-op at this stage */ +} + +uint8_t SCL_EMAC::get_hwaddr_size() const +{ + scl_mac_t mac; + return sizeof(mac.octet); +} + +void SCL_EMAC::set_link_input_cb(emac_link_input_cb_t input_cb) +{ + emac_link_input_cb = input_cb; +} + +void SCL_EMAC::set_link_state_cb(emac_link_state_change_cb_t state_cb) +{ + emac_link_state_cb = state_cb; +} + +void SCL_EMAC::set_memory_manager(EMACMemoryManager &mem_mngr) +{ + memory_manager = &mem_mngr; +} + +bool SCL_EMAC::link_out(emac_mem_buf_t *buf) +{ + scl_result_t retval; + scl_tx_buf_t scl_tx_data; + scl_tx_data.size = memory_manager->get_total_len(buf); + scl_tx_data.buffer = buf; + if (buf == NULL) { + return false; + } + retval = scl_network_send_ethernet_data(scl_tx_data); + if (retval != SCL_SUCCESS) { + return false; + } + memory_manager->free(buf); + return true; +} + +void SCL_EMAC::get_ifname(char *name, uint8_t size) const +{ + if (name != NULL) { + memcpy(name, "scl", size); + } +} + +void SCL_EMAC::set_activity_cb(mbed::Callback cb) +{ + activity_cb = cb; +} + +extern "C" +{ + + void emac_receive_eapol_packet(scl_buffer_t buffer) + { + if (buffer != NULL) { + if (emac_eapol_packet_handler != NULL) { + emac_eapol_packet_handler(buffer); + } else { + scl_buffer_release(buffer, SCL_NETWORK_RX); + } + } + } + + scl_result_t emac_register_eapol_packet_handler(eapol_packet_handler_t eapol_packet_handler) + { + + if (emac_eapol_packet_handler == NULL) { + emac_eapol_packet_handler = eapol_packet_handler; + return SCL_SUCCESS; + } + + return SCL_HANDLER_ALREADY_REGISTERED; + } + + void emac_unregister_eapol_packet_handler(void) + { + emac_eapol_packet_handler = NULL; + } + + void scl_network_process_ethernet_data(scl_buffer_t buffer) + { + emac_mem_buf_t *mem_buf = NULL; + + SCL_EMAC &emac = SCL_EMAC::get_instance(SCL_STA_ROLE); + + if (!emac.powered_up && !emac.emac_link_input_cb) { + scl_buffer_release(buffer, SCL_NETWORK_RX); + return; + } + mem_buf = buffer; + if (emac.activity_cb) { + emac.activity_cb(false); + } + emac.emac_link_input_cb(mem_buf); + } + + void scl_emac_wifi_link_state_changed(bool state_up) + { + SCL_EMAC &emac = SCL_EMAC::get_instance(SCL_STA_ROLE); + + emac.link_state = state_up; + if (emac.emac_link_state_cb) { + emac.emac_link_state_cb(state_up); + } + } +} // extern "C" + + diff --git a/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/scl_emac.h b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/scl_emac.h new file mode 100644 index 0000000000..14e5b8f0ba --- /dev/null +++ b/features/netsocket/emac-drivers/TARGET_Cypress/COMPONENT_SCL/interface/scl_emac.h @@ -0,0 +1,189 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +#ifndef SCL_EMAC_H_ +#define SCL_EMAC_H_ + +/** @file + * Provides EMAC interface functions to be used with SCL_EMAC Object + */ +#include "EMAC.h" +#include "EMACInterface.h" +#include "WiFiInterface.h" +#include "scl_common.h" +#include "rtos/Semaphore.h" +#include "rtos/Mutex.h" +#include "scl_wifi_api.h" +class SCL_EMAC : public EMAC { +public: + SCL_EMAC(); + SCL_EMAC(scl_interface_role_t itype); + + static SCL_EMAC &get_instance(); + + static SCL_EMAC &get_instance(scl_interface_role_t role); + + /** + * Return maximum transmission unit + * + * @return MTU in bytes + */ + virtual uint32_t get_mtu_size() const; + + /** + * Gets memory buffer alignment preference + * + * Gets preferred memory buffer alignment of the Emac device. IP stack may or may not + * align link out memory buffer chains using the alignment. + * + * @return Memory alignment requirement in bytes + */ + virtual uint32_t get_align_preference() const; + + /** + * Return interface name + * + * @param name Pointer to where the name should be written + * @param size Maximum number of character to copy + */ + virtual void get_ifname(char *name, uint8_t size) const; + + /** + * Returns size of the underlying interface HW address size. + * + * @return HW address size in bytes + */ + virtual uint8_t get_hwaddr_size() const; + + /** + * Return interface-supplied HW address + * Copies HW address to provided memory + * @param addr HW address for underlying interface, it has to be of correct size see @a get_hwaddr_size + * @return true if HW address is available + */ + virtual bool get_hwaddr(uint8_t *addr) const; + + /** + * Set HW address for interface + * + * Provided address has to be of correct size, see @a get_hwaddr_size + * + * Called to set the MAC address to actually use - if @a get_hwaddr is provided + * the stack would normally use that, but it could be overridden, eg for test + * purposes. + * + * @param addr Address to be set + */ + virtual void set_hwaddr(const uint8_t *addr); + + /** + * Sends the packet over the link + * + * That can not be called from an interrupt context. + * + * @param buf Packet to be send + * @return True if the packet was send successfully, False otherwise + */ + virtual bool link_out(emac_mem_buf_t *buf); + + /** + * Initializes the HW + * + * @return True on success, False in case of an error. + */ + virtual bool power_up(); + + /** + * Deinitializes the HW + * + */ + virtual void power_down(); + + /** + * Sets a callback that needs to be called for packets received for that interface + * + * @param input_cb Function to be register as a callback + */ + virtual void set_link_input_cb(emac_link_input_cb_t input_cb); + + /** + * Sets a callback that needs to be called on link status changes for given interface + * + * @param state_cb Function to be register as a callback + */ + virtual void set_link_state_cb(emac_link_state_change_cb_t state_cb); + + /** Add device to a multicast group + * + * @param address A multicast group hardware address + */ + virtual void add_multicast_group(const uint8_t *address); + + /** Remove device from a multicast group + * + * @param address A multicast group hardware address + */ + virtual void remove_multicast_group(const uint8_t *address); + + /** Request reception of all multicast packets + * + * @param all True to receive all multicasts + * False to receive only multicasts addressed to specified groups + */ + virtual void set_all_multicast(bool all); + + /** Sets memory manager that is used to handle memory buffers + * + * @param mem_mngr Pointer to memory manager + */ + virtual void set_memory_manager(EMACMemoryManager &mem_mngr); + + /** Set callback to receive EMAC activity events + * + * @param activity_cb The callback for activity events + */ + virtual void set_activity_cb(mbed::Callback activity_cb); + + emac_link_input_cb_t emac_link_input_cb = NULL; /* Callback for incoming data */ + emac_link_state_change_cb_t emac_link_state_cb = NULL; + EMACMemoryManager *memory_manager; + bool powered_up = false; + bool link_state = false; + scl_interface_role_t interface_type; + + scl_mac_t multicast_addr; + mbed::Callback activity_cb; + +}; +extern "C" void scl_emac_wifi_link_state_changed(bool state_up); + +#endif /* SCL_EMAC_H_ */ diff --git a/features/netsocket/ppp/mbed_lib.json b/features/netsocket/ppp/mbed_lib.json index 33bdb3df99..a95bfd25bb 100644 --- a/features/netsocket/ppp/mbed_lib.json +++ b/features/netsocket/ppp/mbed_lib.json @@ -47,6 +47,9 @@ }, "CY8CKIT_062S2_43012": { "thread-stacksize": 896 + }, + "CYSBSYSKIT_01": { + "thread-stacksize": 896 } } } diff --git a/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/generated_mac_address.txt b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/generated_mac_address.txt new file mode 100644 index 0000000000..cba1ab8625 --- /dev/null +++ b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/generated_mac_address.txt @@ -0,0 +1,9 @@ +/* + * This file is used to set the MAC address in NVRAM. + * The MAC address of the Wi-Fi device may be configured in OTP and/or in NVRAM. + * If both OTP and NVRAM contains the MAC address then OTP programmed MAC address will be used. + * PSOC boards are usually programmed with OTP MAC address. + * MAC address is printed during SCL power up + */ + +#define NVRAM_GENERATED_MAC_ADDRESS "macaddr=00:A0:50:45:2e:c8" diff --git a/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_common.h b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_common.h new file mode 100644 index 0000000000..81b890bcc0 --- /dev/null +++ b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_common.h @@ -0,0 +1,217 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + + +/** @file scl_common.h + * Defines common data types used with SCL + * + */ + +#include +#include "cy_result.h" + +#ifndef INCLUDED_SCL_COMMON_H_ +#define INCLUDED_SCL_COMMON_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + +/****************************************************** +* Constants +******************************************************/ +#define SCL_LOG_ENABLE false +#define SCL_LOG(x) if (SCL_LOG_ENABLE) \ + { printf x; } +#define CHECK_BUFFER_NULL(buf) if (buf == NULL)\ + { SCL_LOG(("Buffer pointer is null\n")); \ + return SCL_BADARG; } +#define MODULE_BASE_CODE (0x0080U) +/* scl_result_t error code format + * |31-18 (14 bit) for module id|17-16 (2 bit) for result type|15-0 for scl error code| + * eg:- for error code 1026, the result of SCL_RESULT_CREATE is 33555458 + */ +#define SCL_RESULT_TYPE 0 /**< SCL Result type */ +#define SCL_RESULT_CREATE(x) CY_RSLT_CREATE(SCL_RESULT_TYPE, MODULE_BASE_CODE, (x) ) /**< Create a result value from the specified type, module, and result code */ + +#define SCL_SUCCESS (0) +#define SCL_ERROR (100) +#define SCL_PENDING SCL_RESULT_CREATE(1) +#define SCL_TIMEOUT SCL_RESULT_CREATE(2) /**< Timeout */ +#define SCL_BADARG SCL_RESULT_CREATE(5) /**< Bad Arguments */ +#define SCL_UNFINISHED SCL_RESULT_CREATE(10) /**< Operation not finished yet (maybe aborted) */ +#define SCL_PARTIAL_RESULTS SCL_RESULT_CREATE(1003) /**< Partial results */ +#define SCL_INVALID_KEY SCL_RESULT_CREATE(1004) /**< Invalid key */ +#define SCL_DOES_NOT_EXIST SCL_RESULT_CREATE(1005) /**< Does not exist */ +#define SCL_NOT_AUTHENTICATED SCL_RESULT_CREATE(1006) /**< Not authenticated */ +#define SCL_NOT_KEYED SCL_RESULT_CREATE(1007) /**< Not keyed */ +#define SCL_IOCTL_FAIL SCL_RESULT_CREATE(1008) /**< IOCTL fail */ +#define SCL_BUFFER_UNAVAILABLE_TEMPORARY SCL_RESULT_CREATE(1009) /**< Buffer unavailable temporarily */ +#define SCL_BUFFER_UNAVAILABLE_PERMANENT SCL_RESULT_CREATE(1010) /**< Buffer unavailable permanently */ +#define SCL_CONNECTION_LOST SCL_RESULT_CREATE(1012) /**< Connection lost */ +#define SCL_OUT_OF_EVENT_HANDLER_SPACE SCL_RESULT_CREATE(1013) /**< Cannot add extra event handler */ +#define SCL_SEMAPHORE_ERROR SCL_RESULT_CREATE(1014) /**< Error manipulating a semaphore */ +#define SCL_FLOW_CONTROLLED SCL_RESULT_CREATE(1015) /**< Packet retrieval cancelled due to flow control */ +#define SCL_NO_CREDITS SCL_RESULT_CREATE(1016) /**< Packet retrieval cancelled due to lack of bus credits */ +#define SCL_NO_PACKET_TO_SEND SCL_RESULT_CREATE(1017) /**< Packet retrieval cancelled due to no pending packets */ +#define SCL_CORE_CLOCK_NOT_ENABLED SCL_RESULT_CREATE(1018) /**< Core disabled due to no clock */ +#define SCL_CORE_IN_RESET SCL_RESULT_CREATE(1019) /**< Core disabled - in reset */ +#define SCL_UNSUPPORTED SCL_RESULT_CREATE(1020) /**< Unsupported function */ +#define SCL_BUS_WRITE_REGISTER_ERROR SCL_RESULT_CREATE(1021) /**< Error writing to WLAN register */ +#define SCL_SDIO_BUS_UP_FAIL SCL_RESULT_CREATE(1022) /**< SDIO bus failed to come up */ +#define SCL_JOIN_IN_PROGRESS SCL_RESULT_CREATE(1023) /**< Join not finished yet */ +#define SCL_NETWORK_NOT_FOUND SCL_RESULT_CREATE(1024) /**< Specified network was not found */ +#define SCL_INVALID_JOIN_STATUS SCL_RESULT_CREATE(1025) /**< Join status error */ +#define SCL_UNKNOWN_INTERFACE SCL_RESULT_CREATE(1026) /**< Unknown interface specified */ +#define SCL_SDIO_RX_FAIL SCL_RESULT_CREATE(1027) /**< Error during SDIO receive */ +#define SCL_HWTAG_MISMATCH SCL_RESULT_CREATE(1028) /**< Hardware tag header corrupt */ +#define SCL_RX_BUFFER_ALLOC_FAIL SCL_RESULT_CREATE(1029) /**< Failed to allocate a buffer to receive into */ +#define SCL_BUS_READ_REGISTER_ERROR SCL_RESULT_CREATE(1030) /**< Error reading a bus hardware register */ +#define SCL_THREAD_CREATE_FAILED SCL_RESULT_CREATE(1031) /**< Failed to create a new thread */ +#define SCL_QUEUE_ERROR SCL_RESULT_CREATE(1032) /**< Error manipulating a queue */ +#define SCL_BUFFER_POINTER_MOVE_ERROR SCL_RESULT_CREATE(1033) /**< Error moving the current pointer of a packet buffer */ +#define SCL_BUFFER_SIZE_SET_ERROR SCL_RESULT_CREATE(1034) /**< Error setting size of packet buffer */ +#define SCL_THREAD_STACK_NULL SCL_RESULT_CREATE(1035) /**< Null stack pointer passed when non null was reqired */ +#define SCL_THREAD_DELETE_FAIL SCL_RESULT_CREATE(1036) /**< Error deleting a thread */ +#define SCL_SLEEP_ERROR SCL_RESULT_CREATE(1037) /**< Error sleeping a thread */ +#define SCL_BUFFER_ALLOC_FAIL SCL_RESULT_CREATE(1038) /**< Failed to allocate a packet buffer */ +#define SCL_NO_PACKET_TO_RECEIVE SCL_RESULT_CREATE(1039) /**< No Packets waiting to be received */ +#define SCL_INTERFACE_NOT_UP SCL_RESULT_CREATE(1040) /**< Requested interface is not active */ +#define SCL_DELAY_TOO_LONG SCL_RESULT_CREATE(1041) /**< Requested delay is too long */ +#define SCL_INVALID_DUTY_CYCLE SCL_RESULT_CREATE(1042) /**< Duty cycle is outside limit 0 to 100 */ +#define SCL_PMK_WRONG_LENGTH SCL_RESULT_CREATE(1043) /**< Returned pmk was the wrong length */ +#define SCL_UNKNOWN_SECURITY_TYPE SCL_RESULT_CREATE(1044) /**< AP security type was unknown */ +#define SCL_WEP_NOT_ALLOWED SCL_RESULT_CREATE(1045) /**< AP not allowed to use WEP - it is not secure - use Open instead */ +#define SCL_WPA_KEYLEN_BAD SCL_RESULT_CREATE(1046) /**< WPA / WPA2 key length must be between 8 & 64 bytes */ +#define SCL_FILTER_NOT_FOUND SCL_RESULT_CREATE(1047) /**< Specified filter id not found */ +#define SCL_SPI_ID_READ_FAIL SCL_RESULT_CREATE(1048) /**< Failed to read 0xfeedbead SPI id from chip */ +#define SCL_SPI_SIZE_MISMATCH SCL_RESULT_CREATE(1049) /**< Mismatch in sizes between SPI header and SDPCM header */ +#define SCL_ADDRESS_ALREADY_REGISTERED SCL_RESULT_CREATE(1050) /**< Attempt to register a multicast address twice */ +#define SCL_SDIO_RETRIES_EXCEEDED SCL_RESULT_CREATE(1051) /**< SDIO transfer failed too many times. */ +#define SCL_NULL_PTR_ARG SCL_RESULT_CREATE(1052) /**< Null Pointer argument passed to function. */ +#define SCL_THREAD_FINISH_FAIL SCL_RESULT_CREATE(1053) /**< Error deleting a thread */ +#define SCL_WAIT_ABORTED SCL_RESULT_CREATE(1054) /**< Semaphore/mutex wait has been aborted */ +#define SCL_SET_BLOCK_ACK_WINDOW_FAIL SCL_RESULT_CREATE(1055) /**< Failed to set block ack window */ +#define SCL_DELAY_TOO_SHORT SCL_RESULT_CREATE(1056) /**< Requested delay is too short */ +#define SCL_INVALID_INTERFACE SCL_RESULT_CREATE(1057) /**< Invalid interface provided */ +#define SCL_WEP_KEYLEN_BAD SCL_RESULT_CREATE(1058) /**< WEP / WEP_SHARED key length must be 5 or 13 bytes */ +#define SCL_HANDLER_ALREADY_REGISTERED SCL_RESULT_CREATE(1059) /**< EAPOL handler already registered */ +#define SCL_AP_ALREADY_UP SCL_RESULT_CREATE(1060) /**< Soft AP or P2P group owner already up */ +#define SCL_EAPOL_KEY_PACKET_M1_TIMEOUT SCL_RESULT_CREATE(1061) /**< Timeout occurred while waiting for EAPOL packet M1 from AP */ +#define SCL_EAPOL_KEY_PACKET_M3_TIMEOUT SCL_RESULT_CREATE(1062) /**< Timeout occurred while waiting for EAPOL packet M3 from APwhich may indicate incorrect WPA2/WPA passphrase */ +#define SCL_EAPOL_KEY_PACKET_G1_TIMEOUT SCL_RESULT_CREATE(1063) /**< Timeout occurred while waiting for EAPOL packet G1 from AP */ +#define SCL_EAPOL_KEY_FAILURE SCL_RESULT_CREATE(1064) /**< Unknown failure occurred during the EAPOL key handshake */ +#define SCL_MALLOC_FAILURE SCL_RESULT_CREATE(1065) /**< Memory allocation failure */ +#define SCL_ACCESS_POINT_NOT_FOUND SCL_RESULT_CREATE(1066) /**< Access point not found */ +#define SCL_RTOS_ERROR SCL_RESULT_CREATE(1067) /**< RTOS operation failed */ +#define SCL_CLM_BLOB_DLOAD_ERROR SCL_RESULT_CREATE(1068) /**< CLM blob download failed */ +#define SCL_HAL_ERROR SCL_RESULT_CREATE(1069) /**< SCL HAL Error */ +#define SCL_RTOS_STATIC_MEM_LIMIT SCL_RESULT_CREATE(1070) /**< Exceeding the RTOS static objects memory */ + +/* Below constants are used to allocate the buffer pool by the application */ + +#define BDC_HEADER_WITH_PAD 6 /**< BDC Header with padding 4 + 2 */ + +/** + * The maximum size in bytes of the data part of an Ethernet frame + */ +#define SCL_PAYLOAD_MTU (1500) + +/****************************************************** +* Type Definitions +******************************************************/ + +typedef void *scl_buffer_t; + +typedef uint32_t scl_result_t; + +/****************************************************** +* Structures and Enumerations +******************************************************/ + + + +typedef enum +{ + SCL_FALSE = 0, + SCL_TRUE = 1 +} scl_bool_t; + +typedef enum +{ + SCL_INVALID_ROLE = 0, + SCL_STA_ROLE = 1, /**< STA or Client Interface */ + SCL_AP_ROLE = 2, /**< softAP Interface */ + SCL_P2P_ROLE = 3 /**< P2P Interface */ +} scl_interface_role_t; + +typedef enum +{ + SCL_RX_DATA = 0, + SCL_RX_TEST_MSG = 1, + SCL_RX_GET_BUFFER = 2, + SCL_RX_GET_CONNECTION_STATUS = 3 +} scl_ipc_rx_t; + +typedef enum +{ + SCL_TX_TEST_MSG = 1, + SCL_TX_WIFI_INIT = 2, + SCL_TX_CONFIG_PARAMETERS = 3, + SCL_TX_GET_MAC = 4, + SCL_TX_REGISTER_MULTICAST_ADDRESS = 5, + SCL_TX_SEND_OUT = 6, + SCL_TX_TRANSCEIVE_READY = 7, + SCL_TX_WIFI_ON = 8, + SCL_TX_WIFI_SET_UP = 9, + SCL_TX_WIFI_NW_PARAM = 10, + SCL_TX_WIFI_GET_RSSI = 11, + SCL_TX_WIFI_GET_BSSID = 12, + SCL_TX_CONNECT = 13, + SCL_TX_DISCONNECT = 14, + SCL_TX_CONNECTION_STATUS = 15 +} scl_ipc_tx_t; + + +/** + * Structure for storing a MAC address (Wi-Fi Media Access Control address). + */ +typedef struct +{ + uint8_t octet[6]; /**< Unique 6-byte MAC address */ +} scl_mac_t; + +#ifdef __cplusplus +} /* extern "C" */ +#endif +#endif /* ifndef INCLUDED_SCL_COMMON_H_ */ \ No newline at end of file diff --git a/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_ipc.h b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_ipc.h new file mode 100644 index 0000000000..c11dce81a3 --- /dev/null +++ b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_ipc.h @@ -0,0 +1,113 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +/** @file + * Provides SCL Functionality to communicate with WiFi Chip + */ + +#include "scl_common.h" +#include "cy_device.h" +#include "cy_sysint.h" +#include "cy_ipc_drv.h" +#include "scl_wifi_api.h" +#include "ip4_addr.h" + +#ifndef INCLUDED_SCL_IPC_H +#define INCLUDED_SCL_IPC_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +/****************************************************** + * Macros + ******************************************************/ +#define REG_IPC_STRUCT_DATA0(base) (((IPC_STRUCT_V2_Type*)(base))->DATA0) +#define TIMER_DEFAULT_VALUE (100) +#define WIFI_ON_TIMEOUT (5000) +#define NW_CONNECT_TIMEOUT (30) +#define NW_DISCONNECT_TIMEOUT (60000) +#define NW_DELAY_TIME (3000000) +/****************************************************** +* Variables +******************************************************/ +extern struct network_params_t network_params; +/****************************************************** +* Function declarations +******************************************************/ + +/** @addtogroup communication SCL communication API + * APIs for communicating with NP + * @{ + */ + +/** + * Initializes the SCL Thread and necessary artifacts + * + * @return SCL_SUCCESS on successful intialization + * SCL_ERROR otherwise + */ +extern scl_result_t scl_init(void); + +/** + * Send the SCL data and respective command to NP + * @param index Index of the command + * @param buffer Data to be sent + * @param timeout Wait time for IPC to be released by NP + * + * @return SCL_SUCCESS on successful communication within given time + * SCL_ERROR on Timeout + */ +extern scl_result_t scl_send_data(int index, char *buffer, uint32_t timeout); + +/** + * Terminate the SCL Thread and disable the interrupts + * + * @return SCL_SUCCESS on successful communication within given time + * SCL_ERROR on Timeout + */ +extern scl_result_t scl_end(void); + +/** + * Get the network parameters like IP Address, Netmask and Gateway from NP + * @param network_params_t structure pointer + * @return SCL_SUCCESS on successful communication within given time + * SCL_ERROR on Timeout + */ +extern scl_result_t scl_get_nw_parameters(struct network_params_t *nw_param); + +#ifdef __cplusplus +} /* extern "C" */ +#endif +#endif /* ifndef INCLUDED_SCL_IPC_H */ + diff --git a/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_types.h b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_types.h new file mode 100644 index 0000000000..9afc7952a8 --- /dev/null +++ b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_types.h @@ -0,0 +1,132 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +/** @file scl_types.h + * Defines common data types used with SCL + * + */ + +#include +#include "cy_result.h" + +#ifndef INCLUDED_SCL_TYPES_H_ +#define INCLUDED_SCL_TYPES_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif +/****************************************************** +* Macros +******************************************************/ +#define SSID_NAME_SIZE (32) /**< SSID Length */ + +#define WEP_ENABLED 0x0001 /**< Flag to enable WEP Security */ +#define TKIP_ENABLED 0x0002 /**< Flag to enable TKIP Encryption */ +#define AES_ENABLED 0x0004 /**< Flag to enable AES Encryption */ +#define SHARED_ENABLED 0x00008000 /**< Flag to enable Shared key Security */ +#define WPA_SECURITY 0x00200000 /**< Flag to enable WPA Security */ +#define WPA2_SECURITY 0x00400000 /**< Flag to enable WPA2 Security */ +#define WPA3_SECURITY 0x01000000 /**< Flag to enable WPA3 PSK Security */ + +#define ENTERPRISE_ENABLED 0x02000000 /**< Flag to enable Enterprise Security */ +#define WPS_ENABLED 0x10000000 /**< Flag to enable WPS Security */ +#define IBSS_ENABLED 0x20000000 /**< Flag to enable IBSS mode */ +#define FBT_ENABLED 0x40000000 /**< Flag to enable FBT */ + +#define NO_POWERSAVE_MODE (0) /**< No Powersave mode */ +#define PM1_POWERSAVE_MODE (1) /**< Powersave mode on specified interface without regard for throughput reduction */ +#define PM2_POWERSAVE_MODE (2) /**< Powersave mode on specified interface with High throughput */ + +/** + * Suppress unused parameter warning + */ +#define UNUSED_PARAMETER(x) ( (void)(x) ) + +/** + * Suppress unused variable warning + */ +#define UNUSED_VARIABLE(x) ( (void)(x) ) + +/** + * Suppress unused variable warning occurring due to an assert which is disabled in release mode + */ +#define REFERENCE_DEBUG_ONLY_VARIABLE(x) ( (void)(x) ) + +/****************************************************** +* Constants +******************************************************/ + +/****************************************************** +* Structures and Enumerations +******************************************************/ + +/** + * Enumeration of Wi-Fi security modes + */ +typedef enum +{ + SCL_SECURITY_OPEN = 0, /**< Open security */ + SCL_SECURITY_WEP_PSK = WEP_ENABLED, /**< WEP PSK Security with open authentication */ + SCL_SECURITY_WEP_SHARED = (WEP_ENABLED | SHARED_ENABLED), /**< WEP PSK Security with shared authentication */ + SCL_SECURITY_WPA_TKIP_PSK = (WPA_SECURITY | TKIP_ENABLED), /**< WPA PSK Security with TKIP */ + SCL_SECURITY_WPA_AES_PSK = (WPA_SECURITY | AES_ENABLED), /**< WPA PSK Security with AES */ + SCL_SECURITY_WPA_MIXED_PSK = (WPA_SECURITY | AES_ENABLED | TKIP_ENABLED), /**< WPA PSK Security with AES & TKIP */ + SCL_SECURITY_WPA2_AES_PSK = (WPA2_SECURITY | AES_ENABLED), /**< WPA2 PSK Security with AES */ + SCL_SECURITY_WPA2_TKIP_PSK = (WPA2_SECURITY | TKIP_ENABLED), /**< WPA2 PSK Security with TKIP */ + SCL_SECURITY_WPA2_MIXED_PSK = (WPA2_SECURITY | AES_ENABLED | TKIP_ENABLED), /**< WPA2 PSK Security with AES & TKIP */ + SCL_SECURITY_WPA2_FBT_PSK = (WPA2_SECURITY | AES_ENABLED | FBT_ENABLED), /**< WPA2 FBT PSK Security with AES & TKIP */ + SCL_SECURITY_WPA3_SAE = (WPA3_SECURITY | AES_ENABLED), /**< WPA3 Security with AES */ + SCL_SECURITY_WPA3_WPA2_PSK = (WPA3_SECURITY | WPA2_SECURITY | AES_ENABLED), /**< WPA3 WPA2 PSK Security with AES */ + + SCL_SECURITY_WPA_TKIP_ENT = (ENTERPRISE_ENABLED | WPA_SECURITY | TKIP_ENABLED), /**< WPA Enterprise Security with TKIP */ + SCL_SECURITY_WPA_AES_ENT = (ENTERPRISE_ENABLED | WPA_SECURITY | AES_ENABLED), /**< WPA Enterprise Security with AES */ + SCL_SECURITY_WPA_MIXED_ENT = (ENTERPRISE_ENABLED | WPA_SECURITY | AES_ENABLED | TKIP_ENABLED), /**< WPA Enterprise Security with AES & TKIP */ + SCL_SECURITY_WPA2_TKIP_ENT = (ENTERPRISE_ENABLED | WPA2_SECURITY | TKIP_ENABLED), /**< WPA2 Enterprise Security with TKIP */ + SCL_SECURITY_WPA2_AES_ENT = (ENTERPRISE_ENABLED | WPA2_SECURITY | AES_ENABLED), /**< WPA2 Enterprise Security with AES */ + SCL_SECURITY_WPA2_MIXED_ENT = (ENTERPRISE_ENABLED | WPA2_SECURITY | AES_ENABLED | TKIP_ENABLED), /**< WPA2 Enterprise Security with AES & TKIP */ + SCL_SECURITY_WPA2_FBT_ENT = (ENTERPRISE_ENABLED | WPA2_SECURITY | AES_ENABLED | FBT_ENABLED), /**< WPA2 Enterprise Security with AES & FBT */ + + SCL_SECURITY_IBSS_OPEN = (IBSS_ENABLED), /**< Open security on IBSS ad-hoc network */ + SCL_SECURITY_WPS_OPEN = (WPS_ENABLED), /**< WPS with open security */ + SCL_SECURITY_WPS_SECURE = (WPS_ENABLED | AES_ENABLED), /**< WPS with AES security */ + + SCL_SECURITY_UNKNOWN = -1, /**< May be returned by scan function if security is unknown. Do not pass this to the join function! */ + + SCL_SECURITY_FORCE_32_BIT = 0x7fffffff /**< Exists only to force scl_security_t type to 32 bits */ +} scl_security_t; + +#ifdef __cplusplus +} /* extern "C" */ +#endif +#endif /* ifndef INCLUDED_SCL_TYPES_H_ */ + diff --git a/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_wifi_api.h b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_wifi_api.h new file mode 100644 index 0000000000..f1a67dbd6e --- /dev/null +++ b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/inc/scl_wifi_api.h @@ -0,0 +1,168 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +/** @file + * Prototypes of functions for controlling the Wi-Fi system + * + * This file provides prototypes for end-user functions which allow + * actions such as scanning for Wi-Fi networks, joining Wi-Fi + * networks, getting the MAC address, etc + * + */ + +#include +#include "scl_common.h" +#ifndef INCLUDED_SCL_WIFI_API_H +#define INCLUDED_SCL_WIFI_API_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef struct scl_tx_buf{ + scl_buffer_t buffer; + uint32_t size; +}scl_tx_buf_t; + +/****************************************************** +* Function declarations +******************************************************/ + +/** @addtogroup wifi SCL Wi-Fi API + * APIs for controlling the Wi-Fi system + * @{ + */ + +/** @addtogroup wifimanagement SCL Wi-Fi Management API + * @ingroup wifi + * Initialisation and other management functions for SCL system + * @{ + */ + +/** + * Turn on the Wi-Fi device + * + * Initialise Wi-Fi platform + * Program various WiFi parameters and modes + * This API should be called before using any scl_wifi_api's + * @return true if initialization is successful, false otherwise + */ +extern bool scl_wifi_on(void); + +/** Brings up the Wi-Fi core + * + * @return SCL_SUCCESS or Error code + */ +extern scl_result_t scl_wifi_set_up(void); + +/** Retrieves the current Media Access Control (MAC) address + * (or Ethernet hardware address) of the 802.11 device + * + * @param mac Pointer to a variable that the current MAC address will be written to + * + * @return SCL_SUCCESS or Error code + */ +extern scl_result_t scl_wifi_get_mac_address(scl_mac_t *mac); + +/** Get the BSSID of the interface + * This API should be used after the device is connected to a network + * @param bssid Returns the BSSID address (mac address) if associated + * + * @return SCL_SUCCESS or Error code + */ +extern scl_result_t scl_wifi_get_bssid(scl_mac_t *bssid); + +/** Registers interest in a multicast address + * + * Once a multicast address has been registered, all packets detected on the + * medium destined for that address are forwarded to the host. + * Otherwise they are ignored. + * + * @param mac Ethernet MAC address + * + * @return SCL_SUCCESS if the address was registered successfully + * Error code if the address was not registered + */ +extern scl_result_t scl_wifi_register_multicast_address(scl_mac_t *mac); + +/** Determines if a particular interface is ready to transceive ethernet packets + * This function has to be called after the connection is established otherwise it returns error code + * + * @return SCL_SUCCESS if the interface is ready to transceive ethernet packets + * SCL_NOTFOUND no AP with a matching SSID was found + * SCL_NOT_AUTHENTICATED Matching AP was found but it won't let you authenticate. + * This can occur if this device is in the block list on the AP. + * SCL_NOT_KEYED Device has authenticated and associated but has not completed the key exchange. + * This can occur if the passphrase is incorrect. + * Error code if the interface is not ready to transceive ethernet packets + */ +extern scl_result_t scl_wifi_is_ready_to_transceive(void); + +/** To send an ethernet frame to SCL (called by the Network Stack) + * + * This function takes ethernet data from the network stack and transmits over the wireless network. + * This function returns immediately after the packet has been queued for transmit, + * NOT after it has been transmitted. Packet buffers passed to the SCL + * are released inside the SCL once they have been transmitted. + * + * @param buffer Handle of the packet buffer to be sent. + * + * @return SCL_SUCCESS or Error code + * + */ +extern scl_result_t scl_network_send_ethernet_data(scl_tx_buf_t buffer); + +/** Retrieve the latest RSSI value + * This API has to be called after the device is connected to a network + * @param rssi The location where the RSSI value will be stored + * + * @return SCL_SUCCESS if the RSSI was successfully retrieved + * Error code if the RSSI was not retrieved + */ +extern scl_result_t scl_wifi_get_rssi(int32_t *rssi); + +/** Retrieve the RX data packet + * + * @param pointer to rx buffer + * + * @return void + * + */ +extern void scl_network_process_ethernet_data(scl_buffer_t buffer); +extern void scl_emac_wifi_link_state_changed(bool state_up); + +#ifdef __cplusplus +} /* extern "C" */ +#endif +#endif /* ifndef INCLUDED_SCL_WIFI_API_H */ + diff --git a/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/IPC/scl_ipc.c b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/IPC/scl_ipc.c new file mode 100644 index 0000000000..f0464f6f31 --- /dev/null +++ b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/IPC/scl_ipc.c @@ -0,0 +1,399 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + + +/** @file + * Provides SCL Functionality to communicate with WiFi Chip + */ +#include "scl_ipc.h" +#include "scl_buffer_api.h" +#include "cyabs_rtos.h" +#include "mbed_wait_api.h" +#include "string.h" +#include "nsapi_types.h" +/****************************************************** + ** Macros + *******************************************************/ +#define SCL_THREAD_STACK_SIZE (1000) +#define SCL_THREAD_PRIORITY (CY_RTOS_PRIORITY_HIGH) +#define SCL_INTR_SRC (cpuss_interrupts_ipc_4_IRQn) +#define SCL_INTR_PRI (1) +#define SCL_RX_CHANNEL (4) +#define SCL_CHANNEL_NOTIFY_INTR ((1 << SCL_RX_CHANNEL) << 16) +#define SCL_NOTIFY (1 << SCL_TX_CHANNEL) +#define SCL_LOCK_ACQUIRE_STATUS (0x80000000) +#define SCL_TX_CHANNEL (3) +#define SCL_RELEASE (0) +#define DELAY_TIME (1000) +#define SEMAPHORE_MAXCOUNT (1) +#define SEMAPHORE_INITCOUNT (0) +/****************************************************** + ** Function Declarations + *******************************************************/ +static void scl_isr(void); +static void scl_config(void); +static void scl_rx_handler(void); +static scl_result_t scl_thread_init(void); +scl_result_t scl_get_nw_parameters(struct network_params_t *nw_param); +scl_result_t scl_send_data(int index, char *buffer, uint32_t timeout); +scl_result_t scl_end(void); +scl_result_t scl_init(void); +/****************************************************** + * Variables Definitions + *****************************************************/ +/* Structure of scl thread info + * scl_thread_quit_flag: flag used to determine if thread is to be quit + * scl_inited: flag used to determine if thread is started + * scl_thread: variable for thread handle + * scl_thread_stack_start: pointer to start of thread stack + * scl_thread_stack_size: size of thread stack + * scl_thread_priority: priority of thread + * scl_rx_ready: semaphore for blocking the thread + */ +struct scl_thread_info_t { + volatile scl_bool_t scl_inited; + volatile scl_bool_t scl_thread_quit_flag; + void *scl_thread_stack_start; + cy_thread_t scl_thread; + cy_semaphore_t scl_rx_ready; + uint32_t scl_thread_stack_size; + cy_thread_priority_t scl_thread_priority; +}; +struct scl_thread_info_t g_scl_thread_info; + +/****************************************************** + * Function Definitions + ******************************************************/ +/******************************************************************************* + * Function Name: scl_isr + ******************************************************************************** + * Summary: + * 1. ISR for the recevier channel interrupt + * + * Parameters: + * + * Return: + * + *******************************************************************************/ +static void scl_isr(void) +{ + IPC_INTR_STRUCT_Type *scl_rx_intr = NULL; + scl_rx_intr = Cy_IPC_Drv_GetIntrBaseAddr(SCL_RX_CHANNEL); + + if (REG_IPC_INTR_STRUCT_INTR_MASKED(scl_rx_intr) & SCL_CHANNEL_NOTIFY_INTR) { + REG_IPC_INTR_STRUCT_INTR(scl_rx_intr) |= SCL_CHANNEL_NOTIFY_INTR; + if (g_scl_thread_info.scl_inited == SCL_TRUE) { + cy_rtos_set_semaphore(&g_scl_thread_info.scl_rx_ready, true); + } + } +} + +/******************************************************************************* + * Function Name: scl_config + ******************************************************************************** + * Summary: + * 1. Configuring the interrupt channel + * + * Parameters: + * + * Return: + * + *******************************************************************************/ +static void scl_config(void) +{ + IPC_INTR_STRUCT_Type *scl_rx_intr = NULL; + cy_stc_sysint_t intrCfg = + { + .intrSrc = SCL_INTR_SRC, + .intrPriority = SCL_INTR_PRI + }; + + scl_rx_intr = Cy_IPC_Drv_GetIntrBaseAddr(SCL_RX_CHANNEL); + REG_IPC_INTR_STRUCT_INTR_MASK(scl_rx_intr) |= SCL_CHANNEL_NOTIFY_INTR; + Cy_SysInt_Init(&intrCfg, &scl_isr); + NVIC_EnableIRQ(intrCfg.intrSrc); +} + +/******************************************************************************* + * Function Name: scl_thread_init + ******************************************************************************** + * Summary: + * 1. Intialises the scl_rx_handler thread and semaphores + * + * Parameters: + * + * Return: + * SCL_SUCCESS - On successful initialization of thread + * SCL_ERROR - An error occurred during intialization of thread + *******************************************************************************/ +static scl_result_t scl_thread_init(void) +{ + cy_rslt_t retval,tmp = 0; + memset(&g_scl_thread_info, 0, sizeof(g_scl_thread_info)); + g_scl_thread_info.scl_thread_stack_start = (uint8_t*) malloc (SCL_THREAD_STACK_SIZE);; + g_scl_thread_info.scl_thread_stack_size = (uint32_t) SCL_THREAD_STACK_SIZE; + g_scl_thread_info.scl_thread_priority = (cy_thread_priority_t) SCL_THREAD_PRIORITY; + + if (g_scl_thread_info.scl_inited != SCL_TRUE) { + retval = cy_rtos_init_semaphore(&g_scl_thread_info.scl_rx_ready, SEMAPHORE_MAXCOUNT, SEMAPHORE_INITCOUNT); + if (retval != SCL_SUCCESS) { + return SCL_ERROR; + } + retval = cy_rtos_create_thread(&g_scl_thread_info.scl_thread, (cy_thread_entry_fn_t) scl_rx_handler, + "SCL_thread", g_scl_thread_info.scl_thread_stack_start, + g_scl_thread_info.scl_thread_stack_size, + g_scl_thread_info.scl_thread_priority,(uint32_t) tmp); + if (retval != SCL_SUCCESS) { + return SCL_ERROR; + } + g_scl_thread_info.scl_inited = SCL_TRUE; + } + else { + return SCL_ERROR; + } + return SCL_SUCCESS; +} + +/******************************************************************************* + * Function Name: scl_init + ******************************************************************************** + * Summary: + * 1. Intializing the scl thread and interrupts + * + * Parameters: + * + * Return: + * SCL_SUCCESS - On successful initialization + * SCL_ERROR - An error occured during intialization + *******************************************************************************/ +scl_result_t scl_init(void) +{ + scl_result_t retval = SCL_SUCCESS; + uint32_t configuration_parameters = 0; + + configuration_parameters = MBED_CONF_TARGET_NP_CLOUD_DISABLE; + configuration_parameters = configuration_parameters << 1; + configuration_parameters |= MBED_CONF_TARGET_NP_WIFI_ENABLE; + //SCL_LOG("configuration_parameters = %lu\n", configuration_parameters); + scl_config(); + if (g_scl_thread_info.scl_inited != SCL_TRUE) { + retval = scl_thread_init(); + if (retval != SCL_SUCCESS) { + SCL_LOG(("Thread init failed\n")); + return SCL_ERROR; + } + else { + retval = scl_send_data(SCL_TX_CONFIG_PARAMETERS, (char*) &configuration_parameters ,TIMER_DEFAULT_VALUE); + return retval; + } + } + return SCL_SUCCESS; +} + +/******************************************************************************* + * Function Name: scl_send_data + ******************************************************************************** + * Summary: + * 1. send the data + * + * Parameters: + * index - integer value to indicate which API is using scl + * buffer - pointer to buffer to be transferred + * timeout (in ms) - The time to wait for the IPC to be released + * Return: + * SCL_SUCCESS - On successful transfer of data + * SCL_ERROR - An error occured while transmitting data + *******************************************************************************/ +scl_result_t scl_send_data(int index, char* buffer, uint32_t timeout) +{ + uint32_t acquire_state; + IPC_STRUCT_Type *scl_send = NULL; + uint32_t delay_timeout; + + SCL_LOG(("scl_send_data index = %d\n",index)); + scl_send = Cy_IPC_Drv_GetIpcBaseAddress(SCL_TX_CHANNEL); + CHECK_BUFFER_NULL(buffer); + if (!(REG_IPC_STRUCT_LOCK_STATUS(scl_send) & SCL_LOCK_ACQUIRE_STATUS)) { + acquire_state = REG_IPC_STRUCT_ACQUIRE(scl_send); + if (!(acquire_state & SCL_LOCK_ACQUIRE_STATUS)) { + SCL_LOG(("IPC Channel 3 Acquired Failed\r\n")); + return SCL_ERROR; + } + REG_IPC_STRUCT_DATA0(scl_send) = index; + REG_IPC_STRUCT_DATA1(scl_send) = (uint32_t) buffer; + REG_IPC_STRUCT_NOTIFY(scl_send) = SCL_NOTIFY; + delay_timeout = 0; + while ((REG_IPC_STRUCT_LOCK_STATUS(scl_send) & SCL_LOCK_ACQUIRE_STATUS) && delay_timeout <= timeout) { + wait_us(DELAY_TIME); + delay_timeout++; + } + if (delay_timeout > timeout) { + REG_IPC_STRUCT_RELEASE(scl_send) = SCL_RELEASE; + delay_timeout = 0; + return SCL_ERROR; + } + else { + return SCL_SUCCESS; + } + } + else { + SCL_LOG(("unable to acquire lock\n")); + return SCL_ERROR; + } +} + +/******************************************************************************* + * Function Name: scl_end + ******************************************************************************** + * Summary: + * 1. API to stop the SCL + * + * Parameters: + * + * Return: + * SCL_SUCCESS - If channel is not locked + * SCL_ERROR - If the channel is locked + *******************************************************************************/ +scl_result_t scl_end(void) +{ + scl_result_t retval = SCL_ERROR; + if (g_scl_thread_info.scl_inited == SCL_TRUE) { + retval = (scl_result_t) cy_rtos_terminate_thread(&g_scl_thread_info.scl_thread); + if (retval == SCL_SUCCESS) { + retval = (scl_result_t) cy_rtos_join_thread(&g_scl_thread_info.scl_thread); + if (retval == SCL_SUCCESS) { + retval = (scl_result_t) cy_rtos_deinit_semaphore(&g_scl_thread_info.scl_rx_ready); + if (retval == SCL_SUCCESS) { + g_scl_thread_info.scl_inited = SCL_FALSE; + } + } + } + } + return retval; +} + +/******************************************************************************* + * Function Name: scl_rx_handler + ******************************************************************************** + * Summary: + * 1. Thread to handle recevied buffer + * + * Parameters: + * + * Return: + * + *******************************************************************************/ +static void scl_rx_handler(void) +{ + char *buffer = NULL; + nsapi_connection_status_t connection_status; + uint32_t index; + IPC_STRUCT_Type *scl_receive = NULL; + scl_buffer_t cp_buffer; + scl_buffer_t scl_buffer; + uint32_t rx_ipc_size; + struct rx_ipc_info { + uint32_t size; + int* buf_alloc; + }*rx_cp = NULL; + + SCL_LOG(("Starting CP Rx thread\r\n")); + scl_receive = Cy_IPC_Drv_GetIpcBaseAddress(SCL_RX_CHANNEL); + + while (SCL_TRUE) { + cy_rtos_get_semaphore(&g_scl_thread_info.scl_rx_ready, CY_RTOS_NEVER_TIMEOUT, SCL_FALSE); + index = (uint32_t)REG_IPC_STRUCT_DATA0(scl_receive); + SCL_LOG(("scl_rx_handler index = %lu\n", index)); + switch (index) { + case SCL_RX_DATA: + { + rx_cp = (struct rx_ipc_info*) REG_IPC_STRUCT_DATA1(scl_receive); + scl_buffer = rx_cp->buf_alloc; + REG_IPC_STRUCT_RELEASE(scl_receive) = SCL_RELEASE; + SCL_LOG(("scl_buffer = %p\n",scl_buffer)); + scl_network_process_ethernet_data(scl_buffer); + break; + } + case SCL_RX_TEST_MSG: + { + buffer = (char*) REG_IPC_STRUCT_DATA1(scl_receive); + SCL_LOG(("%s\r\n", (char*) buffer)); + REG_IPC_STRUCT_RELEASE(scl_receive) = SCL_RELEASE; + break; + } + case SCL_RX_GET_BUFFER: + { + rx_ipc_size = (uint32_t) REG_IPC_STRUCT_DATA1(scl_receive); + scl_host_buffer_get(&cp_buffer, SCL_NETWORK_RX, rx_ipc_size, SCL_FALSE ); + REG_IPC_STRUCT_DATA1(scl_receive) = (uint32_t)cp_buffer; + REG_IPC_STRUCT_RELEASE(scl_receive) = SCL_RELEASE; + break; + } + case SCL_RX_GET_CONNECTION_STATUS: + { + connection_status = (nsapi_connection_status_t) REG_IPC_STRUCT_DATA1(scl_receive); + if (connection_status == NSAPI_STATUS_GLOBAL_UP) { + scl_emac_wifi_link_state_changed(true); + } + else { + scl_emac_wifi_link_state_changed(false); + } + SCL_LOG(("connection status = %d\n",connection_status)); + break; + } + default: + { + SCL_LOG(("incorrect IPC from NP\n")); + REG_IPC_STRUCT_RELEASE(scl_receive) = SCL_RELEASE; + break; + } + } + } +} + +/******************************************************************************* + * Function Name: scl_get_nw_parameters + ******************************************************************************** + * Summary: + * Function to get the network parameter from NP + * + * Parameters: + * + * Return: + * + *******************************************************************************/ +scl_result_t scl_get_nw_parameters(struct network_params_t *nw_param) +{ + scl_result_t status; + status = scl_send_data(SCL_TX_WIFI_NW_PARAM, (char*)nw_param, TIMER_DEFAULT_VALUE); + return status; +} diff --git a/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/include/scl_buffer_api.h b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/include/scl_buffer_api.h new file mode 100644 index 0000000000..05f75ab133 --- /dev/null +++ b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/include/scl_buffer_api.h @@ -0,0 +1,143 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +/** @file + * Provides prototypes / declarations for common APSTA functionality + */ +#ifndef _SCL_INTERNAL_BUFFER_API_H_ +#define _SCL_INTERNAL_BUFFER_API_H_ + +#include "scl_types.h" +#include "scl_common.h" +#include +#include "cy_utils.h" +#include "memp.h" +#include "pbuf.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + +/****************************************************** +* Constants +******************************************************/ +#define SDIO_BLOCK_SIZE (64U) + +/****************************************************** +* Macros +******************************************************/ + +/****************************************************** +* Structures & enums +******************************************************/ +/** + * Indicates transmit/receive direction that the packet buffer has + * been used for. This is needed if tx/rx pools are separate. + */ +typedef enum +{ + SCL_NETWORK_TX = 0, /**< Transmit direction */ + SCL_NETWORK_RX = 1 /**< Recieve direction */ +} scl_buffer_dir_t; + +/****************************************************** +* Function prototypes +******************************************************/ +/** Allocates a packet buffer + * Attempts to allocate a packet buffer of the size requested. It can do this + * by allocating a pre-existing packet from a pool, using a static buffer, + * or by dynamically allocating memory. + * + * @param buffer : A pointer which receives the allocated packet buffer handle + * @param direction : Indicates transmit/receive direction that the packet buffer is + * used for. This may be needed if tx/rx pools are separate. + * @param size : The number of bytes to allocate. + * @param wait : Whether to wait for a packet buffer to be available + * + * @return : SCL_SUCCESS or error code + * + */ +scl_result_t scl_host_buffer_get(scl_buffer_t *buffer, scl_buffer_dir_t direction, + uint16_t size, uint32_t wait); + +/** Releases a packet buffer + * + * Implemented in the port layer interface, which will be specific to the + * buffering scheme in use. + * This function is used by SCL to indicate that it no longer requires + * a packet buffer. The buffer can then be released back into a pool for + * reuse, or the dynamically allocated memory can be freed, according to + * how the packet was allocated. + * Returns void since SCL cannot do anything about failures + * + * @param buffer : The handle of the packet buffer to be released + * @param direction : Indicates transmit/receive direction that the packet buffer has + * been used for. This might be needed if tx/rx pools are separate. + * + */ +void scl_buffer_release(scl_buffer_t buffer, scl_buffer_dir_t direction); + +/** Retrieves the current pointer of a packet buffer + * + * Implemented in the port layer interface which is specific to the + * buffering scheme in use. + * Since packet buffers usually need to be created with space at the + * front for additional headers, this function allows SCL to get + * the current 'front' location pointer. + * + * @param buffer : The handle of the packet buffer whose pointer is to be retrieved + * + * @return : The packet buffer's current pointer. + */ +uint8_t *scl_buffer_get_current_piece_data_pointer(scl_buffer_t buffer); + +/** Retrieves the size of a packet buffer + * + * Implemented in the port layer interface which is specific to the + * buffering scheme in use. + * Since packet buffers usually need to be created with space at the + * front for additional headers, the memory block used to contain a packet buffer + * will often be larger than the current size of the packet buffer data. + * This function allows SCL to retrieve the current size of a packet buffer's data. + * + * @param buffer : The handle of the packet buffer whose size is to be retrieved + * + * @return : The size of the packet buffer. + */ +uint16_t scl_buffer_get_current_piece_size(scl_buffer_t buffer); +#ifdef __cplusplus +} /*extern "C" */ +#endif + +#endif /* ifndef _SCL_INTERNAL_BUFFER_API_H_ */ + diff --git a/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/scl_buffer_api.c b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/scl_buffer_api.c new file mode 100644 index 0000000000..7f1dd3d49c --- /dev/null +++ b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/scl_buffer_api.c @@ -0,0 +1,162 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +#include "scl_buffer_api.h" + +/****************************************************** +** @cond Constants +*******************************************************/ + +/****************************************************** +** Enumerations +*******************************************************/ + +/****************************************************** +** Function Declarations +*******************************************************/ + +/****************************************************** + * Variables Definitions + *****************************************************/ + +/****************************************************** +* Function Definitions +******************************************************/ +/** Allocates a packet buffer + * + * Implemented in the port layer interface which is specific to the + * buffering scheme in use. + * Attempts to allocate a packet buffer of the size requested. It can do this + * by allocating a pre-existing packet from a pool, using a static buffer, + * or by dynamically allocating memory. The method of allocation does not + * concern SCL, however it must match the way the network stack expects packet + * buffers to be allocated. + * + * @param buffer : A pointer which receives the allocated packet buffer handle + * @param direction : Indicates transmit/receive direction that the packet buffer is + * used for. This may be needed if tx/rx pools are separate. + * @param size : The number of bytes to allocate. + * @param wait : Whether to wait for a packet buffer to be available + * + * @return : SCL_SUCCESS or error code + * + */ +scl_result_t scl_host_buffer_get(scl_buffer_t *buffer, scl_buffer_dir_t direction, + uint16_t size, uint32_t wait) +{ + UNUSED_PARAMETER( direction ); + struct pbuf *p = NULL; + if ( ( direction == SCL_NETWORK_TX) && ( size <= PBUF_POOL_BUFSIZE ) ) + { + p = pbuf_alloc(PBUF_RAW, size, PBUF_POOL); + } + else + { + p = pbuf_alloc(PBUF_RAW, size+SDIO_BLOCK_SIZE, PBUF_RAM); + if ( p != NULL ) + { + p->len = size; + p->tot_len -= SDIO_BLOCK_SIZE; + } + } + if (p != NULL ) + { + *buffer = p; + return SCL_SUCCESS; + } + else + { + return SCL_BUFFER_ALLOC_FAIL; + } + +} + +/** Releases a packet buffer + * + * Implemented in the port layer interface, which will be specific to the + * buffering scheme in use. + * This function is used by SCL to indicate that it no longer requires + * a packet buffer. The buffer can then be released back into a pool for + * reuse, or the dynamically allocated memory can be freed, according to + * how the packet was allocated. + * Returns void since SCL cannot do anything about failures + * + * @param buffer : The handle of the packet buffer to be released + * @param direction : Indicates transmit/receive direction that the packet buffer has + * been used for. This might be needed if tx/rx pools are separate. + * + */ +void scl_buffer_release(scl_buffer_t buffer, scl_buffer_dir_t direction) +{ + UNUSED_PARAMETER( direction ); + (void) pbuf_free( (struct pbuf *)buffer ); +} + +/** Retrieves the current pointer of a packet buffer + * + * Implemented in the port layer interface which is specific to the + * buffering scheme in use. + * Since packet buffers usually need to be created with space at the + * front for additional headers, this function allows SCL to get + * the current 'front' location pointer. + * + * @param buffer : The handle of the packet buffer whose pointer is to be retrieved + * + * @return : The packet buffer's current pointer. + */ +uint8_t *scl_buffer_get_current_piece_data_pointer(scl_buffer_t buffer) +{ + CY_ASSERT(buffer != NULL); + struct pbuf *pbuffer= (struct pbuf*) buffer; + return (uint8_t*) pbuffer->payload; +} + +/** Retrieves the size of a packet buffer + * + * Implemented in the port layer interface which is specific to the + * buffering scheme in use. + * Since packet buffers usually need to be created with space at the + * front for additional headers, the memory block used to contain a packet buffer + * will often be larger than the current size of the packet buffer data. + * This function allows SCL to retrieve the current size of a packet buffer's data. + * + * @param buffer : The handle of the packet buffer whose size is to be retrieved + * + * @return : The size of the packet buffer. + */ +uint16_t scl_buffer_get_current_piece_size(scl_buffer_t buffer) +{ + CY_ASSERT(buffer != NULL); + struct pbuf *pbuffer = (struct pbuf*) buffer; + return (uint16_t) pbuffer->len; +} + diff --git a/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/scl_wifi_api.c b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/scl_wifi_api.c new file mode 100644 index 0000000000..9547e9b123 --- /dev/null +++ b/targets/TARGET_Cypress/TARGET_PSOC6/COMPONENT_SCL/src/scl_wifi_api.c @@ -0,0 +1,181 @@ +/* + * (c) (2019-2020), Cypress Semiconductor Corporation. All rights reserved. + * + * This software, including source code, documentation and related materials + * ("Software"), is owned by Cypress Semiconductor Corporation or one of its + * subsidiaries ("Cypress") and is protected by and subject to worldwide patent + * protection (United States and foreign), United States copyright laws and + * international treaty provisions. Therefore, you may use this Software only + * as provided in the license agreement accompanying the software package from + * which you obtained this Software ("EULA"). + * + * If no EULA applies, Cypress hereby grants you a personal, non-exclusive, + * non-transferable license to copy, modify, and compile the Software source + * code solely for use in connection with Cypress's integrated circuit products. + * Any reproduction, modification, translation, compilation, or representation + * of this Software except as specified above is prohibited without the express + * written permission of Cypress. + * + * Disclaimer: THIS SOFTWARE IS PROVIDED AS-IS, WITH NO WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT, IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Cypress + * reserves the right to make changes to the Software without notice. Cypress + * does not assume any liability arising out of the application or use of the + * Software or any product or circuit described in the Software. Cypress does + * not authorize its products for use in any products where a malfunction or + * failure of the Cypress product may reasonably be expected to result in + * significant property damage, injury or death ("High Risk Product"). By + * including Cypress's product in a High Risk Product, the manufacturer of such + * system or application assumes all risk of such use and in doing so agrees to + * indemnify Cypress against all liability. + */ + +#include "scl_wifi_api.h" +#include "scl_ipc.h" + +/****************************************************** + * Variables Definitions + *****************************************************/ + +typedef struct { + scl_mac_t *mac; + uint32_t retval; +}scl_mac; + +/****************************************************** + * Function Definitions + ******************************************************/ + +scl_result_t scl_wifi_is_ready_to_transceive(void) +{ + scl_result_t result = SCL_SUCCESS; + scl_result_t retval = SCL_SUCCESS; + + result = scl_send_data(SCL_TX_TRANSCEIVE_READY, (char*)&retval, TIMER_DEFAULT_VALUE); + if (result == SCL_ERROR) { + SCL_LOG(("Ready to tranceive error\n")); + return SCL_ERROR; + } + else { + return retval; + } +} + +bool scl_wifi_on(void) +{ + bool retval = false; + scl_result_t result = SCL_SUCCESS; + result = scl_send_data(SCL_TX_WIFI_ON, (char*)&retval, WIFI_ON_TIMEOUT); + if (result == SCL_ERROR) { + SCL_LOG(("wifi_on Error\n")); + return false; + } + else { + return retval; + } +} + +scl_result_t scl_wifi_set_up(void) +{ + scl_result_t retval = SCL_SUCCESS; + scl_result_t result = SCL_SUCCESS; + result = scl_send_data(SCL_TX_WIFI_SET_UP, (char*)&retval, TIMER_DEFAULT_VALUE); + if (result == SCL_SUCCESS) { + return retval; + } + else { + SCL_LOG(("Wifi set up error\n")); + return SCL_ERROR; + } +} + +scl_result_t scl_wifi_get_mac_address(scl_mac_t *mac) +{ + scl_mac scl_mac_data; + scl_result_t scl_retval = SCL_SUCCESS; + scl_mac_data.mac = mac; + scl_mac_data.retval = SCL_SUCCESS; + + if (mac == NULL) { + return SCL_BADARG; + } + scl_retval = scl_send_data(SCL_TX_GET_MAC, (char*)&scl_mac_data, TIMER_DEFAULT_VALUE); + if (scl_retval == SCL_SUCCESS) { + return scl_mac_data.retval; + } + else { + SCL_LOG(("Get MAC address error\n")); + return SCL_ERROR; + } +} + +scl_result_t scl_wifi_get_bssid(scl_mac_t *bssid) +{ + struct scl_bssid { + scl_mac_t* bssid; + uint32_t retval; + } scl_bssid_t; + scl_result_t scl_retval = SCL_SUCCESS; + scl_bssid_t.bssid = bssid; + scl_bssid_t.retval = 0; + if (bssid == NULL) { + return SCL_BADARG; + } + scl_retval = scl_send_data(SCL_TX_WIFI_GET_BSSID, (char*)&scl_bssid_t, TIMER_DEFAULT_VALUE); + if (scl_retval == SCL_SUCCESS) { + return scl_bssid_t.retval; + } + else { + SCL_LOG(("get bssid error\n")); + return SCL_ERROR; + } +} + +scl_result_t scl_wifi_register_multicast_address(scl_mac_t *mac) +{ + scl_mac scl_mac_t; + scl_mac_t.mac = mac; + scl_mac_t.retval = 0; + scl_result_t scl_retval = SCL_SUCCESS; + if (mac == NULL) { + return SCL_BADARG; + } + scl_retval = scl_send_data(SCL_TX_REGISTER_MULTICAST_ADDRESS, (char*)&scl_mac_t, TIMER_DEFAULT_VALUE); + if(scl_retval != SCL_SUCCESS){ + SCL_LOG(("Register Multicast Address IPC Error")); + return SCL_ERROR; + } + return (scl_mac_t.retval); +} + +scl_result_t scl_network_send_ethernet_data(scl_tx_buf_t scl_buffer) +{ + scl_result_t retval = SCL_SUCCESS; + if (scl_buffer.buffer == NULL) { + return SCL_BADARG; + } + retval = scl_send_data(SCL_TX_SEND_OUT, (char*)&scl_buffer, TIMER_DEFAULT_VALUE); + return retval; +} + +scl_result_t scl_wifi_get_rssi(int32_t *rssi) +{ + struct tx_param { + uint32_t retval; + int32_t *get_rssi; + }tx_param_t; + scl_result_t scl_retval = SCL_SUCCESS; + + if (rssi == NULL) { + return SCL_BADARG; + } + tx_param_t.get_rssi = rssi; + scl_retval = scl_send_data(SCL_TX_WIFI_GET_RSSI, (char*) &tx_param_t, TIMER_DEFAULT_VALUE); + if (scl_retval == SCL_SUCCESS) { + return tx_param_t.retval; + } + else { + SCL_LOG(("get rssi error\n")); + return SCL_ERROR; + } +} \ No newline at end of file