/***************************************************************************** (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 /*----------------------------------------------------------------------------* * 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__) #endif /* CSR_WIFI_SME_LIB_H__ */