nbWifiMsgStructs.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef __NBWICEDMSGSTRUCTS_H
#define __NBWICEDMSGSTRUCTS_H
 
#include <nettypes.h>
#include <string.h>
#include <wifi/nbWifiConstants.h>
 
// #define HTONS(x) (x)
// #define HTONL(x) (x)
// #define htons(x) (x)
// #define htonl(x) (x)
 
#define BufferToObjPtr(buffer, objType) ((objType *)((uint8_t *)((buffer)->pData) + (buffer)->usedsize))
#define AddToBuffLen(buffer, msgPtr) (buffer)->usedsize += sizeof(*msgPtr)
#define GetSafeLength(val, max) ((val) <= (max)) ? (val) : (max)
 
#define MESSAGE_TYPE_BIT_OFFSET 4
#define TYPELEN_FIELD_LEN (sizeof(NB::NBWifiAPIMessage::Header::lenType))
#define _STRUCT_PACKED __attribute__((__packed__))
#define MAX_HARDWARE_TYPE_LENGTH 64
 
//
// Enum Definitions
//
namespace NB
{
namespace NBWifiAPIMessage
{
namespace Header
{
typedef enum
{
    Type_API_Request = 0x0,
    Type_API_Response = 0x1,
    Type_Credit_Report = 0x2,
    Type_Data_Raw = 0x3,
    Type_Data_CompressedIP = 0x4,
    Type_Internal = 0x7,
} ApiMessageTypes;
}
namespace Request
{
typedef enum
{
    Type_Config = 0x0,
    Type_Connect_Start = 0x1,
    Type_Disconnect_Stop = 0x2,
    Type_Scan = 0x3,
    Type_SetMAC = 0x4,
    Type_SaveConfig = 0x5,
    Type_GetCredits = 0x6,
    Type_SetBusSpeed = 0x7,
    Type_ReadyFirmware = 0x8,
    Type_FirmwareChunk = 0x9,
    Type_VerifyAndProgFirm = 0xA,
    Type_AddRemoveMulticast = 0xB,
    Type_SetITUCountry = 0xC,
    Type_GetStatus = 0xFD,
    Type_GetDeviceInfo = 0xFE,
    Type_GetOptionTable = 0xFF
} RequestTypes;
}
namespace Response
{
typedef enum
{
    Type_Scan_Result = 0x0,
    Type_Status = 0x1,
    Type_DeviceInfo = 0x2,
    Type_OptionTableResp = 0x3,
} ResponseTypes;
}
namespace Internal
{
typedef enum
{
    Type_Internal_JoinAP = 0x0,
    Type_Internal_SendStatus = 0x1,
    Type_Internal_Reconnect = 0x2,
} InternalTypes;
}
 
}   // namespace NBWifiAPIMessage
}   // namespace NB
 
//
// Structure Definitions
//
namespace NB
{
namespace NBWifiAPIMessage
{
// Header structures
namespace Header
{
struct _STRUCT_PACKED lenType
{
    beuint16_t val;
    beuint16_t xorVal;
};
struct _STRUCT_PACKED APIRequest
{
    lenType lengthAndType;
    uint8_t requestType;
    uint8_t commandID;
    uint8_t pData[];
};
struct _STRUCT_PACKED APIResponse
{
    lenType lengthAndType;
    uint8_t responseType;
    uint8_t commandID;
    int32_t returnCode;
    // beint32_t     returnCode;
    // uint8_t     returnCode;
    uint8_t pData[];
};
struct _STRUCT_PACKED CreditReport
{
    lenType lengthAndType;
    uint8_t availableCredits;
};
struct _STRUCT_PACKED Data_Raw
{
    lenType lengthAndType;
    uint8_t availableCredits;
    uint8_t pData[];
};
struct _STRUCT_PACKED Data_CompressedIP
{
    lenType lengthAndType;
    uint8_t connectionID;
    uint8_t availableCredits;
    uint8_t pData[];
};
struct _STRUCT_PACKED Internal
{
    lenType lengthAndType;
    uint8_t messageType;
    uint8_t commandID;
};
}   // namespace Header
 
// Request structures
namespace Request
{
struct _STRUCT_PACKED ConfigReq
{
    uint8_t optionCount;
    uint8_t ssidLength;
    uint8_t passwdLength;
    uint8_t padding;
    char options[];   // Placeholder for char array pobe_inter
};
struct _STRUCT_PACKED ConnectStart
{
    uint8_t configNum;
    uint8_t flags;
    uint8_t retryCount;
};
struct _STRUCT_PACKED Scan
{
    uint8_t optionCount;
    uint8_t ssidLength;
    char options[];   // Placeholder for char array pobe_inter
};
struct _STRUCT_PACKED SetMAC
{
    MACADR newMAC;
};
struct _STRUCT_PACKED SaveConfig
{
    uint8_t configNum;
};
struct _STRUCT_PACKED SetBusSpeed
{
    beuint32_t busSpeed;
};
struct _STRUCT_PACKED FirmwareChunk
{
    beuint32_t offset;
    beuint16_t length;
    beuint16_t checksum;
    uint8_t pData[];
};
struct _STRUCT_PACKED VerifyAndProgFirm
{
    beuint32_t imageLength;
    beuint32_t checksum[4];
};
struct _STRUCT_PACKED AddRemoveMulticast
{
    uint8_t flags;
    MACADR theMac;
};
struct _STRUCT_PACKED SetITUCountry
{
    uint8_t length;
    uint8_t pData[];
};
struct _STRUCT_PACKED GetTableReq
{
    uint8_t tableNum;
};
}   // namespace Request
 
// Response structures
namespace Response
{
struct _STRUCT_PACKED ScanResult
{
    uint8_t lastAndBand;
    uint8_t bssType;
    uint8_t channel;
    uint8_t security;
    uint8_t cipher;
    uint8_t ssidLength;
    beint16_t rssi;
    MACADR bssid;
    char ssid[];   // Placeholder for char array pobe_inter
};
struct _STRUCT_PACKED Status
{
    uint8_t connected;
    uint8_t bssType;
    uint8_t security;
    uint8_t cipher;
    beuint32_t maxTxRate;
    beuint16_t rssi;
    uint8_t band;
    uint8_t channel;
    beuint16_t txPower;
    MACADR bssid;
    uint8_t ssidLength;
    char ssid[];   // Placeholder for char array pobe_inter
};
struct _STRUCT_PACKED DeviceInfo
{
    uint8_t hardwareMajorRev;
    uint8_t hardwareMinorRev;
    uint8_t softwareMajorRev;
    uint8_t softwareMinorRev;
    MACADR hardwareID;
    uint8_t hardwareTypeLength;
    char hardwareType[MAX_HARDWARE_TYPE_LENGTH + 1];   // allow extra space for null terminating char
};
struct _STRUCT_PACKED OptionTable
{
    struct Entry
    {
        uint8_t value;
        uint8_t labelLength;
        char label[];   // Placeholder for char array
    };
    beuint16_t flagsAndEntryCount;
    uint8_t tableNum;
    Entry entries[];
};
}   // namespace Response
}   // namespace NBWifiAPIMessage
}   // namespace NB
 
//
// Function declarations
//
namespace NB
{
namespace NBWifiAPIMessage
{
namespace Header
{
void WriteHeader_APIRequest(PoolPtr messageBuffer,
                            bool additionalFlag,
                            NB::NBWifiAPIMessage::Request::RequestTypes requestType,
                            uint8_t commandID);
void WriteHeader_APIResponse(PoolPtr messageBuffer,
                             bool additionalFlag,
                             NB::NBWifiAPIMessage::Response::ResponseTypes responseType,
                             uint8_t commandID,
                             int32_t returnCode);
void FixHeader_Length(PoolPtr messageBuffer);
void WriteHeader_Data_Raw(PoolPtr messageBuffer, bool additionalFlag, uint16_t length);
void WriteHeader_Data_CompressedIP(PoolPtr messageBuffer, bool additionalFlag, uint16_t length, uint8_t connectionID);
void WriteCreditReport(PoolPtr messageBuffer, bool additionalFlag, uint16_t length, uint8_t availableCredits);
bool VerifyChecksum(NB::NBWifiAPIMessage::Header::lenType lengthAndType);
}   // namespace Header
namespace Request
{
void WriteMsg_ConfigReq(PoolPtr messageBuffer,
                        const char *ssid,
                        uint8_t ssidLength,
                        const char *passwd,
                        uint8_t passwdLength,
                        uint16_t *optionList,
                        uint8_t optionCount);
void WriteMsg_ConnectStart(PoolPtr messageBuffer, uint8_t configNumber, bool scan, uint8_t retryCount);
void WriteMsg_SetMAC(PoolPtr messageBuffer, const MACADR *newMAC);
void WriteMsg_SetITUCountry(PoolPtr messageBuffer, NB::ITU_Country::CountryCode_t country);
void WriteMsg_SetBusSpeed(PoolPtr messageBuffer, uint32_t busSpeed);
void WriteMsg_SaveConfig(PoolPtr messageBuffer, uint32_t busSpeed);
void WriteMsg_FirmwareChunk(PoolPtr messageBuffer, uint32_t offset, uint16_t dataLen, uint16_t checksum, const uint8_t *data);
void WriteMsg_VerifyAndProgFirm(PoolPtr messageBuffer, uint32_t imageLen, const uint32_t *checksum);
void WriteMsg_AddRemoveMulticast(PoolPtr messageBuffer, bool AddNotRemove, const MACADR *mac);
void WriteMsg_Scan(PoolPtr messageBuffer, uint8_t optionCount, uint16_t *optionList, uint8_t ssidLength, const char *ssid);
}   // namespace Request
namespace Response
{
void WriteMsg_ScanResult(PoolPtr messageBuffer,
                         bool last,
                         Constants::RadioBand band,
                         Constants::BssType bssType,
                         uint8_t channel,
                         uint8_t security,
                         uint8_t cipher,
                         int16_t rssi,
                         const MACADR *pBssid,
                         const char *ssid,
                         int ssidLength);
void WriteMsg_Status(PoolPtr messageBuffer,
                     uint8_t connected,
                     int16_t txPower,
                     int16_t rssi,
                     uint16_t channel,
                     uint32_t maxTxRate,
                     uint32_t security,
                     const MACADR *pBssid,
                     uint8_t bssType,
                     const char *ssid,
                     uint8_t ssidLength);
void WriteMsg_DeviceInfo(PoolPtr messageBuffer,
                         uint8_t hardwareMajorRev,
                         uint8_t hardwareMinorRev,
                         uint8_t softwareMajorRev,
                         uint8_t softwareMinorRev,
                         const MACADR *pHardwareID,
                         const char *hardwareType,
                         uint8_t hardwareTypeLength);
}   // namespace Response
}   // namespace NBWifiAPIMessage
}   // namespace NB
 
#endif /* ----- #ifndef __NBWICEDMSGSTRUCTS_H  ----- */