Mbed OS Reference | WhdSTAInterface.h Source File

 /* WHD implementation of NetworkInterfaceAPI
  * Copyright (c) 2017-2019 ARM Limited
  * SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 #ifndef WHD_STA_INTERFACE_H
 #define WHD_STA_INTERFACE_H
 
 #include "netsocket/WiFiInterface.h"
 #include "netsocket/EMACInterface.h"
 #include "netsocket/OnboardNetworkStack.h"
 #include "WhdAccessPoint.h"
 #include "whd_emac.h"
 #include "whd_interface.h"
 #include "whd_types_int.h"
 
 struct ol_desc;
 
 /** WhdSTAInterface class
  *  Implementation of the NetworkStack for the WHD
  */
 class WhdSTAInterface : public WiFiInterface, public EMACInterface {
 public:
     class OlmInterface {
     public:
         /** Get the default OLM interface. */
         static OlmInterface &get_default_instance();
 
         OlmInterface(struct ol_desc *list = NULL) {}
 
         virtual int init_ols(void *whd, void *ip)
         {
             return 0;
         }
         virtual int sleep()
         {
             return 0;
         }
         virtual int wake()
         {
             return 0;
         }
 
         virtual void deinit_ols(void) {}
     };
 
     WhdSTAInterface(
         WHD_EMAC &emac = WHD_EMAC::get_instance(),
         OnboardNetworkStack &stack = OnboardNetworkStack::get_default_instance(),
         OlmInterface &olm = OlmInterface::get_default_instance(),
         whd_interface_shared_info_t &shared = whd_iface_shared);
 
     static WhdSTAInterface *get_default_instance();
 
     /* 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 in WiFiAccessPoint format
      *
      * This function will block.
      *
      * @param  ap       Pointer to allocated array of WiFiAccessPoint format for 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);
 
     /** Scan for available networks in WhdAccessPoint format
      *
      * This function will block.
      *
      * @param  ap       Pointer to allocated array of WhdAccessPoint format for 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_whd(WhdAccessPoint *res, unsigned count);
 
     /* is interface connected, if yes return WICED_SUCCESS else WICED_NOT_CONNECTED */
     int is_interface_connected();
 
     /* get bssid of the AP  if success return WICED_SUCCESS else WICED_ERROR */
     int get_bssid(uint8_t *bssid);
 
     /* print WHD log (this routine will malloc/free a buffer
      * You need to enable printing with WHD_LOGGING_BUFFER_ENABLE
      */
     int whd_log_print(void);
 
     /* read WHD log */
     int whd_log_read(char *buffer, int buffer_size);
 
     /* Get EDCF AC params */
     nsapi_error_t wifi_get_ac_params_sta(void *ac_param);
 
     /* get iovar value */
     int wifi_get_iovar_value(const char *iovar, uint32_t *value);
 
     /* set iovar value */
     int wifi_set_iovar_value(const char *iovar, uint32_t value);
 
     /* set ioctl value */
     int wifi_set_ioctl_value(uint32_t ioctl, uint32_t value) ;
 
     /* get WHD ifp value */
     int wifi_get_ifp(whd_interface_t *ifp);
 
     /* set wifi interface up */
     int wifi_set_up(void);
 
     /* set wifi interface down */
     int wifi_set_down(void);
 
     /* set wifi coex configuration */
     int wifi_set_coex_config(whd_coex_config_t *coex_config);
 
     /** Set Offload Manager Information
      *  NOTE: Only allowed while disconnected
      *
      * @param  olm      Offload Manager info structure
      * @return          true if completed successfully
      *                  false if Interface is connected
      */
     int set_olm(OlmInterface *olm)
     {
         if (get_connection_status() == NSAPI_STATUS_DISCONNECTED) {
             _olm = olm;
             return true;
         }
         return false;
     }
 
     /** Network stack is suspended
      *
      * @return          0 if successful
      */
     int net_suspended()
     {
         int ret = _olm->sleep();
         return ret;
     }
 
     /** Network stack is resuming
      *
      * @return          0 if successful
      */
     int net_resuming()
     {
         int ret = _olm->wake();
         return ret;
     }
 
 protected:
     int internal_scan(WiFiAccessPoint *aps, unsigned count, scan_result_type sres_type);
 
 private:
     char _ssid[33]; /* The longest possible name (defined in 802.11) +1 for the \0 */
     char _pass[64]; /* The longest allowed passphrase + 1 */
     nsapi_security_t _security;
     WHD_EMAC &_whd_emac;
     OlmInterface *_olm;
     whd_interface_shared_info_t &_iface_shared;
 };
 
 #endif
Important Information for this Arm website
