wifiDriver.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef __WIFIDRIVER_H
#define __WIFIDRIVER_H
 
#include <buffers.h>
#include <nettypes.h>
#include <config_obj.h>
#include <netinterface.h>
#include <constants.h>
#include <utils.h>
#include <wifi/nbWifiConstants.h>
#include <wifi/nbwifi/nbWifiMsgStructs.h>
#include <wifi/wilc/microchip/driver/m2m_types.h>
#include <json_lexer.h>
 
#ifndef _STRUCT_PACKED
#define _STRUCT_PACKED __attribute__((__packed__))
#endif
 
#define WIFI_INTERFACE_NAME         "Wlan0"
#define MAX_WIFI_INTERFACES 1
#define WIFI_TASK_STACK_SIZE 4048
#define WIFI_RX_TASK_BASE_PRIO 18
#define WIFI_TX_FLOW_OFF_COUNT 120
 
#define CONNECT_RETRIES (5)
#define DEFAULT_WIFI_SEC_ALL (255)
#define DEFAULT_WIFI_CH_ALL (255)
 
#define STATUS_STALENESS_LIMIT (1 * TICKS_PER_SECOND)
//#define STATUS_STALENESS_LIMIT (TICKS_PER_SECOND*2)
#define SCAN_STALENESS_LIMIT (20 * TICKS_PER_SECOND)
 
#define CONNECT_TIMEOUT (60 * TICKS_PER_SECOND)
#define RECONNECT_TIMEOUT (20 * TICKS_PER_SECOND)
#define SCAN_TIMEOUT (15 * TICKS_PER_SECOND)
 
#define DRIVER_STATUS_CHECK_INTERVAL (5 * TICKS_PER_SECOND)
#define STATUS_AUTO_REQUEST_LIMIT (5 * TICKS_PER_SECOND)
#define STATUS_ERROR_TIMEOUT (30 * TICKS_PER_SECOND)
#define WIFI_RX_ERROR_TIMEOUT (300 * TICKS_PER_SECOND)
#define MAX_RX_TASK_TIMEOUT_COUNT (2)
 
#define PHY_BRDCST_DEST(x)                                                                                                               \
    ((((uint8_t *)(x))[0] == 0xFF) && (((uint8_t *)(x))[1] == 0xFF) && (((uint8_t *)(x))[2] == 0xFF) && (((uint8_t *)(x))[3] == 0xFF) && \
     (((uint8_t *)(x))[4] == 0xFF) & (((uint8_t *)(x))[5] == 0xFF))
 
extern bool def_wifi_quiet;
 
void SetWifiSPISpeed(int busSpeed);
 
uint32_t FifoSize(const OS_FIFO *fifo);
 
struct _STRUCT_PACKED nbWifiScanResult
{
    uint8_t lastAndBand;
    uint8_t bssType;
    uint8_t channel;
    uint8_t security;
    uint8_t cipher;
    uint8_t ssidLength;
    int16_t rssi;
    MACADR bssid;
    char ssid[SSID_MAX_LEN + 1];
    struct nbWifiScanResult *next;
};
 
enum wifiModule
{
    NBWIFIIN = 0,
    NBWIFIWILC
};
 
enum busType
{
    SPI = 0,
    SERIAL
};
 
namespace NB
{
struct nbWifiDeviceInfo
{
    uint8_t hardwareMajorRev;
    uint8_t hardwareMinorRev;
    uint8_t softwareMajorRev;
    uint8_t softwareMinorRev;
    MACADR hwAddr;
    uint8_t hardwareTypeLength;
    char hardwareType[];   // Placeholder for char array pobe_inter
};
 
struct nbWifiScanResultList
{
    PoolPtr headBuffer;
    PoolPtr tailBuffer;
    nbWifiScanResult *head;
    nbWifiScanResult *tail;
    uint8_t count;
    uint32_t tickLastUpdated;
};
 
struct nbWifiConnect
{
    char ssid[SSID_MAX_LEN + 1];
    uint8_t ssidLength;
    uint8_t security;
    char psk[PASS_MAX_LEN + 1];
    uint8_t channel;
    int retryCount;
};
 
void PrintScanResult(nbWifiScanResult *scanResult);
void PrintScanResultList(nbWifiScanResult *firstResult);
 
ParsedJsonDataSet ConvertScanResultsToJSON(nbWifiScanResult *scanResults);
 
class Wifi : public ::EtherLikeInterface
{
   public:
    // NNDK 3.0: Testing config variables
    config_string  cfg_ssid{"", "SSID"};
    config_pass    cfg_key{"", "Password"};
    config_chooser mode{"Connection Mode", "Client", "Client,Access Point"};
    config_chooser security{"Security", "Any", "Open,WEP,WPA,WPA2,Any"};
    config_bool    wifiQuiet{def_wifi_quiet, "ConnectQuiet", "Suppress connection serial print statements"};
    ConfigEndMarker;
 
    volatile bool autoReconnect;
    struct driverStatusStruct
    {
        uint8_t connected;             
        uint8_t ssidLength;            
        uint16_t txPower;              
        int16_t rssi;                  
        uint8_t band;                  
        uint8_t channel;               
        uint32_t maxTxRate;            
        uint8_t security;              
        uint8_t cipher;                
        MACADR bssid;                  
        uint8_t bssType;               
        char ssid[SSID_MAX_LEN + 1];   
 
        uint32_t tickLastUpdated;   
    };
 
    virtual int ConnectToAP(const char *ssid = nullptr,
                            const char *passwd = "",
                            uint8_t retryCount = CONNECT_RETRIES,
                            uint8_t security = DEFAULT_WIFI_SEC_ALL) = 0;
 
    virtual int ConnectToAP(nbWifiConnect connect) = 0;
 
    virtual int StartAP(const char *ssid = nullptr,
                        const char *passwd = "",
                        uint8_t channel = DEFAULT_TABLE_LABEL_CHANNEL,
                        uint8_t security = DEFAULT_TABLE_LABEL_SEC,
                        uint8_t cipher = DEFAULT_TABLE_LABEL_CIPH,
                        uint8_t ssidLen = 0) = 0;
 
    virtual int StartConfigAP(uint8_t channel = DEFAULT_TABLE_LABEL_CHANNEL) = 0;
 
    virtual nbWifiScanResult *Scan(const char *ssid = nullptr, uint8_t optionCount = 0, uint16_t *optionList = nullptr) = 0;
 
    virtual void Disconnect() = 0;
 
    static Wifi *wifiDrivers[MAX_WIFI_INTERFACES];
 
    static Wifi *GetDriverByInterfaceNumber(int interfaceNumber);
 
    static void SetDefaultITUCountry(NB::ITU_Country::CountryCode_t country);
    virtual int SetITUCountry(NB::ITU_Country::CountryCode_t country) = 0;
 
    virtual bool isRegistered() const = 0;
 
    virtual int GetWifiInterfaceNumber() const = 0;
 
    [[deprecated]] virtual int GetSystemInterfaceNumber() const = 0;
 
    /************************* BEGIN Status Functions **************************/
    virtual int StoreSSIDPWToConfig(char *ssid, char *password, int ssidLen = 0) = 0;
 
    virtual const char *GetDriverName();
 
    virtual int GetSSIDFromConfig(char *returnBuf, int maxLen) = 0;
 
    virtual int GetKeyFromConfig(char *returnBuf, int maxLen) = 0;
 
    virtual int GetCurSSID(char *buf, int maxlen) = 0;
 
    virtual MACADR GetCurBSSID() = 0;
 
    virtual void GetCurrentAP(driverStatusStruct *ap) = 0;
 
    virtual void GetDeviceInformation(nbWifiDeviceInfo *ap) = 0;
 
    virtual bool Connected() = 0;
 
    virtual int GetSignalStrength() = 0;
 
    virtual int GetCurChannel() = 0;
 
    virtual int GetSecurity() = 0;
 
    virtual int GetCipher() = 0;
    /************************* END Status Functions ***************************/
 
    virtual void TransmitBuffer(PoolPtr txBuffer) = 0;
 
    virtual bool GetLinkStatus() = 0;
 
    virtual void enab_multicast(MACADR macAddress, BOOL addAddress) = 0;
 
    virtual int APIStart() = 0;
 
    /********************** BEGIN RXTask control methods ***********************/
    virtual int Start() = 0;
 
    virtual void Pause() = 0;
 
    virtual void Resume() = 0;
 
    virtual void Kill() = 0;
    /********************** END RXTask control methods **********************/
 
    Wifi();
    Wifi(const Wifi &rhs);
    virtual bool UpdateSlaveFirmware(uint32_t imageLength, const uint8_t *imageBuffer) = 0;
 
   protected:
    typedef enum
    {
        Bus_Serial = 0,
        Bus_SPI = 1,
        Bus_SDIO = 2,
        Bus_USB = 3,
        Bus_PCI_E = 4,
        Bus_Ethernet = 5,
        Bus_Internal = 6,
    } CommBus;
 
    typedef enum
    {
        Mss_Serial = 1500,
        Mss_SPI = 1500,
        Mss_SDIO = 1500,
        Mss_USB = 1500,
        Mss_PCI_E = 1500,
        Mss_Ethernet = 1480,
        Mss_Internal = 1500,
    } MssSizes;
 
    /* ---- Static members ---- */
    static bool APITaskStarted;
    static bool APITaskRunning;
    static bool APIAbortTask;
    static bool APIPauseTask;
    static OS_SEM APITaskPauseSem;
    static ITU_Country::CountryCode_t wifiCountry;
    /* ---- End Static members ---- */
 
    /* ---- Data members ---- */
    nbWifiScanResultList ScanResults;
    bool scanComplete;
    OS_MBOX scanMailbox;
    /* ---- End Data members ---- */
 
    void (*DisconnectCB)(Wifi *wifiIntf);
    driverStatusStruct connectionState;
    CommBus busType;
    OS_CRIT busTxCrit;
    int resetPinConnector;
    int resetPinNum;
    bool taskStarted;
    bool taskRunning;
    bool abortTask;
    bool pauseTask;
    int myWifiNum;   // WiFi Driver number, not the interface number
 
    Wifi(CommBus busType, int resetPinConnector, int resetPinMum, const char *name);
    ~Wifi();
 
    virtual bool SetBusSpeed(uint32_t busSpeed) = 0;
    friend void ::SetWifiSPISpeed(int busSpeed);
 
    friend class WILC1000;
    friend class WICED;
};
 
struct SSID_t
{
    uint8_t len;
    uint8_t ssid[SSID_MAX_LEN + 1];
};
}   // namespace NB
 
typedef struct
{
    int spiModuleNum;
    int connectorNum;
    int csNum;
    int csGpioPinNum;
    int resetPinNum;
    int irqNum;
    int serialPortNum;
    int chipEnablePinNum;
    NB::Wifi *(*GetDriver)();
} wifi_init;
 
extern wifi_init wifiInit;
extern NB::Wifi *theWifiIntf;
extern NB::Wifi *wlan0;
 
#endif /* NBWIFIDRIVER_H_ */