4314 lines
190 KiB
C
4314 lines
190 KiB
C
/*****************************************************************************
|
|
|
|
(c) Cambridge Silicon Radio Limited 2012
|
|
All rights reserved and confidential information of CSR
|
|
|
|
Refer to LICENSE.txt included with this source for details
|
|
on the license terms.
|
|
|
|
*****************************************************************************/
|
|
|
|
/* Note: this is an auto-generated file. */
|
|
|
|
#ifndef CSR_WIFI_SME_LIB_H__
|
|
#define CSR_WIFI_SME_LIB_H__
|
|
|
|
#include "csr_sched.h"
|
|
#include "csr_macro.h"
|
|
#include "csr_msg_transport.h"
|
|
|
|
#include "csr_wifi_lib.h"
|
|
|
|
#include "csr_wifi_sme_prim.h"
|
|
#include "csr_wifi_sme_task.h"
|
|
|
|
|
|
#ifndef CSR_WIFI_SME_LIB_DESTINATION_QUEUE
|
|
# ifdef CSR_WIFI_NME_ENABLE
|
|
# include "csr_wifi_nme_task.h"
|
|
# define CSR_WIFI_SME_LIB_DESTINATION_QUEUE CSR_WIFI_NME_IFACEQUEUE
|
|
# else
|
|
# define CSR_WIFI_SME_LIB_DESTINATION_QUEUE CSR_WIFI_SME_IFACEQUEUE
|
|
# endif
|
|
#endif
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*----------------------------------------------------------------------------*
|
|
* CsrWifiSmeFreeUpstreamMessageContents
|
|
*
|
|
* DESCRIPTION
|
|
* Free the allocated memory in a CSR_WIFI_SME upstream message. Does not
|
|
* free the message itself, and can only be used for upstream messages.
|
|
*
|
|
* PARAMETERS
|
|
* Deallocates the resources in a CSR_WIFI_SME upstream message
|
|
*----------------------------------------------------------------------------*/
|
|
void CsrWifiSmeFreeUpstreamMessageContents(u16 eventClass, void *message);
|
|
|
|
/*----------------------------------------------------------------------------*
|
|
* CsrWifiSmeFreeDownstreamMessageContents
|
|
*
|
|
* DESCRIPTION
|
|
* Free the allocated memory in a CSR_WIFI_SME downstream message. Does not
|
|
* free the message itself, and can only be used for downstream messages.
|
|
*
|
|
* PARAMETERS
|
|
* Deallocates the resources in a CSR_WIFI_SME downstream message
|
|
*----------------------------------------------------------------------------*/
|
|
void CsrWifiSmeFreeDownstreamMessageContents(u16 eventClass, void *message);
|
|
|
|
/*----------------------------------------------------------------------------*
|
|
* Enum to string functions
|
|
*----------------------------------------------------------------------------*/
|
|
const char* CsrWifiSme80211NetworkTypeToString(CsrWifiSme80211NetworkType value);
|
|
const char* CsrWifiSme80211PrivacyModeToString(CsrWifiSme80211PrivacyMode value);
|
|
const char* CsrWifiSme80211dTrustLevelToString(CsrWifiSme80211dTrustLevel value);
|
|
const char* CsrWifiSmeAmpStatusToString(CsrWifiSmeAmpStatus value);
|
|
const char* CsrWifiSmeAuthModeToString(CsrWifiSmeAuthMode value);
|
|
const char* CsrWifiSmeBasicUsabilityToString(CsrWifiSmeBasicUsability value);
|
|
const char* CsrWifiSmeBssTypeToString(CsrWifiSmeBssType value);
|
|
const char* CsrWifiSmeCoexSchemeToString(CsrWifiSmeCoexScheme value);
|
|
const char* CsrWifiSmeControlIndicationToString(CsrWifiSmeControlIndication value);
|
|
const char* CsrWifiSmeCtsProtectionTypeToString(CsrWifiSmeCtsProtectionType value);
|
|
const char* CsrWifiSmeD3AutoScanModeToString(CsrWifiSmeD3AutoScanMode value);
|
|
const char* CsrWifiSmeEncryptionToString(CsrWifiSmeEncryption value);
|
|
const char* CsrWifiSmeFirmwareDriverInterfaceToString(CsrWifiSmeFirmwareDriverInterface value);
|
|
const char* CsrWifiSmeHostPowerModeToString(CsrWifiSmeHostPowerMode value);
|
|
const char* CsrWifiSmeIEEE80211ReasonToString(CsrWifiSmeIEEE80211Reason value);
|
|
const char* CsrWifiSmeIEEE80211ResultToString(CsrWifiSmeIEEE80211Result value);
|
|
const char* CsrWifiSmeIndicationsToString(CsrWifiSmeIndications value);
|
|
const char* CsrWifiSmeKeyTypeToString(CsrWifiSmeKeyType value);
|
|
const char* CsrWifiSmeListActionToString(CsrWifiSmeListAction value);
|
|
const char* CsrWifiSmeMediaStatusToString(CsrWifiSmeMediaStatus value);
|
|
const char* CsrWifiSmeP2pCapabilityToString(CsrWifiSmeP2pCapability value);
|
|
const char* CsrWifiSmeP2pGroupCapabilityToString(CsrWifiSmeP2pGroupCapability value);
|
|
const char* CsrWifiSmeP2pNoaConfigMethodToString(CsrWifiSmeP2pNoaConfigMethod value);
|
|
const char* CsrWifiSmeP2pRoleToString(CsrWifiSmeP2pRole value);
|
|
const char* CsrWifiSmeP2pStatusToString(CsrWifiSmeP2pStatus value);
|
|
const char* CsrWifiSmePacketFilterModeToString(CsrWifiSmePacketFilterMode value);
|
|
const char* CsrWifiSmePowerSaveLevelToString(CsrWifiSmePowerSaveLevel value);
|
|
const char* CsrWifiSmePreambleTypeToString(CsrWifiSmePreambleType value);
|
|
const char* CsrWifiSmeRadioIFToString(CsrWifiSmeRadioIF value);
|
|
const char* CsrWifiSmeRegulatoryDomainToString(CsrWifiSmeRegulatoryDomain value);
|
|
const char* CsrWifiSmeRoamReasonToString(CsrWifiSmeRoamReason value);
|
|
const char* CsrWifiSmeScanTypeToString(CsrWifiSmeScanType value);
|
|
const char* CsrWifiSmeTrafficTypeToString(CsrWifiSmeTrafficType value);
|
|
const char* CsrWifiSmeTspecCtrlToString(CsrWifiSmeTspecCtrl value);
|
|
const char* CsrWifiSmeTspecResultCodeToString(CsrWifiSmeTspecResultCode value);
|
|
const char* CsrWifiSmeWepAuthModeToString(CsrWifiSmeWepAuthMode value);
|
|
const char* CsrWifiSmeWepCredentialTypeToString(CsrWifiSmeWepCredentialType value);
|
|
const char* CsrWifiSmeWmmModeToString(CsrWifiSmeWmmMode value);
|
|
const char* CsrWifiSmeWmmQosInfoToString(CsrWifiSmeWmmQosInfo value);
|
|
const char* CsrWifiSmeWpsConfigTypeToString(CsrWifiSmeWpsConfigType value);
|
|
const char* CsrWifiSmeWpsDeviceCategoryToString(CsrWifiSmeWpsDeviceCategory value);
|
|
const char* CsrWifiSmeWpsDeviceSubCategoryToString(CsrWifiSmeWpsDeviceSubCategory value);
|
|
const char* CsrWifiSmeWpsDpidToString(CsrWifiSmeWpsDpid value);
|
|
const char* CsrWifiSmeWpsRegistrationToString(CsrWifiSmeWpsRegistration value);
|
|
|
|
|
|
/*----------------------------------------------------------------------------*
|
|
* CsrPrim Type toString function.
|
|
* Converts a message type to the String name of the Message
|
|
*----------------------------------------------------------------------------*/
|
|
const char* CsrWifiSmePrimTypeToString(CsrPrim msgType);
|
|
|
|
/*----------------------------------------------------------------------------*
|
|
* Lookup arrays for PrimType name Strings
|
|
*----------------------------------------------------------------------------*/
|
|
extern const char *CsrWifiSmeUpstreamPrimNames[CSR_WIFI_SME_PRIM_UPSTREAM_COUNT];
|
|
extern const char *CsrWifiSmeDownstreamPrimNames[CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT];
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeActivateReqSend
|
|
|
|
DESCRIPTION
|
|
The WMA sends this primitive to activate the SME.
|
|
The WMA must activate the SME before it can send any other primitive.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeActivateReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeActivateReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ACTIVATE_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeActivateReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeActivateReq *msg__; \
|
|
CsrWifiSmeActivateReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeActivateReqSend(src__) \
|
|
CsrWifiSmeActivateReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeActivateCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME sends this primitive when the activation is complete.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeActivateCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeActivateCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ACTIVATE_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeActivateCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeActivateCfm *msg__; \
|
|
CsrWifiSmeActivateCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeActivateCfmSend(dst__, status__) \
|
|
CsrWifiSmeActivateCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeAdhocConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the adHocConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeAdhocConfigGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeAdhocConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeAdhocConfigGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeAdhocConfigGetReq *msg__; \
|
|
CsrWifiSmeAdhocConfigGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeAdhocConfigGetReqSend(src__) \
|
|
CsrWifiSmeAdhocConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeAdhocConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
adHocConfig - Contains the values used when starting an Ad-hoc (IBSS)
|
|
connection.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeAdhocConfigGetCfmCreate(msg__, dst__, src__, status__, adHocConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeAdhocConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->adHocConfig = (adHocConfig__);
|
|
|
|
#define CsrWifiSmeAdhocConfigGetCfmSendTo(dst__, src__, status__, adHocConfig__) \
|
|
{ \
|
|
CsrWifiSmeAdhocConfigGetCfm *msg__; \
|
|
CsrWifiSmeAdhocConfigGetCfmCreate(msg__, dst__, src__, status__, adHocConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeAdhocConfigGetCfmSend(dst__, status__, adHocConfig__) \
|
|
CsrWifiSmeAdhocConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, adHocConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeAdhocConfigSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the adHocConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
adHocConfig - Sets the values to use when starting an ad hoc network.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeAdhocConfigSetReqCreate(msg__, dst__, src__, adHocConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeAdhocConfigSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_SET_REQ, dst__, src__); \
|
|
msg__->adHocConfig = (adHocConfig__);
|
|
|
|
#define CsrWifiSmeAdhocConfigSetReqSendTo(dst__, src__, adHocConfig__) \
|
|
{ \
|
|
CsrWifiSmeAdhocConfigSetReq *msg__; \
|
|
CsrWifiSmeAdhocConfigSetReqCreate(msg__, dst__, src__, adHocConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeAdhocConfigSetReqSend(src__, adHocConfig__) \
|
|
CsrWifiSmeAdhocConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, adHocConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeAdhocConfigSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeAdhocConfigSetCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeAdhocConfigSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_SET_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeAdhocConfigSetCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeAdhocConfigSetCfm *msg__; \
|
|
CsrWifiSmeAdhocConfigSetCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeAdhocConfigSetCfmSend(dst__, status__) \
|
|
CsrWifiSmeAdhocConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeAmpStatusChangeIndSend
|
|
|
|
DESCRIPTION
|
|
Indication of change to AMP activity.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface on which the AMP activity changed.
|
|
ampStatus - The new status of AMP activity.Range: {AMP_ACTIVE,
|
|
AMP_INACTIVE}.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeAmpStatusChangeIndCreate(msg__, dst__, src__, interfaceTag__, ampStatus__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeAmpStatusChangeInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_AMP_STATUS_CHANGE_IND, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->ampStatus = (ampStatus__);
|
|
|
|
#define CsrWifiSmeAmpStatusChangeIndSendTo(dst__, src__, interfaceTag__, ampStatus__) \
|
|
{ \
|
|
CsrWifiSmeAmpStatusChangeInd *msg__; \
|
|
CsrWifiSmeAmpStatusChangeIndCreate(msg__, dst__, src__, interfaceTag__, ampStatus__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeAmpStatusChangeIndSend(dst__, interfaceTag__, ampStatus__) \
|
|
CsrWifiSmeAmpStatusChangeIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, ampStatus__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeAssociationCompleteIndSend
|
|
|
|
DESCRIPTION
|
|
The SME will send this primitive to all the tasks that have registered to
|
|
receive it whenever it completes an attempt to associate with an AP. If
|
|
the association was successful, status will be set to
|
|
CSR_WIFI_SME_STATUS_SUCCESS, otherwise status and deauthReason shall be
|
|
set to appropriate error codes.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the association procedure
|
|
connectionInfo - This parameter is relevant only if result is
|
|
CSR_WIFI_SME_STATUS_SUCCESS:
|
|
it points to the connection information for the new network
|
|
deauthReason - This parameter is relevant only if result is not
|
|
CSR_WIFI_SME_STATUS_SUCCESS:
|
|
if the AP deauthorised the station, it gives the reason of
|
|
the deauthorization
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeAssociationCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__, deauthReason__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeAssociationCompleteInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ASSOCIATION_COMPLETE_IND, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->connectionInfo = (connectionInfo__); \
|
|
msg__->deauthReason = (deauthReason__);
|
|
|
|
#define CsrWifiSmeAssociationCompleteIndSendTo(dst__, src__, interfaceTag__, status__, connectionInfo__, deauthReason__) \
|
|
{ \
|
|
CsrWifiSmeAssociationCompleteInd *msg__; \
|
|
CsrWifiSmeAssociationCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__, deauthReason__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeAssociationCompleteIndSend(dst__, interfaceTag__, status__, connectionInfo__, deauthReason__) \
|
|
CsrWifiSmeAssociationCompleteIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionInfo__, deauthReason__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeAssociationStartIndSend
|
|
|
|
DESCRIPTION
|
|
The SME will send this primitive to all the tasks that have registered to
|
|
receive it whenever it begins an attempt to associate with an AP.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
address - BSSID of the associating network
|
|
ssid - Service Set identifier of the associating network
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeAssociationStartIndCreate(msg__, dst__, src__, interfaceTag__, address__, ssid__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeAssociationStartInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ASSOCIATION_START_IND, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->address = (address__); \
|
|
msg__->ssid = (ssid__);
|
|
|
|
#define CsrWifiSmeAssociationStartIndSendTo(dst__, src__, interfaceTag__, address__, ssid__) \
|
|
{ \
|
|
CsrWifiSmeAssociationStartInd *msg__; \
|
|
CsrWifiSmeAssociationStartIndCreate(msg__, dst__, src__, interfaceTag__, address__, ssid__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeAssociationStartIndSend(dst__, interfaceTag__, address__, ssid__) \
|
|
CsrWifiSmeAssociationStartIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, address__, ssid__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeBlacklistReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application should call this primitive to notify the
|
|
driver of any networks that should not be connected to. The interface
|
|
allows the wireless manager application to query, add, remove, and flush
|
|
the BSSIDs that the driver may not connect or roam to.
|
|
When this primitive adds to the black list the BSSID to which the SME is
|
|
currently connected, the SME will try to roam, if applicable, to another
|
|
BSSID in the same ESS; if the roaming procedure fails, the SME will
|
|
disconnect.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
action - The value of the CsrWifiSmeListAction parameter instructs
|
|
the driver to modify or provide the list of blacklisted
|
|
networks.
|
|
setAddressCount - Number of BSSIDs sent with this primitive
|
|
setAddresses - Pointer to the list of BBSIDs sent with the primitive, set
|
|
to NULL if none is sent.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeBlacklistReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressCount__, setAddresses__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeBlacklistReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_BLACKLIST_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->action = (action__); \
|
|
msg__->setAddressCount = (setAddressCount__); \
|
|
msg__->setAddresses = (setAddresses__);
|
|
|
|
#define CsrWifiSmeBlacklistReqSendTo(dst__, src__, interfaceTag__, action__, setAddressCount__, setAddresses__) \
|
|
{ \
|
|
CsrWifiSmeBlacklistReq *msg__; \
|
|
CsrWifiSmeBlacklistReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressCount__, setAddresses__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeBlacklistReqSend(src__, interfaceTag__, action__, setAddressCount__, setAddresses__) \
|
|
CsrWifiSmeBlacklistReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, setAddressCount__, setAddresses__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeBlacklistCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME will call this primitive when the action on the blacklist has
|
|
completed. For a GET action, this primitive also reports the list of
|
|
BBSIDs in the blacklist.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
action - Action in the request
|
|
getAddressCount - This parameter is only relevant if action is
|
|
CSR_WIFI_SME_LIST_ACTION_GET:
|
|
number of BSSIDs sent with this primitive
|
|
getAddresses - Pointer to the list of BBSIDs sent with the primitive, set
|
|
to NULL if none is sent.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeBlacklistCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeBlacklistCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_BLACKLIST_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->action = (action__); \
|
|
msg__->getAddressCount = (getAddressCount__); \
|
|
msg__->getAddresses = (getAddresses__);
|
|
|
|
#define CsrWifiSmeBlacklistCfmSendTo(dst__, src__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__) \
|
|
{ \
|
|
CsrWifiSmeBlacklistCfm *msg__; \
|
|
CsrWifiSmeBlacklistCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeBlacklistCfmSend(dst__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__) \
|
|
CsrWifiSmeBlacklistCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, getAddressCount__, getAddresses__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCalibrationDataGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive retrieves the Wi-Fi radio calibration data.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCalibrationDataGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCalibrationDataGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeCalibrationDataGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeCalibrationDataGetReq *msg__; \
|
|
CsrWifiSmeCalibrationDataGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCalibrationDataGetReqSend(src__) \
|
|
CsrWifiSmeCalibrationDataGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCalibrationDataGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
calibrationDataLength - Number of bytes in the buffer pointed by
|
|
calibrationData
|
|
calibrationData - Pointer to a buffer of length calibrationDataLength
|
|
containing the calibration data
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCalibrationDataGetCfmCreate(msg__, dst__, src__, status__, calibrationDataLength__, calibrationData__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCalibrationDataGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->calibrationDataLength = (calibrationDataLength__); \
|
|
msg__->calibrationData = (calibrationData__);
|
|
|
|
#define CsrWifiSmeCalibrationDataGetCfmSendTo(dst__, src__, status__, calibrationDataLength__, calibrationData__) \
|
|
{ \
|
|
CsrWifiSmeCalibrationDataGetCfm *msg__; \
|
|
CsrWifiSmeCalibrationDataGetCfmCreate(msg__, dst__, src__, status__, calibrationDataLength__, calibrationData__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCalibrationDataGetCfmSend(dst__, status__, calibrationDataLength__, calibrationData__) \
|
|
CsrWifiSmeCalibrationDataGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, calibrationDataLength__, calibrationData__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCalibrationDataSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the Wi-Fi radio calibration data.
|
|
The usage of the primitive with proper calibration data will avoid
|
|
time-consuming configuration after power-up.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
calibrationDataLength - Number of bytes in the buffer pointed by
|
|
calibrationData
|
|
calibrationData - Pointer to a buffer of length calibrationDataLength
|
|
containing the calibration data
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCalibrationDataSetReqCreate(msg__, dst__, src__, calibrationDataLength__, calibrationData__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCalibrationDataSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_SET_REQ, dst__, src__); \
|
|
msg__->calibrationDataLength = (calibrationDataLength__); \
|
|
msg__->calibrationData = (calibrationData__);
|
|
|
|
#define CsrWifiSmeCalibrationDataSetReqSendTo(dst__, src__, calibrationDataLength__, calibrationData__) \
|
|
{ \
|
|
CsrWifiSmeCalibrationDataSetReq *msg__; \
|
|
CsrWifiSmeCalibrationDataSetReqCreate(msg__, dst__, src__, calibrationDataLength__, calibrationData__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCalibrationDataSetReqSend(src__, calibrationDataLength__, calibrationData__) \
|
|
CsrWifiSmeCalibrationDataSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, calibrationDataLength__, calibrationData__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCalibrationDataSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCalibrationDataSetCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCalibrationDataSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_SET_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeCalibrationDataSetCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeCalibrationDataSetCfm *msg__; \
|
|
CsrWifiSmeCalibrationDataSetCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCalibrationDataSetCfmSend(dst__, status__) \
|
|
CsrWifiSmeCalibrationDataSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCcxConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the CcxConfig parameter.
|
|
CURRENTLY NOT SUPPORTED.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCcxConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCcxConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_GET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__);
|
|
|
|
#define CsrWifiSmeCcxConfigGetReqSendTo(dst__, src__, interfaceTag__) \
|
|
{ \
|
|
CsrWifiSmeCcxConfigGetReq *msg__; \
|
|
CsrWifiSmeCcxConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCcxConfigGetReqSend(src__, interfaceTag__) \
|
|
CsrWifiSmeCcxConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCcxConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
ccxConfig - Currently not supported
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCcxConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, ccxConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCcxConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->ccxConfig = (ccxConfig__);
|
|
|
|
#define CsrWifiSmeCcxConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, ccxConfig__) \
|
|
{ \
|
|
CsrWifiSmeCcxConfigGetCfm *msg__; \
|
|
CsrWifiSmeCcxConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, ccxConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCcxConfigGetCfmSend(dst__, interfaceTag__, status__, ccxConfig__) \
|
|
CsrWifiSmeCcxConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, ccxConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCcxConfigSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the CcxConfig parameter.
|
|
CURRENTLY NOT SUPPORTED.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
ccxConfig - Currently not supported
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCcxConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, ccxConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCcxConfigSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_SET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->ccxConfig = (ccxConfig__);
|
|
|
|
#define CsrWifiSmeCcxConfigSetReqSendTo(dst__, src__, interfaceTag__, ccxConfig__) \
|
|
{ \
|
|
CsrWifiSmeCcxConfigSetReq *msg__; \
|
|
CsrWifiSmeCcxConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, ccxConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCcxConfigSetReqSend(src__, interfaceTag__, ccxConfig__) \
|
|
CsrWifiSmeCcxConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, ccxConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCcxConfigSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCcxConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCcxConfigSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_SET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeCcxConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
|
|
{ \
|
|
CsrWifiSmeCcxConfigSetCfm *msg__; \
|
|
CsrWifiSmeCcxConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCcxConfigSetCfmSend(dst__, interfaceTag__, status__) \
|
|
CsrWifiSmeCcxConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCloakedSsidsGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the CloakedSsids parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCloakedSsidsGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCloakedSsidsGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeCloakedSsidsGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeCloakedSsidsGetReq *msg__; \
|
|
CsrWifiSmeCloakedSsidsGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCloakedSsidsGetReqSend(src__) \
|
|
CsrWifiSmeCloakedSsidsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCloakedSsidsGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
cloakedSsids - Reports list of cloaked SSIDs that are explicitly scanned for
|
|
by the driver
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCloakedSsidsGetCfmCreate(msg__, dst__, src__, status__, cloakedSsids__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCloakedSsidsGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->cloakedSsids = (cloakedSsids__);
|
|
|
|
#define CsrWifiSmeCloakedSsidsGetCfmSendTo(dst__, src__, status__, cloakedSsids__) \
|
|
{ \
|
|
CsrWifiSmeCloakedSsidsGetCfm *msg__; \
|
|
CsrWifiSmeCloakedSsidsGetCfmCreate(msg__, dst__, src__, status__, cloakedSsids__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCloakedSsidsGetCfmSend(dst__, status__, cloakedSsids__) \
|
|
CsrWifiSmeCloakedSsidsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, cloakedSsids__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCloakedSsidsSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the list of cloaked SSIDs for which the WMA possesses
|
|
profiles.
|
|
When the driver detects a cloaked AP, the SME will explicitly scan for it
|
|
using the list of cloaked SSIDs provided it, and, if the scan succeeds,
|
|
it will report the AP to the WMA either via CSR_WIFI_SME_SCAN_RESULT_IND
|
|
(if registered) or via CSR_WIFI_SCAN_RESULT_GET_CFM.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
cloakedSsids - Sets the list of cloaked SSIDs
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCloakedSsidsSetReqCreate(msg__, dst__, src__, cloakedSsids__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCloakedSsidsSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_SET_REQ, dst__, src__); \
|
|
msg__->cloakedSsids = (cloakedSsids__);
|
|
|
|
#define CsrWifiSmeCloakedSsidsSetReqSendTo(dst__, src__, cloakedSsids__) \
|
|
{ \
|
|
CsrWifiSmeCloakedSsidsSetReq *msg__; \
|
|
CsrWifiSmeCloakedSsidsSetReqCreate(msg__, dst__, src__, cloakedSsids__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCloakedSsidsSetReqSend(src__, cloakedSsids__) \
|
|
CsrWifiSmeCloakedSsidsSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, cloakedSsids__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCloakedSsidsSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCloakedSsidsSetCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCloakedSsidsSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_SET_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeCloakedSsidsSetCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeCloakedSsidsSetCfm *msg__; \
|
|
CsrWifiSmeCloakedSsidsSetCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCloakedSsidsSetCfmSend(dst__, status__) \
|
|
CsrWifiSmeCloakedSsidsSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCoexConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the CoexConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCoexConfigGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCoexConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeCoexConfigGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeCoexConfigGetReq *msg__; \
|
|
CsrWifiSmeCoexConfigGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCoexConfigGetReqSend(src__) \
|
|
CsrWifiSmeCoexConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCoexConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
coexConfig - Reports the parameters used to configure the coexistence
|
|
behaviour
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCoexConfigGetCfmCreate(msg__, dst__, src__, status__, coexConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCoexConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->coexConfig = (coexConfig__);
|
|
|
|
#define CsrWifiSmeCoexConfigGetCfmSendTo(dst__, src__, status__, coexConfig__) \
|
|
{ \
|
|
CsrWifiSmeCoexConfigGetCfm *msg__; \
|
|
CsrWifiSmeCoexConfigGetCfmCreate(msg__, dst__, src__, status__, coexConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCoexConfigGetCfmSend(dst__, status__, coexConfig__) \
|
|
CsrWifiSmeCoexConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, coexConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCoexConfigSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the CoexConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
coexConfig - Configures the coexistence behaviour
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCoexConfigSetReqCreate(msg__, dst__, src__, coexConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCoexConfigSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_SET_REQ, dst__, src__); \
|
|
msg__->coexConfig = (coexConfig__);
|
|
|
|
#define CsrWifiSmeCoexConfigSetReqSendTo(dst__, src__, coexConfig__) \
|
|
{ \
|
|
CsrWifiSmeCoexConfigSetReq *msg__; \
|
|
CsrWifiSmeCoexConfigSetReqCreate(msg__, dst__, src__, coexConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCoexConfigSetReqSend(src__, coexConfig__) \
|
|
CsrWifiSmeCoexConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, coexConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCoexConfigSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCoexConfigSetCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCoexConfigSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_SET_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeCoexConfigSetCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeCoexConfigSetCfm *msg__; \
|
|
CsrWifiSmeCoexConfigSetCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCoexConfigSetCfmSend(dst__, status__) \
|
|
CsrWifiSmeCoexConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCoexInfoGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the CoexInfo parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCoexInfoGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCoexInfoGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_INFO_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeCoexInfoGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeCoexInfoGetReq *msg__; \
|
|
CsrWifiSmeCoexInfoGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCoexInfoGetReqSend(src__) \
|
|
CsrWifiSmeCoexInfoGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCoexInfoGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
coexInfo - Reports information and state related to coexistence.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCoexInfoGetCfmCreate(msg__, dst__, src__, status__, coexInfo__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCoexInfoGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_INFO_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->coexInfo = (coexInfo__);
|
|
|
|
#define CsrWifiSmeCoexInfoGetCfmSendTo(dst__, src__, status__, coexInfo__) \
|
|
{ \
|
|
CsrWifiSmeCoexInfoGetCfm *msg__; \
|
|
CsrWifiSmeCoexInfoGetCfmCreate(msg__, dst__, src__, status__, coexInfo__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCoexInfoGetCfmSend(dst__, status__, coexInfo__) \
|
|
CsrWifiSmeCoexInfoGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, coexInfo__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeConnectReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application calls this primitive to start the
|
|
process of joining an 802.11 wireless network or to start an ad hoc
|
|
network.
|
|
The structure pointed by connectionConfig contains parameters describing
|
|
the network to join or, in case of an ad hoc network, to host or join.
|
|
The SME will select a network, perform the IEEE 802.11 Join, Authenticate
|
|
and Associate exchanges.
|
|
The SME selects the networks from the current scan list that match both
|
|
the SSID and BSSID, however either or both of these may be the wildcard
|
|
value. Using this rule, the following operations are possible:
|
|
* To connect to a network by name, specify the SSID and set the BSSID to
|
|
0xFF 0xFF 0xFF 0xFF 0xFF 0xFF. If there are two or more networks visible,
|
|
the SME will select the one with the strongest signal.
|
|
* To connect to a specific network, specify the BSSID. The SSID is
|
|
optional, but if given it must match the SSID of the network. An empty
|
|
SSID may be specified by setting the SSID length to zero. Please note
|
|
that if the BSSID is specified (i.e. not equal to 0xFF 0xFF 0xFF 0xFF
|
|
0xFF 0xFF), the SME will not attempt to roam if signal conditions become
|
|
poor, even if there is an alternative AP with an SSID that matches the
|
|
current network SSID.
|
|
* To connect to any network matching the other parameters (i.e. security,
|
|
etc), set the SSID length to zero and set the BSSID to 0xFF 0xFF 0xFF
|
|
0xFF 0xFF 0xFF. In this case, the SME will order all available networks
|
|
by their signal strengths and will iterate through this list until it
|
|
successfully connects.
|
|
NOTE: Specifying the BSSID will restrict the selection to one specific
|
|
network. If SSID and BSSID are given, they must both match the network
|
|
for it to be selected. To select a network based on the SSID only, the
|
|
wireless manager application must set the BSSID to 0xFF 0xFF 0xFF 0xFF
|
|
0xFF 0xFF.
|
|
The SME will try to connect to each network that matches the provided
|
|
parameters, one by one, until it succeeds or has tried unsuccessfully
|
|
with all the matching networks.
|
|
If there is no network that matches the parameters and the request allows
|
|
to host an ad hoc network, the SME will advertise a new ad hoc network
|
|
instead.
|
|
If the SME cannot connect, it will notify the failure in the confirm.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
connectionConfig - Describes the candidate network to join or to host.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeConnectReqCreate(msg__, dst__, src__, interfaceTag__, connectionConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeConnectReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECT_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->connectionConfig = (connectionConfig__);
|
|
|
|
#define CsrWifiSmeConnectReqSendTo(dst__, src__, interfaceTag__, connectionConfig__) \
|
|
{ \
|
|
CsrWifiSmeConnectReq *msg__; \
|
|
CsrWifiSmeConnectReqCreate(msg__, dst__, src__, interfaceTag__, connectionConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeConnectReqSend(src__, interfaceTag__, connectionConfig__) \
|
|
CsrWifiSmeConnectReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, connectionConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeConnectCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME calls this primitive when the connection exchange is complete or
|
|
all connection attempts fail.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request.
|
|
CSR_WIFI_SME_STATUS_NOT_FOUND: all attempts by the SME to
|
|
locate the requested AP failed
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeConnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeConnectCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECT_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeConnectCfmSendTo(dst__, src__, interfaceTag__, status__) \
|
|
{ \
|
|
CsrWifiSmeConnectCfm *msg__; \
|
|
CsrWifiSmeConnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeConnectCfmSend(dst__, interfaceTag__, status__) \
|
|
CsrWifiSmeConnectCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeConnectionConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the ConnectionConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeConnectionConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeConnectionConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_CONFIG_GET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__);
|
|
|
|
#define CsrWifiSmeConnectionConfigGetReqSendTo(dst__, src__, interfaceTag__) \
|
|
{ \
|
|
CsrWifiSmeConnectionConfigGetReq *msg__; \
|
|
CsrWifiSmeConnectionConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeConnectionConfigGetReqSend(src__, interfaceTag__) \
|
|
CsrWifiSmeConnectionConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeConnectionConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
connectionConfig - Parameters used by the SME for selecting a network
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeConnectionConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeConnectionConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->connectionConfig = (connectionConfig__);
|
|
|
|
#define CsrWifiSmeConnectionConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, connectionConfig__) \
|
|
{ \
|
|
CsrWifiSmeConnectionConfigGetCfm *msg__; \
|
|
CsrWifiSmeConnectionConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeConnectionConfigGetCfmSend(dst__, interfaceTag__, status__, connectionConfig__) \
|
|
CsrWifiSmeConnectionConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeConnectionInfoGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the ConnectionInfo parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeConnectionInfoGetReqCreate(msg__, dst__, src__, interfaceTag__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeConnectionInfoGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_INFO_GET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__);
|
|
|
|
#define CsrWifiSmeConnectionInfoGetReqSendTo(dst__, src__, interfaceTag__) \
|
|
{ \
|
|
CsrWifiSmeConnectionInfoGetReq *msg__; \
|
|
CsrWifiSmeConnectionInfoGetReqCreate(msg__, dst__, src__, interfaceTag__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeConnectionInfoGetReqSend(src__, interfaceTag__) \
|
|
CsrWifiSmeConnectionInfoGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeConnectionInfoGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
connectionInfo - Information about the current connection
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeConnectionInfoGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeConnectionInfoGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_INFO_GET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->connectionInfo = (connectionInfo__);
|
|
|
|
#define CsrWifiSmeConnectionInfoGetCfmSendTo(dst__, src__, interfaceTag__, status__, connectionInfo__) \
|
|
{ \
|
|
CsrWifiSmeConnectionInfoGetCfm *msg__; \
|
|
CsrWifiSmeConnectionInfoGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeConnectionInfoGetCfmSend(dst__, interfaceTag__, status__, connectionInfo__) \
|
|
CsrWifiSmeConnectionInfoGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionInfo__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeConnectionQualityIndSend
|
|
|
|
DESCRIPTION
|
|
The SME sends this primitive to all the tasks that have registered to
|
|
receive it whenever the value of the current connection quality
|
|
parameters change by more than a certain configurable amount.
|
|
The wireless manager application may configure the trigger thresholds for
|
|
this indication using the field in smeConfig parameter of
|
|
CSR_WIFI_SME_SME_CONFIG_SET_REQ.
|
|
Connection quality messages can be suppressed by setting both thresholds
|
|
to zero.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
linkQuality - Indicates the quality of the link
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeConnectionQualityIndCreate(msg__, dst__, src__, interfaceTag__, linkQuality__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeConnectionQualityInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_QUALITY_IND, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->linkQuality = (linkQuality__);
|
|
|
|
#define CsrWifiSmeConnectionQualityIndSendTo(dst__, src__, interfaceTag__, linkQuality__) \
|
|
{ \
|
|
CsrWifiSmeConnectionQualityInd *msg__; \
|
|
CsrWifiSmeConnectionQualityIndCreate(msg__, dst__, src__, interfaceTag__, linkQuality__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeConnectionQualityIndSend(dst__, interfaceTag__, linkQuality__) \
|
|
CsrWifiSmeConnectionQualityIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, linkQuality__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeConnectionStatsGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the ConnectionStats parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeConnectionStatsGetReqCreate(msg__, dst__, src__, interfaceTag__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeConnectionStatsGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_STATS_GET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__);
|
|
|
|
#define CsrWifiSmeConnectionStatsGetReqSendTo(dst__, src__, interfaceTag__) \
|
|
{ \
|
|
CsrWifiSmeConnectionStatsGetReq *msg__; \
|
|
CsrWifiSmeConnectionStatsGetReqCreate(msg__, dst__, src__, interfaceTag__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeConnectionStatsGetReqSend(src__, interfaceTag__) \
|
|
CsrWifiSmeConnectionStatsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeConnectionStatsGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
connectionStats - Statistics for current connection.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeConnectionStatsGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionStats__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeConnectionStatsGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_STATS_GET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->connectionStats = (connectionStats__);
|
|
|
|
#define CsrWifiSmeConnectionStatsGetCfmSendTo(dst__, src__, interfaceTag__, status__, connectionStats__) \
|
|
{ \
|
|
CsrWifiSmeConnectionStatsGetCfm *msg__; \
|
|
CsrWifiSmeConnectionStatsGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionStats__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeConnectionStatsGetCfmSend(dst__, interfaceTag__, status__, connectionStats__) \
|
|
CsrWifiSmeConnectionStatsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionStats__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeCoreDumpIndSend
|
|
|
|
DESCRIPTION
|
|
The SME will send this primitive to all the tasks that have registered to
|
|
receive Wi-Fi Chip core dump data.
|
|
The core dump data may be fragmented and sent using more than one
|
|
indication.
|
|
To indicate that all the data has been sent, the last indication contains
|
|
a 'length' of 0 and 'data' of NULL.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
dataLength - Number of bytes in the buffer pointed to by 'data'
|
|
data - Pointer to the buffer containing 'dataLength' bytes of core
|
|
dump data
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeCoreDumpIndCreate(msg__, dst__, src__, dataLength__, data__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeCoreDumpInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CORE_DUMP_IND, dst__, src__); \
|
|
msg__->dataLength = (dataLength__); \
|
|
msg__->data = (data__);
|
|
|
|
#define CsrWifiSmeCoreDumpIndSendTo(dst__, src__, dataLength__, data__) \
|
|
{ \
|
|
CsrWifiSmeCoreDumpInd *msg__; \
|
|
CsrWifiSmeCoreDumpIndCreate(msg__, dst__, src__, dataLength__, data__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeCoreDumpIndSend(dst__, dataLength__, data__) \
|
|
CsrWifiSmeCoreDumpIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, dataLength__, data__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeDeactivateReqSend
|
|
|
|
DESCRIPTION
|
|
The WMA sends this primitive to deactivate the SME.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeDeactivateReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeDeactivateReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DEACTIVATE_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeDeactivateReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeDeactivateReq *msg__; \
|
|
CsrWifiSmeDeactivateReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeDeactivateReqSend(src__) \
|
|
CsrWifiSmeDeactivateReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeDeactivateCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME sends this primitive when the deactivation is complete.
|
|
The WMA cannot send any more primitives until it actives the SME again
|
|
sending another CSR_WIFI_SME_ACTIVATE_REQ.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeDeactivateCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeDeactivateCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DEACTIVATE_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeDeactivateCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeDeactivateCfm *msg__; \
|
|
CsrWifiSmeDeactivateCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeDeactivateCfmSend(dst__, status__) \
|
|
CsrWifiSmeDeactivateCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeDisconnectReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application may disconnect from the current network
|
|
by calling this primitive
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeDisconnectReqCreate(msg__, dst__, src__, interfaceTag__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeDisconnectReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DISCONNECT_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__);
|
|
|
|
#define CsrWifiSmeDisconnectReqSendTo(dst__, src__, interfaceTag__) \
|
|
{ \
|
|
CsrWifiSmeDisconnectReq *msg__; \
|
|
CsrWifiSmeDisconnectReqCreate(msg__, dst__, src__, interfaceTag__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeDisconnectReqSend(src__, interfaceTag__) \
|
|
CsrWifiSmeDisconnectReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeDisconnectCfmSend
|
|
|
|
DESCRIPTION
|
|
On reception of CSR_WIFI_SME_DISCONNECT_REQ the SME will perform a
|
|
disconnect operation, sending a CsrWifiSmeMediaStatusInd with
|
|
CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED and then call this primitive when
|
|
disconnection is complete.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeDisconnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeDisconnectCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DISCONNECT_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeDisconnectCfmSendTo(dst__, src__, interfaceTag__, status__) \
|
|
{ \
|
|
CsrWifiSmeDisconnectCfm *msg__; \
|
|
CsrWifiSmeDisconnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeDisconnectCfmSend(dst__, interfaceTag__, status__) \
|
|
CsrWifiSmeDisconnectCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeErrorIndSend
|
|
|
|
DESCRIPTION
|
|
Important error message indicating a error of some importance
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
errorMessage - Contains the error message.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeErrorIndCreate(msg__, dst__, src__, errorMessage__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeErrorInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ERROR_IND, dst__, src__); \
|
|
msg__->errorMessage = (errorMessage__);
|
|
|
|
#define CsrWifiSmeErrorIndSendTo(dst__, src__, errorMessage__) \
|
|
{ \
|
|
CsrWifiSmeErrorInd *msg__; \
|
|
CsrWifiSmeErrorIndCreate(msg__, dst__, src__, errorMessage__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeErrorIndSend(dst__, errorMessage__) \
|
|
CsrWifiSmeErrorIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, errorMessage__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeEventMaskSetReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application may register with the SME to receive
|
|
notification of interesting events. Indications will be sent only if the
|
|
wireless manager explicitly registers to be notified of that event.
|
|
indMask is a bit mask of values defined in CsrWifiSmeIndicationsMask.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
indMask - Set mask with values from CsrWifiSmeIndications
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeEventMaskSetReqCreate(msg__, dst__, src__, indMask__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeEventMaskSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_EVENT_MASK_SET_REQ, dst__, src__); \
|
|
msg__->indMask = (indMask__);
|
|
|
|
#define CsrWifiSmeEventMaskSetReqSendTo(dst__, src__, indMask__) \
|
|
{ \
|
|
CsrWifiSmeEventMaskSetReq *msg__; \
|
|
CsrWifiSmeEventMaskSetReqCreate(msg__, dst__, src__, indMask__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeEventMaskSetReqSend(src__, indMask__) \
|
|
CsrWifiSmeEventMaskSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, indMask__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeEventMaskSetCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME calls the primitive to report the result of the request
|
|
primitive.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeEventMaskSetCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeEventMaskSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_EVENT_MASK_SET_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeEventMaskSetCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeEventMaskSetCfm *msg__; \
|
|
CsrWifiSmeEventMaskSetCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeEventMaskSetCfmSend(dst__, status__) \
|
|
CsrWifiSmeEventMaskSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeHostConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the hostConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeHostConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeHostConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_GET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__);
|
|
|
|
#define CsrWifiSmeHostConfigGetReqSendTo(dst__, src__, interfaceTag__) \
|
|
{ \
|
|
CsrWifiSmeHostConfigGetReq *msg__; \
|
|
CsrWifiSmeHostConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeHostConfigGetReqSend(src__, interfaceTag__) \
|
|
CsrWifiSmeHostConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeHostConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
hostConfig - Current host power state.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeHostConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, hostConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeHostConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->hostConfig = (hostConfig__);
|
|
|
|
#define CsrWifiSmeHostConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, hostConfig__) \
|
|
{ \
|
|
CsrWifiSmeHostConfigGetCfm *msg__; \
|
|
CsrWifiSmeHostConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, hostConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeHostConfigGetCfmSend(dst__, interfaceTag__, status__, hostConfig__) \
|
|
CsrWifiSmeHostConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, hostConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeHostConfigSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the hostConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
hostConfig - Communicates a change of host power state (for example, on
|
|
mains power, on battery power etc) and of the periodicity of
|
|
traffic data
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeHostConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, hostConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeHostConfigSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_SET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->hostConfig = (hostConfig__);
|
|
|
|
#define CsrWifiSmeHostConfigSetReqSendTo(dst__, src__, interfaceTag__, hostConfig__) \
|
|
{ \
|
|
CsrWifiSmeHostConfigSetReq *msg__; \
|
|
CsrWifiSmeHostConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, hostConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeHostConfigSetReqSend(src__, interfaceTag__, hostConfig__) \
|
|
CsrWifiSmeHostConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, hostConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeHostConfigSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeHostConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeHostConfigSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_SET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeHostConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
|
|
{ \
|
|
CsrWifiSmeHostConfigSetCfm *msg__; \
|
|
CsrWifiSmeHostConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeHostConfigSetCfmSend(dst__, interfaceTag__, status__) \
|
|
CsrWifiSmeHostConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeIbssStationIndSend
|
|
|
|
DESCRIPTION
|
|
The SME will send this primitive to indicate that a station has joined or
|
|
left the ad-hoc network.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
address - MAC address of the station that has joined or left
|
|
isconnected - TRUE if the station joined, FALSE if the station left
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeIbssStationIndCreate(msg__, dst__, src__, address__, isconnected__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeIbssStationInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_IBSS_STATION_IND, dst__, src__); \
|
|
msg__->address = (address__); \
|
|
msg__->isconnected = (isconnected__);
|
|
|
|
#define CsrWifiSmeIbssStationIndSendTo(dst__, src__, address__, isconnected__) \
|
|
{ \
|
|
CsrWifiSmeIbssStationInd *msg__; \
|
|
CsrWifiSmeIbssStationIndCreate(msg__, dst__, src__, address__, isconnected__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeIbssStationIndSend(dst__, address__, isconnected__) \
|
|
CsrWifiSmeIbssStationIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, address__, isconnected__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeInfoIndSend
|
|
|
|
DESCRIPTION
|
|
Message indicating a some info about current activity. Mostly of interest
|
|
in testing but may be useful in the field.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
infoMessage - Contains the message.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeInfoIndCreate(msg__, dst__, src__, infoMessage__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeInfoInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INFO_IND, dst__, src__); \
|
|
msg__->infoMessage = (infoMessage__);
|
|
|
|
#define CsrWifiSmeInfoIndSendTo(dst__, src__, infoMessage__) \
|
|
{ \
|
|
CsrWifiSmeInfoInd *msg__; \
|
|
CsrWifiSmeInfoIndCreate(msg__, dst__, src__, infoMessage__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeInfoIndSend(dst__, infoMessage__) \
|
|
CsrWifiSmeInfoIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, infoMessage__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeInterfaceCapabilityGetReqSend
|
|
|
|
DESCRIPTION
|
|
The Wireless Manager calls this primitive to ask the SME for the
|
|
capabilities of the supported interfaces
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeInterfaceCapabilityGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeInterfaceCapabilityGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeInterfaceCapabilityGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeInterfaceCapabilityGetReq *msg__; \
|
|
CsrWifiSmeInterfaceCapabilityGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeInterfaceCapabilityGetReqSend(src__) \
|
|
CsrWifiSmeInterfaceCapabilityGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeInterfaceCapabilityGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Result of the request
|
|
numInterfaces - Number of the interfaces supported
|
|
capBitmap - Points to the list of capabilities bitmaps provided for each
|
|
interface.
|
|
The bits represent the following capabilities:
|
|
-bits 7 to 4-Reserved
|
|
-bit 3-AMP
|
|
-bit 2-P2P
|
|
-bit 1-AP
|
|
-bit 0-STA
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeInterfaceCapabilityGetCfmCreate(msg__, dst__, src__, status__, numInterfaces__, capBitmap__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeInterfaceCapabilityGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->numInterfaces = (numInterfaces__); \
|
|
memcpy(msg__->capBitmap, (capBitmap__), sizeof(u8) * 2);
|
|
|
|
#define CsrWifiSmeInterfaceCapabilityGetCfmSendTo(dst__, src__, status__, numInterfaces__, capBitmap__) \
|
|
{ \
|
|
CsrWifiSmeInterfaceCapabilityGetCfm *msg__; \
|
|
CsrWifiSmeInterfaceCapabilityGetCfmCreate(msg__, dst__, src__, status__, numInterfaces__, capBitmap__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeInterfaceCapabilityGetCfmSend(dst__, status__, numInterfaces__, capBitmap__) \
|
|
CsrWifiSmeInterfaceCapabilityGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, numInterfaces__, capBitmap__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeKeyReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application calls this primitive to add or remove
|
|
keys that the chip should use for encryption of data.
|
|
The interface allows the wireless manager application to add and remove
|
|
keys according to the specified action.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
action - The value of the CsrWifiSmeListAction parameter instructs the
|
|
driver to modify or provide the list of keys.
|
|
CSR_WIFI_SME_LIST_ACTION_GET is not supported here.
|
|
key - Key to be added or removed
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeKeyReqCreate(msg__, dst__, src__, interfaceTag__, action__, key__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeKeyReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_KEY_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->action = (action__); \
|
|
msg__->key = (key__);
|
|
|
|
#define CsrWifiSmeKeyReqSendTo(dst__, src__, interfaceTag__, action__, key__) \
|
|
{ \
|
|
CsrWifiSmeKeyReq *msg__; \
|
|
CsrWifiSmeKeyReqCreate(msg__, dst__, src__, interfaceTag__, action__, key__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeKeyReqSend(src__, interfaceTag__, action__, key__) \
|
|
CsrWifiSmeKeyReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, key__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeKeyCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME calls the primitive to report the result of the request
|
|
primitive.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
action - Action in the request
|
|
keyType - Type of the key added/deleted
|
|
peerMacAddress - Peer MAC Address of the key added/deleted
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeKeyCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, keyType__, peerMacAddress__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeKeyCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_KEY_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->action = (action__); \
|
|
msg__->keyType = (keyType__); \
|
|
msg__->peerMacAddress = (peerMacAddress__);
|
|
|
|
#define CsrWifiSmeKeyCfmSendTo(dst__, src__, interfaceTag__, status__, action__, keyType__, peerMacAddress__) \
|
|
{ \
|
|
CsrWifiSmeKeyCfm *msg__; \
|
|
CsrWifiSmeKeyCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, keyType__, peerMacAddress__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeKeyCfmSend(dst__, interfaceTag__, status__, action__, keyType__, peerMacAddress__) \
|
|
CsrWifiSmeKeyCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, keyType__, peerMacAddress__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeLinkQualityGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the LinkQuality parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeLinkQualityGetReqCreate(msg__, dst__, src__, interfaceTag__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeLinkQualityGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_LINK_QUALITY_GET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__);
|
|
|
|
#define CsrWifiSmeLinkQualityGetReqSendTo(dst__, src__, interfaceTag__) \
|
|
{ \
|
|
CsrWifiSmeLinkQualityGetReq *msg__; \
|
|
CsrWifiSmeLinkQualityGetReqCreate(msg__, dst__, src__, interfaceTag__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeLinkQualityGetReqSend(src__, interfaceTag__) \
|
|
CsrWifiSmeLinkQualityGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeLinkQualityGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
linkQuality - Indicates the quality of the link
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeLinkQualityGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, linkQuality__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeLinkQualityGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_LINK_QUALITY_GET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->linkQuality = (linkQuality__);
|
|
|
|
#define CsrWifiSmeLinkQualityGetCfmSendTo(dst__, src__, interfaceTag__, status__, linkQuality__) \
|
|
{ \
|
|
CsrWifiSmeLinkQualityGetCfm *msg__; \
|
|
CsrWifiSmeLinkQualityGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, linkQuality__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeLinkQualityGetCfmSend(dst__, interfaceTag__, status__, linkQuality__) \
|
|
CsrWifiSmeLinkQualityGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, linkQuality__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMediaStatusIndSend
|
|
|
|
DESCRIPTION
|
|
The SME sends this primitive to all the tasks that have registered to
|
|
receive it when a network connection is established, lost or has moved to
|
|
another AP.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
mediaStatus - Indicates the media status
|
|
connectionInfo - This parameter is relevant only if the mediaStatus is
|
|
CSR_WIFI_SME_MEDIA_STATUS_CONNECTED:
|
|
it points to the connection information for the new network
|
|
disassocReason - This parameter is relevant only if the mediaStatus is
|
|
CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED:
|
|
if a disassociation has occurred it gives the reason of the
|
|
disassociation
|
|
deauthReason - This parameter is relevant only if the mediaStatus is
|
|
CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED:
|
|
if a deauthentication has occurred it gives the reason of
|
|
the deauthentication
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMediaStatusIndCreate(msg__, dst__, src__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMediaStatusInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MEDIA_STATUS_IND, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->mediaStatus = (mediaStatus__); \
|
|
msg__->connectionInfo = (connectionInfo__); \
|
|
msg__->disassocReason = (disassocReason__); \
|
|
msg__->deauthReason = (deauthReason__);
|
|
|
|
#define CsrWifiSmeMediaStatusIndSendTo(dst__, src__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__) \
|
|
{ \
|
|
CsrWifiSmeMediaStatusInd *msg__; \
|
|
CsrWifiSmeMediaStatusIndCreate(msg__, dst__, src__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMediaStatusIndSend(dst__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__) \
|
|
CsrWifiSmeMediaStatusIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMibConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the MibConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMibConfigGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMibConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeMibConfigGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeMibConfigGetReq *msg__; \
|
|
CsrWifiSmeMibConfigGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMibConfigGetReqSend(src__) \
|
|
CsrWifiSmeMibConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMibConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
mibConfig - Reports various IEEE 802.11 attributes as currently configured
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMibConfigGetCfmCreate(msg__, dst__, src__, status__, mibConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMibConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->mibConfig = (mibConfig__);
|
|
|
|
#define CsrWifiSmeMibConfigGetCfmSendTo(dst__, src__, status__, mibConfig__) \
|
|
{ \
|
|
CsrWifiSmeMibConfigGetCfm *msg__; \
|
|
CsrWifiSmeMibConfigGetCfmCreate(msg__, dst__, src__, status__, mibConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMibConfigGetCfmSend(dst__, status__, mibConfig__) \
|
|
CsrWifiSmeMibConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, mibConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMibConfigSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the MibConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
mibConfig - Conveys the desired value of various IEEE 802.11 attributes as
|
|
currently configured
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMibConfigSetReqCreate(msg__, dst__, src__, mibConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMibConfigSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_SET_REQ, dst__, src__); \
|
|
msg__->mibConfig = (mibConfig__);
|
|
|
|
#define CsrWifiSmeMibConfigSetReqSendTo(dst__, src__, mibConfig__) \
|
|
{ \
|
|
CsrWifiSmeMibConfigSetReq *msg__; \
|
|
CsrWifiSmeMibConfigSetReqCreate(msg__, dst__, src__, mibConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMibConfigSetReqSend(src__, mibConfig__) \
|
|
CsrWifiSmeMibConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMibConfigSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMibConfigSetCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMibConfigSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_SET_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeMibConfigSetCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeMibConfigSetCfm *msg__; \
|
|
CsrWifiSmeMibConfigSetCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMibConfigSetCfmSend(dst__, status__) \
|
|
CsrWifiSmeMibConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMibGetCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME calls this primitive to return the requested MIB variable values.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
mibAttributeLength - Length of mibAttribute
|
|
mibAttribute - Points to the VarBind or VarBindList containing the
|
|
names and values of the MIB variables requested
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMibGetCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMibGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->mibAttributeLength = (mibAttributeLength__); \
|
|
msg__->mibAttribute = (mibAttribute__);
|
|
|
|
#define CsrWifiSmeMibGetCfmSendTo(dst__, src__, status__, mibAttributeLength__, mibAttribute__) \
|
|
{ \
|
|
CsrWifiSmeMibGetCfm *msg__; \
|
|
CsrWifiSmeMibGetCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMibGetCfmSend(dst__, status__, mibAttributeLength__, mibAttribute__) \
|
|
CsrWifiSmeMibGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, mibAttributeLength__, mibAttribute__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMibGetNextReqSend
|
|
|
|
DESCRIPTION
|
|
To read a sequence of MIB parameters, for example a table, call this
|
|
primitive to find the name of the next MIB variable
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
mibAttributeLength - Length of mibAttribute
|
|
mibAttribute - Points to a VarBind or VarBindList containing the
|
|
name(s) of the MIB variable(s) to search from.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMibGetNextReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMibGetNextReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_NEXT_REQ, dst__, src__); \
|
|
msg__->mibAttributeLength = (mibAttributeLength__); \
|
|
msg__->mibAttribute = (mibAttribute__);
|
|
|
|
#define CsrWifiSmeMibGetNextReqSendTo(dst__, src__, mibAttributeLength__, mibAttribute__) \
|
|
{ \
|
|
CsrWifiSmeMibGetNextReq *msg__; \
|
|
CsrWifiSmeMibGetNextReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMibGetNextReqSend(src__, mibAttributeLength__, mibAttribute__) \
|
|
CsrWifiSmeMibGetNextReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibAttributeLength__, mibAttribute__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMibGetNextCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME calls this primitive to return the requested MIB name(s).
|
|
The wireless manager application can then read the value of the MIB
|
|
variable using CSR_WIFI_SME_MIB_GET_REQ, using the names provided.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
mibAttributeLength - Length of mibAttribute
|
|
mibAttribute - Points to a VarBind or VarBindList containing the
|
|
name(s) of the MIB variable(s) lexicographically
|
|
following the name(s) given in the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMibGetNextCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMibGetNextCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_NEXT_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->mibAttributeLength = (mibAttributeLength__); \
|
|
msg__->mibAttribute = (mibAttribute__);
|
|
|
|
#define CsrWifiSmeMibGetNextCfmSendTo(dst__, src__, status__, mibAttributeLength__, mibAttribute__) \
|
|
{ \
|
|
CsrWifiSmeMibGetNextCfm *msg__; \
|
|
CsrWifiSmeMibGetNextCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMibGetNextCfmSend(dst__, status__, mibAttributeLength__, mibAttribute__) \
|
|
CsrWifiSmeMibGetNextCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, mibAttributeLength__, mibAttribute__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMibGetReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application calls this primitive to retrieve one or
|
|
more MIB variables.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
mibAttributeLength - Length of mibAttribute
|
|
mibAttribute - Points to the VarBind or VarBindList containing the
|
|
names of the MIB variables to be retrieved
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMibGetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMibGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_REQ, dst__, src__); \
|
|
msg__->mibAttributeLength = (mibAttributeLength__); \
|
|
msg__->mibAttribute = (mibAttribute__);
|
|
|
|
#define CsrWifiSmeMibGetReqSendTo(dst__, src__, mibAttributeLength__, mibAttribute__) \
|
|
{ \
|
|
CsrWifiSmeMibGetReq *msg__; \
|
|
CsrWifiSmeMibGetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMibGetReqSend(src__, mibAttributeLength__, mibAttribute__) \
|
|
CsrWifiSmeMibGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibAttributeLength__, mibAttribute__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMibSetReqSend
|
|
|
|
DESCRIPTION
|
|
The SME provides raw access to the MIB on the chip, which may be used by
|
|
some configuration or diagnostic utilities, but is not normally needed by
|
|
the wireless manager application.
|
|
The MIB access functions use BER encoded names (OID) of the MIB
|
|
parameters and BER encoded values, as described in the chip Host
|
|
Interface Protocol Specification.
|
|
The MIB parameters are described in 'Wi-Fi 5.0.0 Management Information
|
|
Base Reference Guide'.
|
|
The wireless manager application calls this primitive to set one or more
|
|
MIB variables
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
mibAttributeLength - Length of mibAttribute
|
|
mibAttribute - Points to the VarBind or VarBindList containing the
|
|
names and values of the MIB variables to set
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMibSetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMibSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_SET_REQ, dst__, src__); \
|
|
msg__->mibAttributeLength = (mibAttributeLength__); \
|
|
msg__->mibAttribute = (mibAttribute__);
|
|
|
|
#define CsrWifiSmeMibSetReqSendTo(dst__, src__, mibAttributeLength__, mibAttribute__) \
|
|
{ \
|
|
CsrWifiSmeMibSetReq *msg__; \
|
|
CsrWifiSmeMibSetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMibSetReqSend(src__, mibAttributeLength__, mibAttribute__) \
|
|
CsrWifiSmeMibSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibAttributeLength__, mibAttribute__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMibSetCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME calls the primitive to report the result of the set primitive.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMibSetCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMibSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_SET_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeMibSetCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeMibSetCfm *msg__; \
|
|
CsrWifiSmeMibSetCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMibSetCfmSend(dst__, status__) \
|
|
CsrWifiSmeMibSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMicFailureIndSend
|
|
|
|
DESCRIPTION
|
|
The SME sends this primitive to all the tasks that have registered to
|
|
receive it whenever the chip firmware reports a MIC failure.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
secondFailure - TRUE if this indication is for a second failure in 60
|
|
seconds
|
|
count - The number of MIC failure events since the connection was
|
|
established
|
|
address - MAC address of the transmitter that caused the MIC failure
|
|
keyType - Type of key for which the failure occurred
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMicFailureIndCreate(msg__, dst__, src__, interfaceTag__, secondFailure__, count__, address__, keyType__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMicFailureInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIC_FAILURE_IND, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->secondFailure = (secondFailure__); \
|
|
msg__->count = (count__); \
|
|
msg__->address = (address__); \
|
|
msg__->keyType = (keyType__);
|
|
|
|
#define CsrWifiSmeMicFailureIndSendTo(dst__, src__, interfaceTag__, secondFailure__, count__, address__, keyType__) \
|
|
{ \
|
|
CsrWifiSmeMicFailureInd *msg__; \
|
|
CsrWifiSmeMicFailureIndCreate(msg__, dst__, src__, interfaceTag__, secondFailure__, count__, address__, keyType__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMicFailureIndSend(dst__, interfaceTag__, secondFailure__, count__, address__, keyType__) \
|
|
CsrWifiSmeMicFailureIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, secondFailure__, count__, address__, keyType__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMulticastAddressReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application calls this primitive to specify the
|
|
multicast addresses which the chip should recognise. The interface allows
|
|
the wireless manager application to query, add, remove and flush the
|
|
multicast addresses for the network interface according to the specified
|
|
action.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
action - The value of the CsrWifiSmeListAction parameter
|
|
instructs the driver to modify or provide the list of
|
|
MAC addresses.
|
|
setAddressesCount - Number of MAC addresses sent with the primitive
|
|
setAddresses - Pointer to the list of MAC Addresses sent with the
|
|
primitive, set to NULL if none is sent.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMulticastAddressReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMulticastAddressReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MULTICAST_ADDRESS_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->action = (action__); \
|
|
msg__->setAddressesCount = (setAddressesCount__); \
|
|
msg__->setAddresses = (setAddresses__);
|
|
|
|
#define CsrWifiSmeMulticastAddressReqSendTo(dst__, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \
|
|
{ \
|
|
CsrWifiSmeMulticastAddressReq *msg__; \
|
|
CsrWifiSmeMulticastAddressReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMulticastAddressReqSend(src__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \
|
|
CsrWifiSmeMulticastAddressReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeMulticastAddressCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME will call this primitive when the operation is complete. For a
|
|
GET action, this primitive reports the current list of MAC addresses.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
action - Action in the request
|
|
getAddressesCount - This parameter is only relevant if action is
|
|
CSR_WIFI_SME_LIST_ACTION_GET:
|
|
number of MAC addresses sent with the primitive
|
|
getAddresses - Pointer to the list of MAC Addresses sent with the
|
|
primitive, set to NULL if none is sent.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeMulticastAddressCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeMulticastAddressCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MULTICAST_ADDRESS_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->action = (action__); \
|
|
msg__->getAddressesCount = (getAddressesCount__); \
|
|
msg__->getAddresses = (getAddresses__);
|
|
|
|
#define CsrWifiSmeMulticastAddressCfmSendTo(dst__, src__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__) \
|
|
{ \
|
|
CsrWifiSmeMulticastAddressCfm *msg__; \
|
|
CsrWifiSmeMulticastAddressCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeMulticastAddressCfmSend(dst__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__) \
|
|
CsrWifiSmeMulticastAddressCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePacketFilterSetReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application should call this primitive to enable or
|
|
disable filtering of broadcast packets: uninteresting broadcast packets
|
|
will be dropped by the Wi-Fi chip, instead of passing them up to the
|
|
host.
|
|
This has the advantage of saving power in the host application processor
|
|
as it removes the need to process unwanted packets.
|
|
All broadcast packets are filtered according to the filter and the filter
|
|
mode provided, except ARP packets, which are filtered using
|
|
arpFilterAddress.
|
|
Filters are not cumulative: only the parameters specified in the most
|
|
recent successful request are significant.
|
|
For more information, see 'UniFi Firmware API Specification'.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
filterLength - Length of the filter in bytes.
|
|
filterLength=0 disables the filter previously set
|
|
filter - Points to the first byte of the filter provided, if any.
|
|
This shall include zero or more instance of the
|
|
information elements of one of these types
|
|
* Traffic Classification (TCLAS) elements
|
|
* WMM-SA TCLAS elements
|
|
mode - Specifies whether the filter selects or excludes packets
|
|
matching the filter
|
|
arpFilterAddress - IPv4 address to be used for filtering the ARP packets.
|
|
* If the specified address is the IPv4 broadcast address
|
|
(255.255.255.255), all ARP packets are reported to the
|
|
host,
|
|
* If the specified address is NOT the IPv4 broadcast
|
|
address, only ARP packets with the specified address in
|
|
the Source or Target Protocol Address fields are reported
|
|
to the host
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePacketFilterSetReqCreate(msg__, dst__, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePacketFilterSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PACKET_FILTER_SET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->filterLength = (filterLength__); \
|
|
msg__->filter = (filter__); \
|
|
msg__->mode = (mode__); \
|
|
msg__->arpFilterAddress = (arpFilterAddress__);
|
|
|
|
#define CsrWifiSmePacketFilterSetReqSendTo(dst__, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__) \
|
|
{ \
|
|
CsrWifiSmePacketFilterSetReq *msg__; \
|
|
CsrWifiSmePacketFilterSetReqCreate(msg__, dst__, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePacketFilterSetReqSend(src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__) \
|
|
CsrWifiSmePacketFilterSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePacketFilterSetCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME calls the primitive to report the result of the set primitive.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePacketFilterSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePacketFilterSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PACKET_FILTER_SET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmePacketFilterSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
|
|
{ \
|
|
CsrWifiSmePacketFilterSetCfm *msg__; \
|
|
CsrWifiSmePacketFilterSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePacketFilterSetCfmSend(dst__, interfaceTag__, status__) \
|
|
CsrWifiSmePacketFilterSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePermanentMacAddressGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive retrieves the MAC address stored in EEPROM
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePermanentMacAddressGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePermanentMacAddressGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PERMANENT_MAC_ADDRESS_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmePermanentMacAddressGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmePermanentMacAddressGetReq *msg__; \
|
|
CsrWifiSmePermanentMacAddressGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePermanentMacAddressGetReqSend(src__) \
|
|
CsrWifiSmePermanentMacAddressGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePermanentMacAddressGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
permanentMacAddress - MAC address stored in the EEPROM
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePermanentMacAddressGetCfmCreate(msg__, dst__, src__, status__, permanentMacAddress__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePermanentMacAddressGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PERMANENT_MAC_ADDRESS_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->permanentMacAddress = (permanentMacAddress__);
|
|
|
|
#define CsrWifiSmePermanentMacAddressGetCfmSendTo(dst__, src__, status__, permanentMacAddress__) \
|
|
{ \
|
|
CsrWifiSmePermanentMacAddressGetCfm *msg__; \
|
|
CsrWifiSmePermanentMacAddressGetCfmCreate(msg__, dst__, src__, status__, permanentMacAddress__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePermanentMacAddressGetCfmSend(dst__, status__, permanentMacAddress__) \
|
|
CsrWifiSmePermanentMacAddressGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, permanentMacAddress__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePmkidCandidateListIndSend
|
|
|
|
DESCRIPTION
|
|
The SME will send this primitive to all the tasks that have registered to
|
|
receive it when a new network supporting preauthentication and/or PMK
|
|
caching is seen.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an
|
|
interface
|
|
pmkidCandidatesCount - Number of PMKID candidates provided
|
|
pmkidCandidates - Points to the first PMKID candidate
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePmkidCandidateListIndCreate(msg__, dst__, src__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePmkidCandidateListInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PMKID_CANDIDATE_LIST_IND, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->pmkidCandidatesCount = (pmkidCandidatesCount__); \
|
|
msg__->pmkidCandidates = (pmkidCandidates__);
|
|
|
|
#define CsrWifiSmePmkidCandidateListIndSendTo(dst__, src__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__) \
|
|
{ \
|
|
CsrWifiSmePmkidCandidateListInd *msg__; \
|
|
CsrWifiSmePmkidCandidateListIndCreate(msg__, dst__, src__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePmkidCandidateListIndSend(dst__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__) \
|
|
CsrWifiSmePmkidCandidateListIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePmkidReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application calls this primitive to request an
|
|
operation on the SME PMKID list.
|
|
The action argument specifies the operation to perform.
|
|
When the connection is complete, the wireless manager application may
|
|
then send and receive EAPOL packets to complete WPA or WPA2
|
|
authentication if appropriate.
|
|
The wireless manager application can then pass the resulting encryption
|
|
keys using this primitive.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
action - The value of the CsrWifiSmeListAction parameter instructs
|
|
the driver to modify or provide the list of PMKIDs.
|
|
setPmkidsCount - Number of PMKIDs sent with the primitive
|
|
setPmkids - Pointer to the list of PMKIDs sent with the primitive, set
|
|
to NULL if none is sent.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePmkidReqCreate(msg__, dst__, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePmkidReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PMKID_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->action = (action__); \
|
|
msg__->setPmkidsCount = (setPmkidsCount__); \
|
|
msg__->setPmkids = (setPmkids__);
|
|
|
|
#define CsrWifiSmePmkidReqSendTo(dst__, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__) \
|
|
{ \
|
|
CsrWifiSmePmkidReq *msg__; \
|
|
CsrWifiSmePmkidReqCreate(msg__, dst__, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePmkidReqSend(src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__) \
|
|
CsrWifiSmePmkidReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePmkidCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME will call this primitive when the operation is complete. For a
|
|
GET action, this primitive reports the current list of PMKIDs
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
action - Action in the request
|
|
getPmkidsCount - This parameter is only relevant if action is
|
|
CSR_WIFI_SME_LIST_ACTION_GET:
|
|
number of PMKIDs sent with the primitive
|
|
getPmkids - Pointer to the list of PMKIDs sent with the primitive, set
|
|
to NULL if none is sent.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePmkidCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePmkidCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PMKID_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->action = (action__); \
|
|
msg__->getPmkidsCount = (getPmkidsCount__); \
|
|
msg__->getPmkids = (getPmkids__);
|
|
|
|
#define CsrWifiSmePmkidCfmSendTo(dst__, src__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__) \
|
|
{ \
|
|
CsrWifiSmePmkidCfm *msg__; \
|
|
CsrWifiSmePmkidCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePmkidCfmSend(dst__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__) \
|
|
CsrWifiSmePmkidCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePowerConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the PowerConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePowerConfigGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePowerConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmePowerConfigGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmePowerConfigGetReq *msg__; \
|
|
CsrWifiSmePowerConfigGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePowerConfigGetReqSend(src__) \
|
|
CsrWifiSmePowerConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePowerConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
powerConfig - Returns the current parameters for the power configuration of
|
|
the firmware
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePowerConfigGetCfmCreate(msg__, dst__, src__, status__, powerConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePowerConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->powerConfig = (powerConfig__);
|
|
|
|
#define CsrWifiSmePowerConfigGetCfmSendTo(dst__, src__, status__, powerConfig__) \
|
|
{ \
|
|
CsrWifiSmePowerConfigGetCfm *msg__; \
|
|
CsrWifiSmePowerConfigGetCfmCreate(msg__, dst__, src__, status__, powerConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePowerConfigGetCfmSend(dst__, status__, powerConfig__) \
|
|
CsrWifiSmePowerConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, powerConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePowerConfigSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the PowerConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
powerConfig - Power saving configuration
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePowerConfigSetReqCreate(msg__, dst__, src__, powerConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePowerConfigSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_SET_REQ, dst__, src__); \
|
|
msg__->powerConfig = (powerConfig__);
|
|
|
|
#define CsrWifiSmePowerConfigSetReqSendTo(dst__, src__, powerConfig__) \
|
|
{ \
|
|
CsrWifiSmePowerConfigSetReq *msg__; \
|
|
CsrWifiSmePowerConfigSetReqCreate(msg__, dst__, src__, powerConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePowerConfigSetReqSend(src__, powerConfig__) \
|
|
CsrWifiSmePowerConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, powerConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmePowerConfigSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmePowerConfigSetCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmePowerConfigSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_SET_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmePowerConfigSetCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmePowerConfigSetCfm *msg__; \
|
|
CsrWifiSmePowerConfigSetCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmePowerConfigSetCfmSend(dst__, status__) \
|
|
CsrWifiSmePowerConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeRegulatoryDomainInfoGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the RegulatoryDomainInfo parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeRegulatoryDomainInfoGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeRegulatoryDomainInfoGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_REGULATORY_DOMAIN_INFO_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeRegulatoryDomainInfoGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeRegulatoryDomainInfoGetReq *msg__; \
|
|
CsrWifiSmeRegulatoryDomainInfoGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeRegulatoryDomainInfoGetReqSend(src__) \
|
|
CsrWifiSmeRegulatoryDomainInfoGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeRegulatoryDomainInfoGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
regDomInfo - Reports information and state related to regulatory domain
|
|
operation.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeRegulatoryDomainInfoGetCfmCreate(msg__, dst__, src__, status__, regDomInfo__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeRegulatoryDomainInfoGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_REGULATORY_DOMAIN_INFO_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->regDomInfo = (regDomInfo__);
|
|
|
|
#define CsrWifiSmeRegulatoryDomainInfoGetCfmSendTo(dst__, src__, status__, regDomInfo__) \
|
|
{ \
|
|
CsrWifiSmeRegulatoryDomainInfoGetCfm *msg__; \
|
|
CsrWifiSmeRegulatoryDomainInfoGetCfmCreate(msg__, dst__, src__, status__, regDomInfo__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeRegulatoryDomainInfoGetCfmSend(dst__, status__, regDomInfo__) \
|
|
CsrWifiSmeRegulatoryDomainInfoGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, regDomInfo__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeRoamCompleteIndSend
|
|
|
|
DESCRIPTION
|
|
The SME will send this primitive to all the tasks that have registered to
|
|
receive it whenever it completes an attempt to roam to an AP. If the roam
|
|
attempt was successful, status will be set to CSR_WIFI_SME_SUCCESS,
|
|
otherwise it shall be set to the appropriate error code.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the roaming procedure
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeRoamCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeRoamCompleteInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAM_COMPLETE_IND, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeRoamCompleteIndSendTo(dst__, src__, interfaceTag__, status__) \
|
|
{ \
|
|
CsrWifiSmeRoamCompleteInd *msg__; \
|
|
CsrWifiSmeRoamCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeRoamCompleteIndSend(dst__, interfaceTag__, status__) \
|
|
CsrWifiSmeRoamCompleteIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeRoamStartIndSend
|
|
|
|
DESCRIPTION
|
|
The SME will send this primitive to all the tasks that have registered to
|
|
receive it whenever it begins an attempt to roam to an AP.
|
|
If the wireless manager application connect request specified the SSID
|
|
and the BSSID was set to the broadcast address (0xFF 0xFF 0xFF 0xFF 0xFF
|
|
0xFF), the SME monitors the signal quality and maintains a list of
|
|
candidates to roam to. When the signal quality of the current connection
|
|
falls below a threshold, and there is a candidate with better quality,
|
|
the SME will attempt to the candidate AP.
|
|
If the roaming procedure succeeds, the SME will also issue a Media
|
|
Connect indication to inform the wireless manager application of the
|
|
change.
|
|
NOTE: to prevent the SME from initiating roaming the WMA must specify the
|
|
BSSID in the connection request; this forces the SME to connect only to
|
|
that AP.
|
|
The wireless manager application can obtain statistics for roaming
|
|
purposes using CSR_WIFI_SME_CONNECTION_QUALITY_IND and
|
|
CSR_WIFI_SME_CONNECTION_STATS_GET_REQ.
|
|
When the wireless manager application wishes to roam to another AP, it
|
|
must issue a connection request specifying the BSSID of the desired AP.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
roamReason - Indicates the reason for starting the roaming procedure
|
|
reason80211 - Indicates the reason for deauthentication or disassociation
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeRoamStartIndCreate(msg__, dst__, src__, interfaceTag__, roamReason__, reason80211__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeRoamStartInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAM_START_IND, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->roamReason = (roamReason__); \
|
|
msg__->reason80211 = (reason80211__);
|
|
|
|
#define CsrWifiSmeRoamStartIndSendTo(dst__, src__, interfaceTag__, roamReason__, reason80211__) \
|
|
{ \
|
|
CsrWifiSmeRoamStartInd *msg__; \
|
|
CsrWifiSmeRoamStartIndCreate(msg__, dst__, src__, interfaceTag__, roamReason__, reason80211__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeRoamStartIndSend(dst__, interfaceTag__, roamReason__, reason80211__) \
|
|
CsrWifiSmeRoamStartIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, roamReason__, reason80211__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeRoamingConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the RoamingConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeRoamingConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeRoamingConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_GET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__);
|
|
|
|
#define CsrWifiSmeRoamingConfigGetReqSendTo(dst__, src__, interfaceTag__) \
|
|
{ \
|
|
CsrWifiSmeRoamingConfigGetReq *msg__; \
|
|
CsrWifiSmeRoamingConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeRoamingConfigGetReqSend(src__, interfaceTag__) \
|
|
CsrWifiSmeRoamingConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeRoamingConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
roamingConfig - Reports the roaming behaviour of the driver and firmware
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeRoamingConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, roamingConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeRoamingConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->roamingConfig = (roamingConfig__);
|
|
|
|
#define CsrWifiSmeRoamingConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, roamingConfig__) \
|
|
{ \
|
|
CsrWifiSmeRoamingConfigGetCfm *msg__; \
|
|
CsrWifiSmeRoamingConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, roamingConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeRoamingConfigGetCfmSend(dst__, interfaceTag__, status__, roamingConfig__) \
|
|
CsrWifiSmeRoamingConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, roamingConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeRoamingConfigSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the RoamingConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
roamingConfig - Desired roaming behaviour values
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeRoamingConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, roamingConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeRoamingConfigSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_SET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->roamingConfig = (roamingConfig__);
|
|
|
|
#define CsrWifiSmeRoamingConfigSetReqSendTo(dst__, src__, interfaceTag__, roamingConfig__) \
|
|
{ \
|
|
CsrWifiSmeRoamingConfigSetReq *msg__; \
|
|
CsrWifiSmeRoamingConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, roamingConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeRoamingConfigSetReqSend(src__, interfaceTag__, roamingConfig__) \
|
|
CsrWifiSmeRoamingConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, roamingConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeRoamingConfigSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the RoamingConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeRoamingConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeRoamingConfigSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_SET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeRoamingConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
|
|
{ \
|
|
CsrWifiSmeRoamingConfigSetCfm *msg__; \
|
|
CsrWifiSmeRoamingConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeRoamingConfigSetCfmSend(dst__, interfaceTag__, status__) \
|
|
CsrWifiSmeRoamingConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the ScanConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanConfigGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeScanConfigGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeScanConfigGetReq *msg__; \
|
|
CsrWifiSmeScanConfigGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanConfigGetReqSend(src__) \
|
|
CsrWifiSmeScanConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
scanConfig - Returns the current parameters for the autonomous scanning
|
|
behaviour of the firmware
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanConfigGetCfmCreate(msg__, dst__, src__, status__, scanConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->scanConfig = (scanConfig__);
|
|
|
|
#define CsrWifiSmeScanConfigGetCfmSendTo(dst__, src__, status__, scanConfig__) \
|
|
{ \
|
|
CsrWifiSmeScanConfigGetCfm *msg__; \
|
|
CsrWifiSmeScanConfigGetCfmCreate(msg__, dst__, src__, status__, scanConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanConfigGetCfmSend(dst__, status__, scanConfig__) \
|
|
CsrWifiSmeScanConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, scanConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanConfigSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the ScanConfig parameter.
|
|
The SME normally configures the firmware to perform autonomous scanning
|
|
without involving the host.
|
|
The firmware passes beacon / probe response or indicates loss of beacon
|
|
on certain changes of state, for example:
|
|
* A new AP is seen for the first time
|
|
* An AP is no longer visible
|
|
* The signal strength of an AP changes by more than a certain amount, as
|
|
configured by the thresholds in the scanConfig parameter
|
|
In addition to the autonomous scan, the wireless manager application may
|
|
request a scan at any time using CSR_WIFI_SME_SCAN_FULL_REQ.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
scanConfig - Reports the configuration for the autonomous scanning behaviour
|
|
of the firmware
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanConfigSetReqCreate(msg__, dst__, src__, scanConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanConfigSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_SET_REQ, dst__, src__); \
|
|
msg__->scanConfig = (scanConfig__);
|
|
|
|
#define CsrWifiSmeScanConfigSetReqSendTo(dst__, src__, scanConfig__) \
|
|
{ \
|
|
CsrWifiSmeScanConfigSetReq *msg__; \
|
|
CsrWifiSmeScanConfigSetReqCreate(msg__, dst__, src__, scanConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanConfigSetReqSend(src__, scanConfig__) \
|
|
CsrWifiSmeScanConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, scanConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanConfigSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanConfigSetCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanConfigSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_SET_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeScanConfigSetCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeScanConfigSetCfm *msg__; \
|
|
CsrWifiSmeScanConfigSetCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanConfigSetCfmSend(dst__, status__) \
|
|
CsrWifiSmeScanConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanFullReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application should call this primitive to request a
|
|
full scan.
|
|
Channels are scanned actively or passively according to the requirement
|
|
set by regulatory domain.
|
|
If the SME receives this primitive while a full scan is going on, the new
|
|
request is buffered and it will be served after the current full scan is
|
|
completed.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
ssidCount - Number of SSIDs provided.
|
|
If it is 0, the SME will attempt to detect any network
|
|
ssid - Points to the first SSID provided, if any.
|
|
bssid - BSS identifier.
|
|
If it is equal to FF-FF-FF-FF-FF, the SME will listen for
|
|
messages from any BSS.
|
|
If it is different from FF-FF-FF-FF-FF and any SSID is
|
|
provided, one SSID must match the network of the BSS.
|
|
forceScan - Forces the scan even if the SME is in a state which would
|
|
normally prevent it (e.g. autonomous scan is running).
|
|
bssType - Type of BSS to scan for
|
|
scanType - Type of scan to perform
|
|
channelListCount - Number of channels provided.
|
|
If it is 0, the SME will initiate a scan of all the
|
|
supported channels that are permitted by the current
|
|
regulatory domain.
|
|
channelList - Points to the first channel , or NULL if channelListCount
|
|
is zero.
|
|
probeIeLength - Length of the information element in bytes to be sent
|
|
with the probe message.
|
|
probeIe - Points to the first byte of the information element to be
|
|
sent with the probe message.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanFullReqCreate(msg__, dst__, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanFullReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_FULL_REQ, dst__, src__); \
|
|
msg__->ssidCount = (ssidCount__); \
|
|
msg__->ssid = (ssid__); \
|
|
msg__->bssid = (bssid__); \
|
|
msg__->forceScan = (forceScan__); \
|
|
msg__->bssType = (bssType__); \
|
|
msg__->scanType = (scanType__); \
|
|
msg__->channelListCount = (channelListCount__); \
|
|
msg__->channelList = (channelList__); \
|
|
msg__->probeIeLength = (probeIeLength__); \
|
|
msg__->probeIe = (probeIe__);
|
|
|
|
#define CsrWifiSmeScanFullReqSendTo(dst__, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__) \
|
|
{ \
|
|
CsrWifiSmeScanFullReq *msg__; \
|
|
CsrWifiSmeScanFullReqCreate(msg__, dst__, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanFullReqSend(src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__) \
|
|
CsrWifiSmeScanFullReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanFullCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME calls this primitive when the results from the scan are
|
|
available.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanFullCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanFullCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_FULL_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeScanFullCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeScanFullCfm *msg__; \
|
|
CsrWifiSmeScanFullCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanFullCfmSend(dst__, status__) \
|
|
CsrWifiSmeScanFullCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanResultIndSend
|
|
|
|
DESCRIPTION
|
|
The SME sends this primitive to all the tasks that have registered to
|
|
receive it whenever a scan indication is received from the firmware.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
result - Points to a buffer containing a scan result.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanResultIndCreate(msg__, dst__, src__, result__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanResultInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULT_IND, dst__, src__); \
|
|
msg__->result = (result__);
|
|
|
|
#define CsrWifiSmeScanResultIndSendTo(dst__, src__, result__) \
|
|
{ \
|
|
CsrWifiSmeScanResultInd *msg__; \
|
|
CsrWifiSmeScanResultIndCreate(msg__, dst__, src__, result__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanResultIndSend(dst__, result__) \
|
|
CsrWifiSmeScanResultIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, result__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanResultsFlushReqSend
|
|
|
|
DESCRIPTION
|
|
The Wireless Manager calls this primitive to ask the SME to delete all
|
|
scan results from its cache, except for the scan result of any currently
|
|
connected network.
|
|
As scan results are received by the SME from the firmware, they are
|
|
cached in the SME memory.
|
|
Any time the Wireless Manager requests scan results, they are returned
|
|
from the SME internal cache.
|
|
For some applications it may be desirable to clear this cache prior to
|
|
requesting that a scan be performed; this will ensure that the cache then
|
|
only contains the networks detected in the most recent scan.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanResultsFlushReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanResultsFlushReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_FLUSH_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeScanResultsFlushReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeScanResultsFlushReq *msg__; \
|
|
CsrWifiSmeScanResultsFlushReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanResultsFlushReqSend(src__) \
|
|
CsrWifiSmeScanResultsFlushReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanResultsFlushCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME will call this primitive when the cache has been cleared.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanResultsFlushCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanResultsFlushCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_FLUSH_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeScanResultsFlushCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeScanResultsFlushCfm *msg__; \
|
|
CsrWifiSmeScanResultsFlushCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanResultsFlushCfmSend(dst__, status__) \
|
|
CsrWifiSmeScanResultsFlushCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanResultsGetReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application calls this primitive to retrieve the
|
|
current set of scan results, either after receiving a successful
|
|
CSR_WIFI_SME_SCAN_FULL_CFM, or to get autonomous scan results.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanResultsGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanResultsGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeScanResultsGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeScanResultsGetReq *msg__; \
|
|
CsrWifiSmeScanResultsGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanResultsGetReqSend(src__) \
|
|
CsrWifiSmeScanResultsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeScanResultsGetCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME sends this primitive to provide the current set of scan results.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
scanResultsCount - Number of scan results
|
|
scanResults - Points to a buffer containing an array of
|
|
CsrWifiSmeScanResult structures.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeScanResultsGetCfmCreate(msg__, dst__, src__, status__, scanResultsCount__, scanResults__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeScanResultsGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->scanResultsCount = (scanResultsCount__); \
|
|
msg__->scanResults = (scanResults__);
|
|
|
|
#define CsrWifiSmeScanResultsGetCfmSendTo(dst__, src__, status__, scanResultsCount__, scanResults__) \
|
|
{ \
|
|
CsrWifiSmeScanResultsGetCfm *msg__; \
|
|
CsrWifiSmeScanResultsGetCfmCreate(msg__, dst__, src__, status__, scanResultsCount__, scanResults__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeScanResultsGetCfmSend(dst__, status__, scanResultsCount__, scanResults__) \
|
|
CsrWifiSmeScanResultsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, scanResultsCount__, scanResults__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeSetReqSend
|
|
|
|
DESCRIPTION
|
|
Used to pass custom data to the SME. Format is the same as 802.11 Info
|
|
Elements => | Id | Length | Data
|
|
1) Cmanr Test Mode "Id:0 Length:1 Data:0x00 = OFF 0x01 = ON" "0x00 0x01
|
|
(0x00|0x01)"
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
dataLength - Number of bytes in the buffer pointed to by 'data'
|
|
data - Pointer to the buffer containing 'dataLength' bytes
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeSetReqCreate(msg__, dst__, src__, dataLength__, data__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SET_REQ, dst__, src__); \
|
|
msg__->dataLength = (dataLength__); \
|
|
msg__->data = (data__);
|
|
|
|
#define CsrWifiSmeSetReqSendTo(dst__, src__, dataLength__, data__) \
|
|
{ \
|
|
CsrWifiSmeSetReq *msg__; \
|
|
CsrWifiSmeSetReqCreate(msg__, dst__, src__, dataLength__, data__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeSetReqSend(src__, dataLength__, data__) \
|
|
CsrWifiSmeSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, dataLength__, data__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeSmeCommonConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the Sme common parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeSmeCommonConfigGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeSmeCommonConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeSmeCommonConfigGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeSmeCommonConfigGetReq *msg__; \
|
|
CsrWifiSmeSmeCommonConfigGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeSmeCommonConfigGetReqSend(src__) \
|
|
CsrWifiSmeSmeCommonConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeSmeCommonConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
deviceConfig - Configuration options in the SME
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeSmeCommonConfigGetCfmCreate(msg__, dst__, src__, status__, deviceConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeSmeCommonConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->deviceConfig = (deviceConfig__);
|
|
|
|
#define CsrWifiSmeSmeCommonConfigGetCfmSendTo(dst__, src__, status__, deviceConfig__) \
|
|
{ \
|
|
CsrWifiSmeSmeCommonConfigGetCfm *msg__; \
|
|
CsrWifiSmeSmeCommonConfigGetCfmCreate(msg__, dst__, src__, status__, deviceConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeSmeCommonConfigGetCfmSend(dst__, status__, deviceConfig__) \
|
|
CsrWifiSmeSmeCommonConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, deviceConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeSmeCommonConfigSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the Sme common.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
deviceConfig - Configuration options in the SME
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeSmeCommonConfigSetReqCreate(msg__, dst__, src__, deviceConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeSmeCommonConfigSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_SET_REQ, dst__, src__); \
|
|
msg__->deviceConfig = (deviceConfig__);
|
|
|
|
#define CsrWifiSmeSmeCommonConfigSetReqSendTo(dst__, src__, deviceConfig__) \
|
|
{ \
|
|
CsrWifiSmeSmeCommonConfigSetReq *msg__; \
|
|
CsrWifiSmeSmeCommonConfigSetReqCreate(msg__, dst__, src__, deviceConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeSmeCommonConfigSetReqSend(src__, deviceConfig__) \
|
|
CsrWifiSmeSmeCommonConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, deviceConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeSmeCommonConfigSetCfmSend
|
|
|
|
DESCRIPTION
|
|
Reports the result of the request
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeSmeCommonConfigSetCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeSmeCommonConfigSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_SET_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeSmeCommonConfigSetCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeSmeCommonConfigSetCfm *msg__; \
|
|
CsrWifiSmeSmeCommonConfigSetCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeSmeCommonConfigSetCfmSend(dst__, status__) \
|
|
CsrWifiSmeSmeCommonConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeSmeStaConfigGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the SmeStaConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeSmeStaConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeSmeStaConfigGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_GET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__);
|
|
|
|
#define CsrWifiSmeSmeStaConfigGetReqSendTo(dst__, src__, interfaceTag__) \
|
|
{ \
|
|
CsrWifiSmeSmeStaConfigGetReq *msg__; \
|
|
CsrWifiSmeSmeStaConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeSmeStaConfigGetReqSend(src__, interfaceTag__) \
|
|
CsrWifiSmeSmeStaConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeSmeStaConfigGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
smeConfig - Current SME Station Parameters
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeSmeStaConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, smeConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeSmeStaConfigGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_GET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->smeConfig = (smeConfig__);
|
|
|
|
#define CsrWifiSmeSmeStaConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, smeConfig__) \
|
|
{ \
|
|
CsrWifiSmeSmeStaConfigGetCfm *msg__; \
|
|
CsrWifiSmeSmeStaConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, smeConfig__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeSmeStaConfigGetCfmSend(dst__, interfaceTag__, status__, smeConfig__) \
|
|
CsrWifiSmeSmeStaConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, smeConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeSmeStaConfigSetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive sets the value of the SmeConfig parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
smeConfig - SME Station Parameters to be set
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeSmeStaConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, smeConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeSmeStaConfigSetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_SET_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->smeConfig = (smeConfig__);
|
|
|
|
#define CsrWifiSmeSmeStaConfigSetReqSendTo(dst__, src__, interfaceTag__, smeConfig__) \
|
|
{ \
|
|
CsrWifiSmeSmeStaConfigSetReq *msg__; \
|
|
CsrWifiSmeSmeStaConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, smeConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeSmeStaConfigSetReqSend(src__, interfaceTag__, smeConfig__) \
|
|
CsrWifiSmeSmeStaConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, smeConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeSmeStaConfigSetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeSmeStaConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeSmeStaConfigSetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_SET_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeSmeStaConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
|
|
{ \
|
|
CsrWifiSmeSmeStaConfigSetCfm *msg__; \
|
|
CsrWifiSmeSmeStaConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeSmeStaConfigSetCfmSend(dst__, interfaceTag__, status__) \
|
|
CsrWifiSmeSmeStaConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeStationMacAddressGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitives is used to retrieve the current MAC address used by the
|
|
station.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeStationMacAddressGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeStationMacAddressGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_STATION_MAC_ADDRESS_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeStationMacAddressGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeStationMacAddressGetReq *msg__; \
|
|
CsrWifiSmeStationMacAddressGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeStationMacAddressGetReqSend(src__) \
|
|
CsrWifiSmeStationMacAddressGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeStationMacAddressGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
stationMacAddress - Current MAC address of the station.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeStationMacAddressGetCfmCreate(msg__, dst__, src__, status__, stationMacAddress__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeStationMacAddressGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_STATION_MAC_ADDRESS_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
memcpy(msg__->stationMacAddress, (stationMacAddress__), sizeof(CsrWifiMacAddress) * 2);
|
|
|
|
#define CsrWifiSmeStationMacAddressGetCfmSendTo(dst__, src__, status__, stationMacAddress__) \
|
|
{ \
|
|
CsrWifiSmeStationMacAddressGetCfm *msg__; \
|
|
CsrWifiSmeStationMacAddressGetCfmCreate(msg__, dst__, src__, status__, stationMacAddress__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeStationMacAddressGetCfmSend(dst__, status__, stationMacAddress__) \
|
|
CsrWifiSmeStationMacAddressGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, stationMacAddress__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeTspecReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application should call this primitive to use the
|
|
TSPEC feature.
|
|
The chip supports the use of TSPECs and TCLAS for the use of IEEE
|
|
802.11/WMM Quality of Service features.
|
|
The API allows the wireless manager application to supply a correctly
|
|
formatted TSPEC and TCLAS pair to the driver.
|
|
After performing basic validation, the driver negotiates the installation
|
|
of the TSPEC with the AP as defined by the 802.11 specification.
|
|
The driver retains all TSPEC and TCLAS pairs until they are specifically
|
|
removed.
|
|
It is not compulsory for a TSPEC to have a TCLAS (NULL is used to
|
|
indicate that no TCLAS is supplied), while a TCLASS always require a
|
|
TSPEC.
|
|
The format of the TSPEC element is specified in 'WMM (including WMM Power
|
|
Save) Specification - Version 1.1' and 'ANSI/IEEE Std 802.11-REVmb/D3.0'.
|
|
For more information, see 'UniFi Configuring WMM and WMM-PS'.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
action - Specifies the action to be carried out on the list of TSPECs.
|
|
CSR_WIFI_SME_LIST_ACTION_FLUSH is not applicable here.
|
|
transactionId - Unique Transaction ID for the TSPEC, as assigned by the
|
|
driver
|
|
strict - If it set to false, allows the SME to perform automatic
|
|
TSPEC negotiation
|
|
ctrlMask - Additional TSPEC configuration for CCX.
|
|
Set mask with values from CsrWifiSmeTspecCtrl.
|
|
CURRENTLY NOT SUPPORTED
|
|
tspecLength - Length of the TSPEC.
|
|
tspec - Points to the first byte of the TSPEC
|
|
tclasLength - Length of the TCLAS.
|
|
If it is equal to 0, no TCLASS is provided for the TSPEC
|
|
tclas - Points to the first byte of the TCLAS, if any.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeTspecReqCreate(msg__, dst__, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeTspecReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_TSPEC_REQ, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->action = (action__); \
|
|
msg__->transactionId = (transactionId__); \
|
|
msg__->strict = (strict__); \
|
|
msg__->ctrlMask = (ctrlMask__); \
|
|
msg__->tspecLength = (tspecLength__); \
|
|
msg__->tspec = (tspec__); \
|
|
msg__->tclasLength = (tclasLength__); \
|
|
msg__->tclas = (tclas__);
|
|
|
|
#define CsrWifiSmeTspecReqSendTo(dst__, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__) \
|
|
{ \
|
|
CsrWifiSmeTspecReq *msg__; \
|
|
CsrWifiSmeTspecReqCreate(msg__, dst__, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeTspecReqSend(src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__) \
|
|
CsrWifiSmeTspecReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeTspecIndSend
|
|
|
|
DESCRIPTION
|
|
The SME will send this primitive to all the task that have registered to
|
|
receive it when a status change in the TSPEC occurs.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
transactionId - Unique Transaction ID for the TSPEC, as assigned by the
|
|
driver
|
|
tspecResultCode - Specifies the TSPEC operation requested by the peer
|
|
station
|
|
tspecLength - Length of the TSPEC.
|
|
tspec - Points to the first byte of the TSPEC
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeTspecIndCreate(msg__, dst__, src__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeTspecInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_TSPEC_IND, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->transactionId = (transactionId__); \
|
|
msg__->tspecResultCode = (tspecResultCode__); \
|
|
msg__->tspecLength = (tspecLength__); \
|
|
msg__->tspec = (tspec__);
|
|
|
|
#define CsrWifiSmeTspecIndSendTo(dst__, src__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
|
|
{ \
|
|
CsrWifiSmeTspecInd *msg__; \
|
|
CsrWifiSmeTspecIndCreate(msg__, dst__, src__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeTspecIndSend(dst__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
|
|
CsrWifiSmeTspecIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeTspecCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME calls the primitive to report the result of the TSpec primitive
|
|
request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
interfaceTag - Interface Identifier; unique identifier of an interface
|
|
status - Reports the result of the request
|
|
transactionId - Unique Transaction ID for the TSPEC, as assigned by the
|
|
driver
|
|
tspecResultCode - Specifies the result of the negotiated TSPEC operation
|
|
tspecLength - Length of the TSPEC.
|
|
tspec - Points to the first byte of the TSPEC
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeTspecCfmCreate(msg__, dst__, src__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeTspecCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_TSPEC_CFM, dst__, src__); \
|
|
msg__->interfaceTag = (interfaceTag__); \
|
|
msg__->status = (status__); \
|
|
msg__->transactionId = (transactionId__); \
|
|
msg__->tspecResultCode = (tspecResultCode__); \
|
|
msg__->tspecLength = (tspecLength__); \
|
|
msg__->tspec = (tspec__);
|
|
|
|
#define CsrWifiSmeTspecCfmSendTo(dst__, src__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
|
|
{ \
|
|
CsrWifiSmeTspecCfm *msg__; \
|
|
CsrWifiSmeTspecCfmCreate(msg__, dst__, src__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeTspecCfmSend(dst__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
|
|
CsrWifiSmeTspecCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeVersionsGetReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive gets the value of the Versions parameter.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeVersionsGetReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeVersionsGetReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_VERSIONS_GET_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeVersionsGetReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeVersionsGetReq *msg__; \
|
|
CsrWifiSmeVersionsGetReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeVersionsGetReqSend(src__) \
|
|
CsrWifiSmeVersionsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeVersionsGetCfmSend
|
|
|
|
DESCRIPTION
|
|
This primitive reports the result of the request.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
versions - Version IDs of the product
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeVersionsGetCfmCreate(msg__, dst__, src__, status__, versions__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeVersionsGetCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_VERSIONS_GET_CFM, dst__, src__); \
|
|
msg__->status = (status__); \
|
|
msg__->versions = (versions__);
|
|
|
|
#define CsrWifiSmeVersionsGetCfmSendTo(dst__, src__, status__, versions__) \
|
|
{ \
|
|
CsrWifiSmeVersionsGetCfm *msg__; \
|
|
CsrWifiSmeVersionsGetCfmCreate(msg__, dst__, src__, status__, versions__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeVersionsGetCfmSend(dst__, status__, versions__) \
|
|
CsrWifiSmeVersionsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, versions__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeWifiFlightmodeReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application may call this primitive on boot-up of
|
|
the platform to ensure that the chip is placed in a mode that prevents
|
|
any emission of RF energy.
|
|
This primitive is an alternative to CSR_WIFI_SME_WIFI_ON_REQ.
|
|
As in CSR_WIFI_SME_WIFI_ON_REQ, it causes the download of the patch file
|
|
(if any) and the programming of the initial MIB settings (if supplied by
|
|
the WMA), but it also ensures that the chip is left in its lowest
|
|
possible power-mode with the radio subsystems disabled.
|
|
This feature is useful on platforms where power cannot be removed from
|
|
the chip (leaving the chip not initialised will cause it to consume more
|
|
power so calling this function ensures that the chip is initialised into
|
|
a low power mode but without entering a state where it could emit any RF
|
|
energy).
|
|
NOTE: this primitive does not cause the Wi-Fi to change state: Wi-Fi
|
|
stays conceptually off. Configuration primitives can be sent after
|
|
CSR_WIFI_SME_WIFI_FLIGHTMODE_REQ and the configuration will be maintained.
|
|
Requests that require the state of the Wi-Fi to be ON will return
|
|
CSR_WIFI_SME_STATUS_WIFI_OFF in their confirms.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
address - Optionally specifies a station MAC address.
|
|
In normal use, the manager should set the address to 0xFF
|
|
0xFF 0xFF 0xFF 0xFF 0xFF, which will cause the chip to use
|
|
the MAC address in the MIB.
|
|
mibFilesCount - Number of provided data blocks with initial MIB values
|
|
mibFiles - Points to the first data block with initial MIB values.
|
|
These data blocks are typically the contents of the provided
|
|
files ufmib.dat and localmib.dat, available from the host
|
|
file system, if they exist.
|
|
These files typically contain radio tuning and calibration
|
|
values.
|
|
More values can be created using the Host Tools.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeWifiFlightmodeReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeWifiFlightmodeReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_FLIGHTMODE_REQ, dst__, src__); \
|
|
msg__->address = (address__); \
|
|
msg__->mibFilesCount = (mibFilesCount__); \
|
|
msg__->mibFiles = (mibFiles__);
|
|
|
|
#define CsrWifiSmeWifiFlightmodeReqSendTo(dst__, src__, address__, mibFilesCount__, mibFiles__) \
|
|
{ \
|
|
CsrWifiSmeWifiFlightmodeReq *msg__; \
|
|
CsrWifiSmeWifiFlightmodeReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeWifiFlightmodeReqSend(src__, address__, mibFilesCount__, mibFiles__) \
|
|
CsrWifiSmeWifiFlightmodeReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, address__, mibFilesCount__, mibFiles__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeWifiFlightmodeCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME calls this primitive when the chip is initialised for low power
|
|
mode and with the radio subsystem disabled. To leave flight mode, and
|
|
enable Wi-Fi, the wireless manager application should call
|
|
CSR_WIFI_SME_WIFI_ON_REQ.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeWifiFlightmodeCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeWifiFlightmodeCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_FLIGHTMODE_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeWifiFlightmodeCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeWifiFlightmodeCfm *msg__; \
|
|
CsrWifiSmeWifiFlightmodeCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeWifiFlightmodeCfmSend(dst__, status__) \
|
|
CsrWifiSmeWifiFlightmodeCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeWifiOffReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application calls this primitive to turn off the
|
|
chip, thus saving power when Wi-Fi is not in use.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeWifiOffReqCreate(msg__, dst__, src__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeWifiOffReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_OFF_REQ, dst__, src__);
|
|
|
|
#define CsrWifiSmeWifiOffReqSendTo(dst__, src__) \
|
|
{ \
|
|
CsrWifiSmeWifiOffReq *msg__; \
|
|
CsrWifiSmeWifiOffReqCreate(msg__, dst__, src__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeWifiOffReqSend(src__) \
|
|
CsrWifiSmeWifiOffReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeWifiOffIndSend
|
|
|
|
DESCRIPTION
|
|
The SME sends this primitive to all the tasks that have registered to
|
|
receive it to report that the chip has been turned off.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
reason - Indicates the reason why the Wi-Fi has been switched off.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeWifiOffIndCreate(msg__, dst__, src__, reason__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeWifiOffInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_OFF_IND, dst__, src__); \
|
|
msg__->reason = (reason__);
|
|
|
|
#define CsrWifiSmeWifiOffIndSendTo(dst__, src__, reason__) \
|
|
{ \
|
|
CsrWifiSmeWifiOffInd *msg__; \
|
|
CsrWifiSmeWifiOffIndCreate(msg__, dst__, src__, reason__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeWifiOffIndSend(dst__, reason__) \
|
|
CsrWifiSmeWifiOffIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, reason__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeWifiOffCfmSend
|
|
|
|
DESCRIPTION
|
|
After receiving CSR_WIFI_SME_WIFI_OFF_REQ, if the chip is connected to a
|
|
network, the SME will perform a disconnect operation, will send a
|
|
CSR_WIFI_SME_MEDIA_STATUS_IND with
|
|
CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED, and then will call
|
|
CSR_WIFI_SME_WIFI_OFF_CFM when the chip is off.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeWifiOffCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeWifiOffCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_OFF_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeWifiOffCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeWifiOffCfm *msg__; \
|
|
CsrWifiSmeWifiOffCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeWifiOffCfmSend(dst__, status__) \
|
|
CsrWifiSmeWifiOffCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeWifiOnReqSend
|
|
|
|
DESCRIPTION
|
|
The wireless manager application calls this primitive to turn on the
|
|
Wi-Fi chip.
|
|
If the Wi-Fi chip is currently off, the SME turns the Wi-Fi chip on,
|
|
downloads the patch file (if any), and programs the initial MIB settings
|
|
(if supplied by the WMA).
|
|
The patch file is not provided with the SME API; its downloading is
|
|
automatic and handled internally by the system.
|
|
The MIB settings, when provided, override the default values that the
|
|
firmware loads from EEPROM.
|
|
If the Wi-Fi chip is already on, the SME takes no action and returns a
|
|
successful status in the confirm.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
address - Optionally specifies a station MAC address.
|
|
In normal use, the manager should set the address to 0xFF
|
|
0xFF 0xFF 0xFF 0xFF 0xFF, which will cause the chip to use
|
|
the MAC address in the MIB
|
|
mibFilesCount - Number of provided data blocks with initial MIB values
|
|
mibFiles - Points to the first data block with initial MIB values.
|
|
These data blocks are typically the contents of the provided
|
|
files ufmib.dat and localmib.dat, available from the host
|
|
file system, if they exist.
|
|
These files typically contain radio tuning and calibration
|
|
values.
|
|
More values can be created using the Host Tools.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeWifiOnReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeWifiOnReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_ON_REQ, dst__, src__); \
|
|
msg__->address = (address__); \
|
|
msg__->mibFilesCount = (mibFilesCount__); \
|
|
msg__->mibFiles = (mibFiles__);
|
|
|
|
#define CsrWifiSmeWifiOnReqSendTo(dst__, src__, address__, mibFilesCount__, mibFiles__) \
|
|
{ \
|
|
CsrWifiSmeWifiOnReq *msg__; \
|
|
CsrWifiSmeWifiOnReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeWifiOnReqSend(src__, address__, mibFilesCount__, mibFiles__) \
|
|
CsrWifiSmeWifiOnReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, address__, mibFilesCount__, mibFiles__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeWifiOnIndSend
|
|
|
|
DESCRIPTION
|
|
The SME sends this primitive to all tasks that have registered to receive
|
|
it once the chip becomes available and ready to use.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
address - Current MAC address
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeWifiOnIndCreate(msg__, dst__, src__, address__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeWifiOnInd), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_ON_IND, dst__, src__); \
|
|
msg__->address = (address__);
|
|
|
|
#define CsrWifiSmeWifiOnIndSendTo(dst__, src__, address__) \
|
|
{ \
|
|
CsrWifiSmeWifiOnInd *msg__; \
|
|
CsrWifiSmeWifiOnIndCreate(msg__, dst__, src__, address__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeWifiOnIndSend(dst__, address__) \
|
|
CsrWifiSmeWifiOnIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, address__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeWifiOnCfmSend
|
|
|
|
DESCRIPTION
|
|
The SME sends this primitive to the task that has sent the request once
|
|
the chip has been initialised and is available for use.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Reports the result of the request
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeWifiOnCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeWifiOnCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_ON_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeWifiOnCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeWifiOnCfm *msg__; \
|
|
CsrWifiSmeWifiOnCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeWifiOnCfmSend(dst__, status__) \
|
|
CsrWifiSmeWifiOnCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeWpsConfigurationReqSend
|
|
|
|
DESCRIPTION
|
|
This primitive passes the WPS information for the device to SME. This may
|
|
be accepted only if no interface is active.
|
|
|
|
PARAMETERS
|
|
queue - Message Source Task Queue (Cfm's will be sent to this Queue)
|
|
wpsConfig - WPS config.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeWpsConfigurationReqCreate(msg__, dst__, src__, wpsConfig__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeWpsConfigurationReq), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WPS_CONFIGURATION_REQ, dst__, src__); \
|
|
msg__->wpsConfig = (wpsConfig__);
|
|
|
|
#define CsrWifiSmeWpsConfigurationReqSendTo(dst__, src__, wpsConfig__) \
|
|
{ \
|
|
CsrWifiSmeWpsConfigurationReq *msg__; \
|
|
CsrWifiSmeWpsConfigurationReqCreate(msg__, dst__, src__, wpsConfig__); \
|
|
CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeWpsConfigurationReqSend(src__, wpsConfig__) \
|
|
CsrWifiSmeWpsConfigurationReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, wpsConfig__)
|
|
|
|
/*******************************************************************************
|
|
|
|
NAME
|
|
CsrWifiSmeWpsConfigurationCfmSend
|
|
|
|
DESCRIPTION
|
|
Confirm.
|
|
|
|
PARAMETERS
|
|
queue - Destination Task Queue
|
|
status - Status of the request.
|
|
|
|
*******************************************************************************/
|
|
#define CsrWifiSmeWpsConfigurationCfmCreate(msg__, dst__, src__, status__) \
|
|
msg__ = kmalloc(sizeof(CsrWifiSmeWpsConfigurationCfm), GFP_KERNEL); \
|
|
CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WPS_CONFIGURATION_CFM, dst__, src__); \
|
|
msg__->status = (status__);
|
|
|
|
#define CsrWifiSmeWpsConfigurationCfmSendTo(dst__, src__, status__) \
|
|
{ \
|
|
CsrWifiSmeWpsConfigurationCfm *msg__; \
|
|
CsrWifiSmeWpsConfigurationCfmCreate(msg__, dst__, src__, status__); \
|
|
CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
|
|
}
|
|
|
|
#define CsrWifiSmeWpsConfigurationCfmSend(dst__, status__) \
|
|
CsrWifiSmeWpsConfigurationCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* CSR_WIFI_SME_LIB_H__ */
|