1 /***************************************************************************** 2 3 (c) Cambridge Silicon Radio Limited 2012 4 All rights reserved and confidential information of CSR 5 6 Refer to LICENSE.txt included with this source for details 7 on the license terms. 8 9 *****************************************************************************/ 10 11 /* Note: this is an auto-generated file. */ 12 13 #ifndef CSR_WIFI_SME_LIB_H__ 14 #define CSR_WIFI_SME_LIB_H__ 15 16 #include "csr_sched.h" 17 #include "csr_macro.h" 18 #include "csr_msg_transport.h" 19 20 #include "csr_wifi_lib.h" 21 22 #include "csr_wifi_sme_prim.h" 23 #include "csr_wifi_sme_task.h" 24 25 26 #ifndef CSR_WIFI_SME_LIB_DESTINATION_QUEUE 27 # ifdef CSR_WIFI_NME_ENABLE 28 # include "csr_wifi_nme_task.h" 29 # define CSR_WIFI_SME_LIB_DESTINATION_QUEUE CSR_WIFI_NME_IFACEQUEUE 30 # else 31 # define CSR_WIFI_SME_LIB_DESTINATION_QUEUE CSR_WIFI_SME_IFACEQUEUE 32 # endif 33 #endif 34 35 /*----------------------------------------------------------------------------* 36 * CsrWifiSmeFreeUpstreamMessageContents 37 * 38 * DESCRIPTION 39 * Free the allocated memory in a CSR_WIFI_SME upstream message. Does not 40 * free the message itself, and can only be used for upstream messages. 41 * 42 * PARAMETERS 43 * Deallocates the resources in a CSR_WIFI_SME upstream message 44 *----------------------------------------------------------------------------*/ 45 void CsrWifiSmeFreeUpstreamMessageContents(u16 eventClass, void *message); 46 47 /*----------------------------------------------------------------------------* 48 * CsrWifiSmeFreeDownstreamMessageContents 49 * 50 * DESCRIPTION 51 * Free the allocated memory in a CSR_WIFI_SME downstream message. Does not 52 * free the message itself, and can only be used for downstream messages. 53 * 54 * PARAMETERS 55 * Deallocates the resources in a CSR_WIFI_SME downstream message 56 *----------------------------------------------------------------------------*/ 57 void CsrWifiSmeFreeDownstreamMessageContents(u16 eventClass, void *message); 58 59 /*----------------------------------------------------------------------------* 60 * Enum to string functions 61 *----------------------------------------------------------------------------*/ 62 const char* CsrWifiSme80211NetworkTypeToString(CsrWifiSme80211NetworkType value); 63 const char* CsrWifiSme80211PrivacyModeToString(CsrWifiSme80211PrivacyMode value); 64 const char* CsrWifiSme80211dTrustLevelToString(CsrWifiSme80211dTrustLevel value); 65 const char* CsrWifiSmeAmpStatusToString(CsrWifiSmeAmpStatus value); 66 const char* CsrWifiSmeAuthModeToString(CsrWifiSmeAuthMode value); 67 const char* CsrWifiSmeBasicUsabilityToString(CsrWifiSmeBasicUsability value); 68 const char* CsrWifiSmeBssTypeToString(CsrWifiSmeBssType value); 69 const char* CsrWifiSmeCoexSchemeToString(CsrWifiSmeCoexScheme value); 70 const char* CsrWifiSmeControlIndicationToString(CsrWifiSmeControlIndication value); 71 const char* CsrWifiSmeCtsProtectionTypeToString(CsrWifiSmeCtsProtectionType value); 72 const char* CsrWifiSmeD3AutoScanModeToString(CsrWifiSmeD3AutoScanMode value); 73 const char* CsrWifiSmeEncryptionToString(CsrWifiSmeEncryption value); 74 const char* CsrWifiSmeFirmwareDriverInterfaceToString(CsrWifiSmeFirmwareDriverInterface value); 75 const char* CsrWifiSmeHostPowerModeToString(CsrWifiSmeHostPowerMode value); 76 const char* CsrWifiSmeIEEE80211ReasonToString(CsrWifiSmeIEEE80211Reason value); 77 const char* CsrWifiSmeIEEE80211ResultToString(CsrWifiSmeIEEE80211Result value); 78 const char* CsrWifiSmeIndicationsToString(CsrWifiSmeIndications value); 79 const char* CsrWifiSmeKeyTypeToString(CsrWifiSmeKeyType value); 80 const char* CsrWifiSmeListActionToString(CsrWifiSmeListAction value); 81 const char* CsrWifiSmeMediaStatusToString(CsrWifiSmeMediaStatus value); 82 const char* CsrWifiSmeP2pCapabilityToString(CsrWifiSmeP2pCapability value); 83 const char* CsrWifiSmeP2pGroupCapabilityToString(CsrWifiSmeP2pGroupCapability value); 84 const char* CsrWifiSmeP2pNoaConfigMethodToString(CsrWifiSmeP2pNoaConfigMethod value); 85 const char* CsrWifiSmeP2pRoleToString(CsrWifiSmeP2pRole value); 86 const char* CsrWifiSmeP2pStatusToString(CsrWifiSmeP2pStatus value); 87 const char* CsrWifiSmePacketFilterModeToString(CsrWifiSmePacketFilterMode value); 88 const char* CsrWifiSmePowerSaveLevelToString(CsrWifiSmePowerSaveLevel value); 89 const char* CsrWifiSmePreambleTypeToString(CsrWifiSmePreambleType value); 90 const char* CsrWifiSmeRadioIFToString(CsrWifiSmeRadioIF value); 91 const char* CsrWifiSmeRegulatoryDomainToString(CsrWifiSmeRegulatoryDomain value); 92 const char* CsrWifiSmeRoamReasonToString(CsrWifiSmeRoamReason value); 93 const char* CsrWifiSmeScanTypeToString(CsrWifiSmeScanType value); 94 const char* CsrWifiSmeTrafficTypeToString(CsrWifiSmeTrafficType value); 95 const char* CsrWifiSmeTspecCtrlToString(CsrWifiSmeTspecCtrl value); 96 const char* CsrWifiSmeTspecResultCodeToString(CsrWifiSmeTspecResultCode value); 97 const char* CsrWifiSmeWepAuthModeToString(CsrWifiSmeWepAuthMode value); 98 const char* CsrWifiSmeWepCredentialTypeToString(CsrWifiSmeWepCredentialType value); 99 const char* CsrWifiSmeWmmModeToString(CsrWifiSmeWmmMode value); 100 const char* CsrWifiSmeWmmQosInfoToString(CsrWifiSmeWmmQosInfo value); 101 const char* CsrWifiSmeWpsConfigTypeToString(CsrWifiSmeWpsConfigType value); 102 const char* CsrWifiSmeWpsDeviceCategoryToString(CsrWifiSmeWpsDeviceCategory value); 103 const char* CsrWifiSmeWpsDeviceSubCategoryToString(CsrWifiSmeWpsDeviceSubCategory value); 104 const char* CsrWifiSmeWpsDpidToString(CsrWifiSmeWpsDpid value); 105 const char* CsrWifiSmeWpsRegistrationToString(CsrWifiSmeWpsRegistration value); 106 107 108 /*----------------------------------------------------------------------------* 109 * CsrPrim Type toString function. 110 * Converts a message type to the String name of the Message 111 *----------------------------------------------------------------------------*/ 112 const char* CsrWifiSmePrimTypeToString(CsrPrim msgType); 113 114 /*----------------------------------------------------------------------------* 115 * Lookup arrays for PrimType name Strings 116 *----------------------------------------------------------------------------*/ 117 extern const char *CsrWifiSmeUpstreamPrimNames[CSR_WIFI_SME_PRIM_UPSTREAM_COUNT]; 118 extern const char *CsrWifiSmeDownstreamPrimNames[CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT]; 119 120 /******************************************************************************* 121 122 NAME 123 CsrWifiSmeActivateReqSend 124 125 DESCRIPTION 126 The WMA sends this primitive to activate the SME. 127 The WMA must activate the SME before it can send any other primitive. 128 129 PARAMETERS 130 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 131 132 *******************************************************************************/ 133 #define CsrWifiSmeActivateReqCreate(msg__, dst__, src__) \ 134 msg__ = kmalloc(sizeof(CsrWifiSmeActivateReq), GFP_KERNEL); \ 135 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ACTIVATE_REQ, dst__, src__); 136 137 #define CsrWifiSmeActivateReqSendTo(dst__, src__) \ 138 { \ 139 CsrWifiSmeActivateReq *msg__; \ 140 CsrWifiSmeActivateReqCreate(msg__, dst__, src__); \ 141 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 142 } 143 144 #define CsrWifiSmeActivateReqSend(src__) \ 145 CsrWifiSmeActivateReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 146 147 /******************************************************************************* 148 149 NAME 150 CsrWifiSmeActivateCfmSend 151 152 DESCRIPTION 153 The SME sends this primitive when the activation is complete. 154 155 PARAMETERS 156 queue - Destination Task Queue 157 status - Reports the result of the request 158 159 *******************************************************************************/ 160 #define CsrWifiSmeActivateCfmCreate(msg__, dst__, src__, status__) \ 161 msg__ = kmalloc(sizeof(CsrWifiSmeActivateCfm), GFP_KERNEL); \ 162 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ACTIVATE_CFM, dst__, src__); \ 163 msg__->status = (status__); 164 165 #define CsrWifiSmeActivateCfmSendTo(dst__, src__, status__) \ 166 { \ 167 CsrWifiSmeActivateCfm *msg__; \ 168 CsrWifiSmeActivateCfmCreate(msg__, dst__, src__, status__); \ 169 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 170 } 171 172 #define CsrWifiSmeActivateCfmSend(dst__, status__) \ 173 CsrWifiSmeActivateCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 174 175 /******************************************************************************* 176 177 NAME 178 CsrWifiSmeAdhocConfigGetReqSend 179 180 DESCRIPTION 181 This primitive gets the value of the adHocConfig parameter. 182 183 PARAMETERS 184 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 185 186 *******************************************************************************/ 187 #define CsrWifiSmeAdhocConfigGetReqCreate(msg__, dst__, src__) \ 188 msg__ = kmalloc(sizeof(CsrWifiSmeAdhocConfigGetReq), GFP_KERNEL); \ 189 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_GET_REQ, dst__, src__); 190 191 #define CsrWifiSmeAdhocConfigGetReqSendTo(dst__, src__) \ 192 { \ 193 CsrWifiSmeAdhocConfigGetReq *msg__; \ 194 CsrWifiSmeAdhocConfigGetReqCreate(msg__, dst__, src__); \ 195 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 196 } 197 198 #define CsrWifiSmeAdhocConfigGetReqSend(src__) \ 199 CsrWifiSmeAdhocConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 200 201 /******************************************************************************* 202 203 NAME 204 CsrWifiSmeAdhocConfigGetCfmSend 205 206 DESCRIPTION 207 This primitive reports the result of the request. 208 209 PARAMETERS 210 queue - Destination Task Queue 211 status - Reports the result of the request 212 adHocConfig - Contains the values used when starting an Ad-hoc (IBSS) 213 connection. 214 215 *******************************************************************************/ 216 #define CsrWifiSmeAdhocConfigGetCfmCreate(msg__, dst__, src__, status__, adHocConfig__) \ 217 msg__ = kmalloc(sizeof(CsrWifiSmeAdhocConfigGetCfm), GFP_KERNEL); \ 218 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_GET_CFM, dst__, src__); \ 219 msg__->status = (status__); \ 220 msg__->adHocConfig = (adHocConfig__); 221 222 #define CsrWifiSmeAdhocConfigGetCfmSendTo(dst__, src__, status__, adHocConfig__) \ 223 { \ 224 CsrWifiSmeAdhocConfigGetCfm *msg__; \ 225 CsrWifiSmeAdhocConfigGetCfmCreate(msg__, dst__, src__, status__, adHocConfig__); \ 226 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 227 } 228 229 #define CsrWifiSmeAdhocConfigGetCfmSend(dst__, status__, adHocConfig__) \ 230 CsrWifiSmeAdhocConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, adHocConfig__) 231 232 /******************************************************************************* 233 234 NAME 235 CsrWifiSmeAdhocConfigSetReqSend 236 237 DESCRIPTION 238 This primitive sets the value of the adHocConfig parameter. 239 240 PARAMETERS 241 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 242 adHocConfig - Sets the values to use when starting an ad hoc network. 243 244 *******************************************************************************/ 245 #define CsrWifiSmeAdhocConfigSetReqCreate(msg__, dst__, src__, adHocConfig__) \ 246 msg__ = kmalloc(sizeof(CsrWifiSmeAdhocConfigSetReq), GFP_KERNEL); \ 247 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_SET_REQ, dst__, src__); \ 248 msg__->adHocConfig = (adHocConfig__); 249 250 #define CsrWifiSmeAdhocConfigSetReqSendTo(dst__, src__, adHocConfig__) \ 251 { \ 252 CsrWifiSmeAdhocConfigSetReq *msg__; \ 253 CsrWifiSmeAdhocConfigSetReqCreate(msg__, dst__, src__, adHocConfig__); \ 254 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 255 } 256 257 #define CsrWifiSmeAdhocConfigSetReqSend(src__, adHocConfig__) \ 258 CsrWifiSmeAdhocConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, adHocConfig__) 259 260 /******************************************************************************* 261 262 NAME 263 CsrWifiSmeAdhocConfigSetCfmSend 264 265 DESCRIPTION 266 This primitive reports the result of the request. 267 268 PARAMETERS 269 queue - Destination Task Queue 270 status - Reports the result of the request 271 272 *******************************************************************************/ 273 #define CsrWifiSmeAdhocConfigSetCfmCreate(msg__, dst__, src__, status__) \ 274 msg__ = kmalloc(sizeof(CsrWifiSmeAdhocConfigSetCfm), GFP_KERNEL); \ 275 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_SET_CFM, dst__, src__); \ 276 msg__->status = (status__); 277 278 #define CsrWifiSmeAdhocConfigSetCfmSendTo(dst__, src__, status__) \ 279 { \ 280 CsrWifiSmeAdhocConfigSetCfm *msg__; \ 281 CsrWifiSmeAdhocConfigSetCfmCreate(msg__, dst__, src__, status__); \ 282 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 283 } 284 285 #define CsrWifiSmeAdhocConfigSetCfmSend(dst__, status__) \ 286 CsrWifiSmeAdhocConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 287 288 /******************************************************************************* 289 290 NAME 291 CsrWifiSmeAmpStatusChangeIndSend 292 293 DESCRIPTION 294 Indication of change to AMP activity. 295 296 PARAMETERS 297 queue - Destination Task Queue 298 interfaceTag - Interface on which the AMP activity changed. 299 ampStatus - The new status of AMP activity.Range: {AMP_ACTIVE, 300 AMP_INACTIVE}. 301 302 *******************************************************************************/ 303 #define CsrWifiSmeAmpStatusChangeIndCreate(msg__, dst__, src__, interfaceTag__, ampStatus__) \ 304 msg__ = kmalloc(sizeof(CsrWifiSmeAmpStatusChangeInd), GFP_KERNEL); \ 305 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_AMP_STATUS_CHANGE_IND, dst__, src__); \ 306 msg__->interfaceTag = (interfaceTag__); \ 307 msg__->ampStatus = (ampStatus__); 308 309 #define CsrWifiSmeAmpStatusChangeIndSendTo(dst__, src__, interfaceTag__, ampStatus__) \ 310 { \ 311 CsrWifiSmeAmpStatusChangeInd *msg__; \ 312 CsrWifiSmeAmpStatusChangeIndCreate(msg__, dst__, src__, interfaceTag__, ampStatus__); \ 313 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 314 } 315 316 #define CsrWifiSmeAmpStatusChangeIndSend(dst__, interfaceTag__, ampStatus__) \ 317 CsrWifiSmeAmpStatusChangeIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, ampStatus__) 318 319 /******************************************************************************* 320 321 NAME 322 CsrWifiSmeAssociationCompleteIndSend 323 324 DESCRIPTION 325 The SME will send this primitive to all the tasks that have registered to 326 receive it whenever it completes an attempt to associate with an AP. If 327 the association was successful, status will be set to 328 CSR_WIFI_SME_STATUS_SUCCESS, otherwise status and deauthReason shall be 329 set to appropriate error codes. 330 331 PARAMETERS 332 queue - Destination Task Queue 333 interfaceTag - Interface Identifier; unique identifier of an interface 334 status - Reports the result of the association procedure 335 connectionInfo - This parameter is relevant only if result is 336 CSR_WIFI_SME_STATUS_SUCCESS: 337 it points to the connection information for the new network 338 deauthReason - This parameter is relevant only if result is not 339 CSR_WIFI_SME_STATUS_SUCCESS: 340 if the AP deauthorised the station, it gives the reason of 341 the deauthorization 342 343 *******************************************************************************/ 344 #define CsrWifiSmeAssociationCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__, deauthReason__) \ 345 msg__ = kmalloc(sizeof(CsrWifiSmeAssociationCompleteInd), GFP_KERNEL); \ 346 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ASSOCIATION_COMPLETE_IND, dst__, src__); \ 347 msg__->interfaceTag = (interfaceTag__); \ 348 msg__->status = (status__); \ 349 msg__->connectionInfo = (connectionInfo__); \ 350 msg__->deauthReason = (deauthReason__); 351 352 #define CsrWifiSmeAssociationCompleteIndSendTo(dst__, src__, interfaceTag__, status__, connectionInfo__, deauthReason__) \ 353 { \ 354 CsrWifiSmeAssociationCompleteInd *msg__; \ 355 CsrWifiSmeAssociationCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__, deauthReason__); \ 356 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 357 } 358 359 #define CsrWifiSmeAssociationCompleteIndSend(dst__, interfaceTag__, status__, connectionInfo__, deauthReason__) \ 360 CsrWifiSmeAssociationCompleteIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionInfo__, deauthReason__) 361 362 /******************************************************************************* 363 364 NAME 365 CsrWifiSmeAssociationStartIndSend 366 367 DESCRIPTION 368 The SME will send this primitive to all the tasks that have registered to 369 receive it whenever it begins an attempt to associate with an AP. 370 371 PARAMETERS 372 queue - Destination Task Queue 373 interfaceTag - Interface Identifier; unique identifier of an interface 374 address - BSSID of the associating network 375 ssid - Service Set identifier of the associating network 376 377 *******************************************************************************/ 378 #define CsrWifiSmeAssociationStartIndCreate(msg__, dst__, src__, interfaceTag__, address__, ssid__) \ 379 msg__ = kmalloc(sizeof(CsrWifiSmeAssociationStartInd), GFP_KERNEL); \ 380 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ASSOCIATION_START_IND, dst__, src__); \ 381 msg__->interfaceTag = (interfaceTag__); \ 382 msg__->address = (address__); \ 383 msg__->ssid = (ssid__); 384 385 #define CsrWifiSmeAssociationStartIndSendTo(dst__, src__, interfaceTag__, address__, ssid__) \ 386 { \ 387 CsrWifiSmeAssociationStartInd *msg__; \ 388 CsrWifiSmeAssociationStartIndCreate(msg__, dst__, src__, interfaceTag__, address__, ssid__); \ 389 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 390 } 391 392 #define CsrWifiSmeAssociationStartIndSend(dst__, interfaceTag__, address__, ssid__) \ 393 CsrWifiSmeAssociationStartIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, address__, ssid__) 394 395 /******************************************************************************* 396 397 NAME 398 CsrWifiSmeBlacklistReqSend 399 400 DESCRIPTION 401 The wireless manager application should call this primitive to notify the 402 driver of any networks that should not be connected to. The interface 403 allows the wireless manager application to query, add, remove, and flush 404 the BSSIDs that the driver may not connect or roam to. 405 When this primitive adds to the black list the BSSID to which the SME is 406 currently connected, the SME will try to roam, if applicable, to another 407 BSSID in the same ESS; if the roaming procedure fails, the SME will 408 disconnect. 409 410 PARAMETERS 411 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 412 interfaceTag - Interface Identifier; unique identifier of an interface 413 action - The value of the CsrWifiSmeListAction parameter instructs 414 the driver to modify or provide the list of blacklisted 415 networks. 416 setAddressCount - Number of BSSIDs sent with this primitive 417 setAddresses - Pointer to the list of BBSIDs sent with the primitive, set 418 to NULL if none is sent. 419 420 *******************************************************************************/ 421 #define CsrWifiSmeBlacklistReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressCount__, setAddresses__) \ 422 msg__ = kmalloc(sizeof(CsrWifiSmeBlacklistReq), GFP_KERNEL); \ 423 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_BLACKLIST_REQ, dst__, src__); \ 424 msg__->interfaceTag = (interfaceTag__); \ 425 msg__->action = (action__); \ 426 msg__->setAddressCount = (setAddressCount__); \ 427 msg__->setAddresses = (setAddresses__); 428 429 #define CsrWifiSmeBlacklistReqSendTo(dst__, src__, interfaceTag__, action__, setAddressCount__, setAddresses__) \ 430 { \ 431 CsrWifiSmeBlacklistReq *msg__; \ 432 CsrWifiSmeBlacklistReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressCount__, setAddresses__); \ 433 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 434 } 435 436 #define CsrWifiSmeBlacklistReqSend(src__, interfaceTag__, action__, setAddressCount__, setAddresses__) \ 437 CsrWifiSmeBlacklistReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, setAddressCount__, setAddresses__) 438 439 /******************************************************************************* 440 441 NAME 442 CsrWifiSmeBlacklistCfmSend 443 444 DESCRIPTION 445 The SME will call this primitive when the action on the blacklist has 446 completed. For a GET action, this primitive also reports the list of 447 BBSIDs in the blacklist. 448 449 PARAMETERS 450 queue - Destination Task Queue 451 interfaceTag - Interface Identifier; unique identifier of an interface 452 status - Reports the result of the request 453 action - Action in the request 454 getAddressCount - This parameter is only relevant if action is 455 CSR_WIFI_SME_LIST_ACTION_GET: 456 number of BSSIDs sent with this primitive 457 getAddresses - Pointer to the list of BBSIDs sent with the primitive, set 458 to NULL if none is sent. 459 460 *******************************************************************************/ 461 #define CsrWifiSmeBlacklistCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__) \ 462 msg__ = kmalloc(sizeof(CsrWifiSmeBlacklistCfm), GFP_KERNEL); \ 463 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_BLACKLIST_CFM, dst__, src__); \ 464 msg__->interfaceTag = (interfaceTag__); \ 465 msg__->status = (status__); \ 466 msg__->action = (action__); \ 467 msg__->getAddressCount = (getAddressCount__); \ 468 msg__->getAddresses = (getAddresses__); 469 470 #define CsrWifiSmeBlacklistCfmSendTo(dst__, src__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__) \ 471 { \ 472 CsrWifiSmeBlacklistCfm *msg__; \ 473 CsrWifiSmeBlacklistCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__); \ 474 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 475 } 476 477 #define CsrWifiSmeBlacklistCfmSend(dst__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__) \ 478 CsrWifiSmeBlacklistCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, getAddressCount__, getAddresses__) 479 480 /******************************************************************************* 481 482 NAME 483 CsrWifiSmeCalibrationDataGetReqSend 484 485 DESCRIPTION 486 This primitive retrieves the Wi-Fi radio calibration data. 487 488 PARAMETERS 489 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 490 491 *******************************************************************************/ 492 #define CsrWifiSmeCalibrationDataGetReqCreate(msg__, dst__, src__) \ 493 msg__ = kmalloc(sizeof(CsrWifiSmeCalibrationDataGetReq), GFP_KERNEL); \ 494 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_GET_REQ, dst__, src__); 495 496 #define CsrWifiSmeCalibrationDataGetReqSendTo(dst__, src__) \ 497 { \ 498 CsrWifiSmeCalibrationDataGetReq *msg__; \ 499 CsrWifiSmeCalibrationDataGetReqCreate(msg__, dst__, src__); \ 500 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 501 } 502 503 #define CsrWifiSmeCalibrationDataGetReqSend(src__) \ 504 CsrWifiSmeCalibrationDataGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 505 506 /******************************************************************************* 507 508 NAME 509 CsrWifiSmeCalibrationDataGetCfmSend 510 511 DESCRIPTION 512 This primitive reports the result of the request. 513 514 PARAMETERS 515 queue - Destination Task Queue 516 status - Reports the result of the request 517 calibrationDataLength - Number of bytes in the buffer pointed by 518 calibrationData 519 calibrationData - Pointer to a buffer of length calibrationDataLength 520 containing the calibration data 521 522 *******************************************************************************/ 523 #define CsrWifiSmeCalibrationDataGetCfmCreate(msg__, dst__, src__, status__, calibrationDataLength__, calibrationData__) \ 524 msg__ = kmalloc(sizeof(CsrWifiSmeCalibrationDataGetCfm), GFP_KERNEL); \ 525 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_GET_CFM, dst__, src__); \ 526 msg__->status = (status__); \ 527 msg__->calibrationDataLength = (calibrationDataLength__); \ 528 msg__->calibrationData = (calibrationData__); 529 530 #define CsrWifiSmeCalibrationDataGetCfmSendTo(dst__, src__, status__, calibrationDataLength__, calibrationData__) \ 531 { \ 532 CsrWifiSmeCalibrationDataGetCfm *msg__; \ 533 CsrWifiSmeCalibrationDataGetCfmCreate(msg__, dst__, src__, status__, calibrationDataLength__, calibrationData__); \ 534 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 535 } 536 537 #define CsrWifiSmeCalibrationDataGetCfmSend(dst__, status__, calibrationDataLength__, calibrationData__) \ 538 CsrWifiSmeCalibrationDataGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, calibrationDataLength__, calibrationData__) 539 540 /******************************************************************************* 541 542 NAME 543 CsrWifiSmeCalibrationDataSetReqSend 544 545 DESCRIPTION 546 This primitive sets the Wi-Fi radio calibration data. 547 The usage of the primitive with proper calibration data will avoid 548 time-consuming configuration after power-up. 549 550 PARAMETERS 551 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 552 calibrationDataLength - Number of bytes in the buffer pointed by 553 calibrationData 554 calibrationData - Pointer to a buffer of length calibrationDataLength 555 containing the calibration data 556 557 *******************************************************************************/ 558 #define CsrWifiSmeCalibrationDataSetReqCreate(msg__, dst__, src__, calibrationDataLength__, calibrationData__) \ 559 msg__ = kmalloc(sizeof(CsrWifiSmeCalibrationDataSetReq), GFP_KERNEL); \ 560 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_SET_REQ, dst__, src__); \ 561 msg__->calibrationDataLength = (calibrationDataLength__); \ 562 msg__->calibrationData = (calibrationData__); 563 564 #define CsrWifiSmeCalibrationDataSetReqSendTo(dst__, src__, calibrationDataLength__, calibrationData__) \ 565 { \ 566 CsrWifiSmeCalibrationDataSetReq *msg__; \ 567 CsrWifiSmeCalibrationDataSetReqCreate(msg__, dst__, src__, calibrationDataLength__, calibrationData__); \ 568 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 569 } 570 571 #define CsrWifiSmeCalibrationDataSetReqSend(src__, calibrationDataLength__, calibrationData__) \ 572 CsrWifiSmeCalibrationDataSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, calibrationDataLength__, calibrationData__) 573 574 /******************************************************************************* 575 576 NAME 577 CsrWifiSmeCalibrationDataSetCfmSend 578 579 DESCRIPTION 580 This primitive reports the result of the request. 581 582 PARAMETERS 583 queue - Destination Task Queue 584 status - Reports the result of the request 585 586 *******************************************************************************/ 587 #define CsrWifiSmeCalibrationDataSetCfmCreate(msg__, dst__, src__, status__) \ 588 msg__ = kmalloc(sizeof(CsrWifiSmeCalibrationDataSetCfm), GFP_KERNEL); \ 589 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_SET_CFM, dst__, src__); \ 590 msg__->status = (status__); 591 592 #define CsrWifiSmeCalibrationDataSetCfmSendTo(dst__, src__, status__) \ 593 { \ 594 CsrWifiSmeCalibrationDataSetCfm *msg__; \ 595 CsrWifiSmeCalibrationDataSetCfmCreate(msg__, dst__, src__, status__); \ 596 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 597 } 598 599 #define CsrWifiSmeCalibrationDataSetCfmSend(dst__, status__) \ 600 CsrWifiSmeCalibrationDataSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 601 602 /******************************************************************************* 603 604 NAME 605 CsrWifiSmeCcxConfigGetReqSend 606 607 DESCRIPTION 608 This primitive gets the value of the CcxConfig parameter. 609 CURRENTLY NOT SUPPORTED. 610 611 PARAMETERS 612 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 613 interfaceTag - Interface Identifier; unique identifier of an interface 614 615 *******************************************************************************/ 616 #define CsrWifiSmeCcxConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \ 617 msg__ = kmalloc(sizeof(CsrWifiSmeCcxConfigGetReq), GFP_KERNEL); \ 618 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_GET_REQ, dst__, src__); \ 619 msg__->interfaceTag = (interfaceTag__); 620 621 #define CsrWifiSmeCcxConfigGetReqSendTo(dst__, src__, interfaceTag__) \ 622 { \ 623 CsrWifiSmeCcxConfigGetReq *msg__; \ 624 CsrWifiSmeCcxConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \ 625 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 626 } 627 628 #define CsrWifiSmeCcxConfigGetReqSend(src__, interfaceTag__) \ 629 CsrWifiSmeCcxConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__) 630 631 /******************************************************************************* 632 633 NAME 634 CsrWifiSmeCcxConfigGetCfmSend 635 636 DESCRIPTION 637 This primitive reports the result of the request. 638 639 PARAMETERS 640 queue - Destination Task Queue 641 interfaceTag - Interface Identifier; unique identifier of an interface 642 status - Reports the result of the request 643 ccxConfig - Currently not supported 644 645 *******************************************************************************/ 646 #define CsrWifiSmeCcxConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, ccxConfig__) \ 647 msg__ = kmalloc(sizeof(CsrWifiSmeCcxConfigGetCfm), GFP_KERNEL); \ 648 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_GET_CFM, dst__, src__); \ 649 msg__->interfaceTag = (interfaceTag__); \ 650 msg__->status = (status__); \ 651 msg__->ccxConfig = (ccxConfig__); 652 653 #define CsrWifiSmeCcxConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, ccxConfig__) \ 654 { \ 655 CsrWifiSmeCcxConfigGetCfm *msg__; \ 656 CsrWifiSmeCcxConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, ccxConfig__); \ 657 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 658 } 659 660 #define CsrWifiSmeCcxConfigGetCfmSend(dst__, interfaceTag__, status__, ccxConfig__) \ 661 CsrWifiSmeCcxConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, ccxConfig__) 662 663 /******************************************************************************* 664 665 NAME 666 CsrWifiSmeCcxConfigSetReqSend 667 668 DESCRIPTION 669 This primitive sets the value of the CcxConfig parameter. 670 CURRENTLY NOT SUPPORTED. 671 672 PARAMETERS 673 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 674 interfaceTag - Interface Identifier; unique identifier of an interface 675 ccxConfig - Currently not supported 676 677 *******************************************************************************/ 678 #define CsrWifiSmeCcxConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, ccxConfig__) \ 679 msg__ = kmalloc(sizeof(CsrWifiSmeCcxConfigSetReq), GFP_KERNEL); \ 680 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_SET_REQ, dst__, src__); \ 681 msg__->interfaceTag = (interfaceTag__); \ 682 msg__->ccxConfig = (ccxConfig__); 683 684 #define CsrWifiSmeCcxConfigSetReqSendTo(dst__, src__, interfaceTag__, ccxConfig__) \ 685 { \ 686 CsrWifiSmeCcxConfigSetReq *msg__; \ 687 CsrWifiSmeCcxConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, ccxConfig__); \ 688 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 689 } 690 691 #define CsrWifiSmeCcxConfigSetReqSend(src__, interfaceTag__, ccxConfig__) \ 692 CsrWifiSmeCcxConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, ccxConfig__) 693 694 /******************************************************************************* 695 696 NAME 697 CsrWifiSmeCcxConfigSetCfmSend 698 699 DESCRIPTION 700 This primitive reports the result of the request. 701 702 PARAMETERS 703 queue - Destination Task Queue 704 interfaceTag - Interface Identifier; unique identifier of an interface 705 status - Reports the result of the request 706 707 *******************************************************************************/ 708 #define CsrWifiSmeCcxConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \ 709 msg__ = kmalloc(sizeof(CsrWifiSmeCcxConfigSetCfm), GFP_KERNEL); \ 710 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_SET_CFM, dst__, src__); \ 711 msg__->interfaceTag = (interfaceTag__); \ 712 msg__->status = (status__); 713 714 #define CsrWifiSmeCcxConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \ 715 { \ 716 CsrWifiSmeCcxConfigSetCfm *msg__; \ 717 CsrWifiSmeCcxConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \ 718 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 719 } 720 721 #define CsrWifiSmeCcxConfigSetCfmSend(dst__, interfaceTag__, status__) \ 722 CsrWifiSmeCcxConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__) 723 724 /******************************************************************************* 725 726 NAME 727 CsrWifiSmeCloakedSsidsGetReqSend 728 729 DESCRIPTION 730 This primitive gets the value of the CloakedSsids parameter. 731 732 PARAMETERS 733 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 734 735 *******************************************************************************/ 736 #define CsrWifiSmeCloakedSsidsGetReqCreate(msg__, dst__, src__) \ 737 msg__ = kmalloc(sizeof(CsrWifiSmeCloakedSsidsGetReq), GFP_KERNEL); \ 738 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_GET_REQ, dst__, src__); 739 740 #define CsrWifiSmeCloakedSsidsGetReqSendTo(dst__, src__) \ 741 { \ 742 CsrWifiSmeCloakedSsidsGetReq *msg__; \ 743 CsrWifiSmeCloakedSsidsGetReqCreate(msg__, dst__, src__); \ 744 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 745 } 746 747 #define CsrWifiSmeCloakedSsidsGetReqSend(src__) \ 748 CsrWifiSmeCloakedSsidsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 749 750 /******************************************************************************* 751 752 NAME 753 CsrWifiSmeCloakedSsidsGetCfmSend 754 755 DESCRIPTION 756 This primitive reports the result of the request. 757 758 PARAMETERS 759 queue - Destination Task Queue 760 status - Reports the result of the request 761 cloakedSsids - Reports list of cloaked SSIDs that are explicitly scanned for 762 by the driver 763 764 *******************************************************************************/ 765 #define CsrWifiSmeCloakedSsidsGetCfmCreate(msg__, dst__, src__, status__, cloakedSsids__) \ 766 msg__ = kmalloc(sizeof(CsrWifiSmeCloakedSsidsGetCfm), GFP_KERNEL); \ 767 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_GET_CFM, dst__, src__); \ 768 msg__->status = (status__); \ 769 msg__->cloakedSsids = (cloakedSsids__); 770 771 #define CsrWifiSmeCloakedSsidsGetCfmSendTo(dst__, src__, status__, cloakedSsids__) \ 772 { \ 773 CsrWifiSmeCloakedSsidsGetCfm *msg__; \ 774 CsrWifiSmeCloakedSsidsGetCfmCreate(msg__, dst__, src__, status__, cloakedSsids__); \ 775 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 776 } 777 778 #define CsrWifiSmeCloakedSsidsGetCfmSend(dst__, status__, cloakedSsids__) \ 779 CsrWifiSmeCloakedSsidsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, cloakedSsids__) 780 781 /******************************************************************************* 782 783 NAME 784 CsrWifiSmeCloakedSsidsSetReqSend 785 786 DESCRIPTION 787 This primitive sets the list of cloaked SSIDs for which the WMA possesses 788 profiles. 789 When the driver detects a cloaked AP, the SME will explicitly scan for it 790 using the list of cloaked SSIDs provided it, and, if the scan succeeds, 791 it will report the AP to the WMA either via CSR_WIFI_SME_SCAN_RESULT_IND 792 (if registered) or via CSR_WIFI_SCAN_RESULT_GET_CFM. 793 794 PARAMETERS 795 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 796 cloakedSsids - Sets the list of cloaked SSIDs 797 798 *******************************************************************************/ 799 #define CsrWifiSmeCloakedSsidsSetReqCreate(msg__, dst__, src__, cloakedSsids__) \ 800 msg__ = kmalloc(sizeof(CsrWifiSmeCloakedSsidsSetReq), GFP_KERNEL); \ 801 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_SET_REQ, dst__, src__); \ 802 msg__->cloakedSsids = (cloakedSsids__); 803 804 #define CsrWifiSmeCloakedSsidsSetReqSendTo(dst__, src__, cloakedSsids__) \ 805 { \ 806 CsrWifiSmeCloakedSsidsSetReq *msg__; \ 807 CsrWifiSmeCloakedSsidsSetReqCreate(msg__, dst__, src__, cloakedSsids__); \ 808 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 809 } 810 811 #define CsrWifiSmeCloakedSsidsSetReqSend(src__, cloakedSsids__) \ 812 CsrWifiSmeCloakedSsidsSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, cloakedSsids__) 813 814 /******************************************************************************* 815 816 NAME 817 CsrWifiSmeCloakedSsidsSetCfmSend 818 819 DESCRIPTION 820 This primitive reports the result of the request. 821 822 PARAMETERS 823 queue - Destination Task Queue 824 status - Reports the result of the request 825 826 *******************************************************************************/ 827 #define CsrWifiSmeCloakedSsidsSetCfmCreate(msg__, dst__, src__, status__) \ 828 msg__ = kmalloc(sizeof(CsrWifiSmeCloakedSsidsSetCfm), GFP_KERNEL); \ 829 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_SET_CFM, dst__, src__); \ 830 msg__->status = (status__); 831 832 #define CsrWifiSmeCloakedSsidsSetCfmSendTo(dst__, src__, status__) \ 833 { \ 834 CsrWifiSmeCloakedSsidsSetCfm *msg__; \ 835 CsrWifiSmeCloakedSsidsSetCfmCreate(msg__, dst__, src__, status__); \ 836 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 837 } 838 839 #define CsrWifiSmeCloakedSsidsSetCfmSend(dst__, status__) \ 840 CsrWifiSmeCloakedSsidsSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 841 842 /******************************************************************************* 843 844 NAME 845 CsrWifiSmeCoexConfigGetReqSend 846 847 DESCRIPTION 848 This primitive gets the value of the CoexConfig parameter. 849 850 PARAMETERS 851 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 852 853 *******************************************************************************/ 854 #define CsrWifiSmeCoexConfigGetReqCreate(msg__, dst__, src__) \ 855 msg__ = kmalloc(sizeof(CsrWifiSmeCoexConfigGetReq), GFP_KERNEL); \ 856 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_GET_REQ, dst__, src__); 857 858 #define CsrWifiSmeCoexConfigGetReqSendTo(dst__, src__) \ 859 { \ 860 CsrWifiSmeCoexConfigGetReq *msg__; \ 861 CsrWifiSmeCoexConfigGetReqCreate(msg__, dst__, src__); \ 862 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 863 } 864 865 #define CsrWifiSmeCoexConfigGetReqSend(src__) \ 866 CsrWifiSmeCoexConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 867 868 /******************************************************************************* 869 870 NAME 871 CsrWifiSmeCoexConfigGetCfmSend 872 873 DESCRIPTION 874 This primitive reports the result of the request. 875 876 PARAMETERS 877 queue - Destination Task Queue 878 status - Reports the result of the request 879 coexConfig - Reports the parameters used to configure the coexistence 880 behaviour 881 882 *******************************************************************************/ 883 #define CsrWifiSmeCoexConfigGetCfmCreate(msg__, dst__, src__, status__, coexConfig__) \ 884 msg__ = kmalloc(sizeof(CsrWifiSmeCoexConfigGetCfm), GFP_KERNEL); \ 885 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_GET_CFM, dst__, src__); \ 886 msg__->status = (status__); \ 887 msg__->coexConfig = (coexConfig__); 888 889 #define CsrWifiSmeCoexConfigGetCfmSendTo(dst__, src__, status__, coexConfig__) \ 890 { \ 891 CsrWifiSmeCoexConfigGetCfm *msg__; \ 892 CsrWifiSmeCoexConfigGetCfmCreate(msg__, dst__, src__, status__, coexConfig__); \ 893 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 894 } 895 896 #define CsrWifiSmeCoexConfigGetCfmSend(dst__, status__, coexConfig__) \ 897 CsrWifiSmeCoexConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, coexConfig__) 898 899 /******************************************************************************* 900 901 NAME 902 CsrWifiSmeCoexConfigSetReqSend 903 904 DESCRIPTION 905 This primitive sets the value of the CoexConfig parameter. 906 907 PARAMETERS 908 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 909 coexConfig - Configures the coexistence behaviour 910 911 *******************************************************************************/ 912 #define CsrWifiSmeCoexConfigSetReqCreate(msg__, dst__, src__, coexConfig__) \ 913 msg__ = kmalloc(sizeof(CsrWifiSmeCoexConfigSetReq), GFP_KERNEL); \ 914 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_SET_REQ, dst__, src__); \ 915 msg__->coexConfig = (coexConfig__); 916 917 #define CsrWifiSmeCoexConfigSetReqSendTo(dst__, src__, coexConfig__) \ 918 { \ 919 CsrWifiSmeCoexConfigSetReq *msg__; \ 920 CsrWifiSmeCoexConfigSetReqCreate(msg__, dst__, src__, coexConfig__); \ 921 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 922 } 923 924 #define CsrWifiSmeCoexConfigSetReqSend(src__, coexConfig__) \ 925 CsrWifiSmeCoexConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, coexConfig__) 926 927 /******************************************************************************* 928 929 NAME 930 CsrWifiSmeCoexConfigSetCfmSend 931 932 DESCRIPTION 933 This primitive reports the result of the request. 934 935 PARAMETERS 936 queue - Destination Task Queue 937 status - Reports the result of the request 938 939 *******************************************************************************/ 940 #define CsrWifiSmeCoexConfigSetCfmCreate(msg__, dst__, src__, status__) \ 941 msg__ = kmalloc(sizeof(CsrWifiSmeCoexConfigSetCfm), GFP_KERNEL); \ 942 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_SET_CFM, dst__, src__); \ 943 msg__->status = (status__); 944 945 #define CsrWifiSmeCoexConfigSetCfmSendTo(dst__, src__, status__) \ 946 { \ 947 CsrWifiSmeCoexConfigSetCfm *msg__; \ 948 CsrWifiSmeCoexConfigSetCfmCreate(msg__, dst__, src__, status__); \ 949 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 950 } 951 952 #define CsrWifiSmeCoexConfigSetCfmSend(dst__, status__) \ 953 CsrWifiSmeCoexConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 954 955 /******************************************************************************* 956 957 NAME 958 CsrWifiSmeCoexInfoGetReqSend 959 960 DESCRIPTION 961 This primitive gets the value of the CoexInfo parameter. 962 963 PARAMETERS 964 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 965 966 *******************************************************************************/ 967 #define CsrWifiSmeCoexInfoGetReqCreate(msg__, dst__, src__) \ 968 msg__ = kmalloc(sizeof(CsrWifiSmeCoexInfoGetReq), GFP_KERNEL); \ 969 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_INFO_GET_REQ, dst__, src__); 970 971 #define CsrWifiSmeCoexInfoGetReqSendTo(dst__, src__) \ 972 { \ 973 CsrWifiSmeCoexInfoGetReq *msg__; \ 974 CsrWifiSmeCoexInfoGetReqCreate(msg__, dst__, src__); \ 975 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 976 } 977 978 #define CsrWifiSmeCoexInfoGetReqSend(src__) \ 979 CsrWifiSmeCoexInfoGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 980 981 /******************************************************************************* 982 983 NAME 984 CsrWifiSmeCoexInfoGetCfmSend 985 986 DESCRIPTION 987 This primitive reports the result of the request. 988 989 PARAMETERS 990 queue - Destination Task Queue 991 status - Reports the result of the request 992 coexInfo - Reports information and state related to coexistence. 993 994 *******************************************************************************/ 995 #define CsrWifiSmeCoexInfoGetCfmCreate(msg__, dst__, src__, status__, coexInfo__) \ 996 msg__ = kmalloc(sizeof(CsrWifiSmeCoexInfoGetCfm), GFP_KERNEL); \ 997 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_INFO_GET_CFM, dst__, src__); \ 998 msg__->status = (status__); \ 999 msg__->coexInfo = (coexInfo__); 1000 1001 #define CsrWifiSmeCoexInfoGetCfmSendTo(dst__, src__, status__, coexInfo__) \ 1002 { \ 1003 CsrWifiSmeCoexInfoGetCfm *msg__; \ 1004 CsrWifiSmeCoexInfoGetCfmCreate(msg__, dst__, src__, status__, coexInfo__); \ 1005 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1006 } 1007 1008 #define CsrWifiSmeCoexInfoGetCfmSend(dst__, status__, coexInfo__) \ 1009 CsrWifiSmeCoexInfoGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, coexInfo__) 1010 1011 /******************************************************************************* 1012 1013 NAME 1014 CsrWifiSmeConnectReqSend 1015 1016 DESCRIPTION 1017 The wireless manager application calls this primitive to start the 1018 process of joining an 802.11 wireless network or to start an ad hoc 1019 network. 1020 The structure pointed by connectionConfig contains parameters describing 1021 the network to join or, in case of an ad hoc network, to host or join. 1022 The SME will select a network, perform the IEEE 802.11 Join, Authenticate 1023 and Associate exchanges. 1024 The SME selects the networks from the current scan list that match both 1025 the SSID and BSSID, however either or both of these may be the wildcard 1026 value. Using this rule, the following operations are possible: 1027 * To connect to a network by name, specify the SSID and set the BSSID to 1028 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF. If there are two or more networks visible, 1029 the SME will select the one with the strongest signal. 1030 * To connect to a specific network, specify the BSSID. The SSID is 1031 optional, but if given it must match the SSID of the network. An empty 1032 SSID may be specified by setting the SSID length to zero. Please note 1033 that if the BSSID is specified (i.e. not equal to 0xFF 0xFF 0xFF 0xFF 1034 0xFF 0xFF), the SME will not attempt to roam if signal conditions become 1035 poor, even if there is an alternative AP with an SSID that matches the 1036 current network SSID. 1037 * To connect to any network matching the other parameters (i.e. security, 1038 etc), set the SSID length to zero and set the BSSID to 0xFF 0xFF 0xFF 1039 0xFF 0xFF 0xFF. In this case, the SME will order all available networks 1040 by their signal strengths and will iterate through this list until it 1041 successfully connects. 1042 NOTE: Specifying the BSSID will restrict the selection to one specific 1043 network. If SSID and BSSID are given, they must both match the network 1044 for it to be selected. To select a network based on the SSID only, the 1045 wireless manager application must set the BSSID to 0xFF 0xFF 0xFF 0xFF 1046 0xFF 0xFF. 1047 The SME will try to connect to each network that matches the provided 1048 parameters, one by one, until it succeeds or has tried unsuccessfully 1049 with all the matching networks. 1050 If there is no network that matches the parameters and the request allows 1051 to host an ad hoc network, the SME will advertise a new ad hoc network 1052 instead. 1053 If the SME cannot connect, it will notify the failure in the confirm. 1054 1055 PARAMETERS 1056 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1057 interfaceTag - Interface Identifier; unique identifier of an interface 1058 connectionConfig - Describes the candidate network to join or to host. 1059 1060 *******************************************************************************/ 1061 #define CsrWifiSmeConnectReqCreate(msg__, dst__, src__, interfaceTag__, connectionConfig__) \ 1062 msg__ = kmalloc(sizeof(CsrWifiSmeConnectReq), GFP_KERNEL); \ 1063 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECT_REQ, dst__, src__); \ 1064 msg__->interfaceTag = (interfaceTag__); \ 1065 msg__->connectionConfig = (connectionConfig__); 1066 1067 #define CsrWifiSmeConnectReqSendTo(dst__, src__, interfaceTag__, connectionConfig__) \ 1068 { \ 1069 CsrWifiSmeConnectReq *msg__; \ 1070 CsrWifiSmeConnectReqCreate(msg__, dst__, src__, interfaceTag__, connectionConfig__); \ 1071 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1072 } 1073 1074 #define CsrWifiSmeConnectReqSend(src__, interfaceTag__, connectionConfig__) \ 1075 CsrWifiSmeConnectReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, connectionConfig__) 1076 1077 /******************************************************************************* 1078 1079 NAME 1080 CsrWifiSmeConnectCfmSend 1081 1082 DESCRIPTION 1083 The SME calls this primitive when the connection exchange is complete or 1084 all connection attempts fail. 1085 1086 PARAMETERS 1087 queue - Destination Task Queue 1088 interfaceTag - Interface Identifier; unique identifier of an interface 1089 status - Reports the result of the request. 1090 CSR_WIFI_SME_STATUS_NOT_FOUND: all attempts by the SME to 1091 locate the requested AP failed 1092 1093 *******************************************************************************/ 1094 #define CsrWifiSmeConnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \ 1095 msg__ = kmalloc(sizeof(CsrWifiSmeConnectCfm), GFP_KERNEL); \ 1096 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECT_CFM, dst__, src__); \ 1097 msg__->interfaceTag = (interfaceTag__); \ 1098 msg__->status = (status__); 1099 1100 #define CsrWifiSmeConnectCfmSendTo(dst__, src__, interfaceTag__, status__) \ 1101 { \ 1102 CsrWifiSmeConnectCfm *msg__; \ 1103 CsrWifiSmeConnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \ 1104 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1105 } 1106 1107 #define CsrWifiSmeConnectCfmSend(dst__, interfaceTag__, status__) \ 1108 CsrWifiSmeConnectCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__) 1109 1110 /******************************************************************************* 1111 1112 NAME 1113 CsrWifiSmeConnectionConfigGetReqSend 1114 1115 DESCRIPTION 1116 This primitive gets the value of the ConnectionConfig parameter. 1117 1118 PARAMETERS 1119 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1120 interfaceTag - Interface Identifier; unique identifier of an interface 1121 1122 *******************************************************************************/ 1123 #define CsrWifiSmeConnectionConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \ 1124 msg__ = kmalloc(sizeof(CsrWifiSmeConnectionConfigGetReq), GFP_KERNEL); \ 1125 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_CONFIG_GET_REQ, dst__, src__); \ 1126 msg__->interfaceTag = (interfaceTag__); 1127 1128 #define CsrWifiSmeConnectionConfigGetReqSendTo(dst__, src__, interfaceTag__) \ 1129 { \ 1130 CsrWifiSmeConnectionConfigGetReq *msg__; \ 1131 CsrWifiSmeConnectionConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \ 1132 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1133 } 1134 1135 #define CsrWifiSmeConnectionConfigGetReqSend(src__, interfaceTag__) \ 1136 CsrWifiSmeConnectionConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__) 1137 1138 /******************************************************************************* 1139 1140 NAME 1141 CsrWifiSmeConnectionConfigGetCfmSend 1142 1143 DESCRIPTION 1144 This primitive reports the result of the request. 1145 1146 PARAMETERS 1147 queue - Destination Task Queue 1148 interfaceTag - Interface Identifier; unique identifier of an interface 1149 status - Reports the result of the request 1150 connectionConfig - Parameters used by the SME for selecting a network 1151 1152 *******************************************************************************/ 1153 #define CsrWifiSmeConnectionConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionConfig__) \ 1154 msg__ = kmalloc(sizeof(CsrWifiSmeConnectionConfigGetCfm), GFP_KERNEL); \ 1155 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_CONFIG_GET_CFM, dst__, src__); \ 1156 msg__->interfaceTag = (interfaceTag__); \ 1157 msg__->status = (status__); \ 1158 msg__->connectionConfig = (connectionConfig__); 1159 1160 #define CsrWifiSmeConnectionConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, connectionConfig__) \ 1161 { \ 1162 CsrWifiSmeConnectionConfigGetCfm *msg__; \ 1163 CsrWifiSmeConnectionConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionConfig__); \ 1164 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1165 } 1166 1167 #define CsrWifiSmeConnectionConfigGetCfmSend(dst__, interfaceTag__, status__, connectionConfig__) \ 1168 CsrWifiSmeConnectionConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionConfig__) 1169 1170 /******************************************************************************* 1171 1172 NAME 1173 CsrWifiSmeConnectionInfoGetReqSend 1174 1175 DESCRIPTION 1176 This primitive gets the value of the ConnectionInfo parameter. 1177 1178 PARAMETERS 1179 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1180 interfaceTag - Interface Identifier; unique identifier of an interface 1181 1182 *******************************************************************************/ 1183 #define CsrWifiSmeConnectionInfoGetReqCreate(msg__, dst__, src__, interfaceTag__) \ 1184 msg__ = kmalloc(sizeof(CsrWifiSmeConnectionInfoGetReq), GFP_KERNEL); \ 1185 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_INFO_GET_REQ, dst__, src__); \ 1186 msg__->interfaceTag = (interfaceTag__); 1187 1188 #define CsrWifiSmeConnectionInfoGetReqSendTo(dst__, src__, interfaceTag__) \ 1189 { \ 1190 CsrWifiSmeConnectionInfoGetReq *msg__; \ 1191 CsrWifiSmeConnectionInfoGetReqCreate(msg__, dst__, src__, interfaceTag__); \ 1192 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1193 } 1194 1195 #define CsrWifiSmeConnectionInfoGetReqSend(src__, interfaceTag__) \ 1196 CsrWifiSmeConnectionInfoGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__) 1197 1198 /******************************************************************************* 1199 1200 NAME 1201 CsrWifiSmeConnectionInfoGetCfmSend 1202 1203 DESCRIPTION 1204 This primitive reports the result of the request. 1205 1206 PARAMETERS 1207 queue - Destination Task Queue 1208 interfaceTag - Interface Identifier; unique identifier of an interface 1209 status - Reports the result of the request 1210 connectionInfo - Information about the current connection 1211 1212 *******************************************************************************/ 1213 #define CsrWifiSmeConnectionInfoGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__) \ 1214 msg__ = kmalloc(sizeof(CsrWifiSmeConnectionInfoGetCfm), GFP_KERNEL); \ 1215 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_INFO_GET_CFM, dst__, src__); \ 1216 msg__->interfaceTag = (interfaceTag__); \ 1217 msg__->status = (status__); \ 1218 msg__->connectionInfo = (connectionInfo__); 1219 1220 #define CsrWifiSmeConnectionInfoGetCfmSendTo(dst__, src__, interfaceTag__, status__, connectionInfo__) \ 1221 { \ 1222 CsrWifiSmeConnectionInfoGetCfm *msg__; \ 1223 CsrWifiSmeConnectionInfoGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__); \ 1224 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1225 } 1226 1227 #define CsrWifiSmeConnectionInfoGetCfmSend(dst__, interfaceTag__, status__, connectionInfo__) \ 1228 CsrWifiSmeConnectionInfoGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionInfo__) 1229 1230 /******************************************************************************* 1231 1232 NAME 1233 CsrWifiSmeConnectionQualityIndSend 1234 1235 DESCRIPTION 1236 The SME sends this primitive to all the tasks that have registered to 1237 receive it whenever the value of the current connection quality 1238 parameters change by more than a certain configurable amount. 1239 The wireless manager application may configure the trigger thresholds for 1240 this indication using the field in smeConfig parameter of 1241 CSR_WIFI_SME_SME_CONFIG_SET_REQ. 1242 Connection quality messages can be suppressed by setting both thresholds 1243 to zero. 1244 1245 PARAMETERS 1246 queue - Destination Task Queue 1247 interfaceTag - Interface Identifier; unique identifier of an interface 1248 linkQuality - Indicates the quality of the link 1249 1250 *******************************************************************************/ 1251 #define CsrWifiSmeConnectionQualityIndCreate(msg__, dst__, src__, interfaceTag__, linkQuality__) \ 1252 msg__ = kmalloc(sizeof(CsrWifiSmeConnectionQualityInd), GFP_KERNEL); \ 1253 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_QUALITY_IND, dst__, src__); \ 1254 msg__->interfaceTag = (interfaceTag__); \ 1255 msg__->linkQuality = (linkQuality__); 1256 1257 #define CsrWifiSmeConnectionQualityIndSendTo(dst__, src__, interfaceTag__, linkQuality__) \ 1258 { \ 1259 CsrWifiSmeConnectionQualityInd *msg__; \ 1260 CsrWifiSmeConnectionQualityIndCreate(msg__, dst__, src__, interfaceTag__, linkQuality__); \ 1261 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1262 } 1263 1264 #define CsrWifiSmeConnectionQualityIndSend(dst__, interfaceTag__, linkQuality__) \ 1265 CsrWifiSmeConnectionQualityIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, linkQuality__) 1266 1267 /******************************************************************************* 1268 1269 NAME 1270 CsrWifiSmeConnectionStatsGetReqSend 1271 1272 DESCRIPTION 1273 This primitive gets the value of the ConnectionStats parameter. 1274 1275 PARAMETERS 1276 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1277 interfaceTag - Interface Identifier; unique identifier of an interface 1278 1279 *******************************************************************************/ 1280 #define CsrWifiSmeConnectionStatsGetReqCreate(msg__, dst__, src__, interfaceTag__) \ 1281 msg__ = kmalloc(sizeof(CsrWifiSmeConnectionStatsGetReq), GFP_KERNEL); \ 1282 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_STATS_GET_REQ, dst__, src__); \ 1283 msg__->interfaceTag = (interfaceTag__); 1284 1285 #define CsrWifiSmeConnectionStatsGetReqSendTo(dst__, src__, interfaceTag__) \ 1286 { \ 1287 CsrWifiSmeConnectionStatsGetReq *msg__; \ 1288 CsrWifiSmeConnectionStatsGetReqCreate(msg__, dst__, src__, interfaceTag__); \ 1289 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1290 } 1291 1292 #define CsrWifiSmeConnectionStatsGetReqSend(src__, interfaceTag__) \ 1293 CsrWifiSmeConnectionStatsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__) 1294 1295 /******************************************************************************* 1296 1297 NAME 1298 CsrWifiSmeConnectionStatsGetCfmSend 1299 1300 DESCRIPTION 1301 This primitive reports the result of the request. 1302 1303 PARAMETERS 1304 queue - Destination Task Queue 1305 interfaceTag - Interface Identifier; unique identifier of an interface 1306 status - Reports the result of the request 1307 connectionStats - Statistics for current connection. 1308 1309 *******************************************************************************/ 1310 #define CsrWifiSmeConnectionStatsGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionStats__) \ 1311 msg__ = kmalloc(sizeof(CsrWifiSmeConnectionStatsGetCfm), GFP_KERNEL); \ 1312 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_STATS_GET_CFM, dst__, src__); \ 1313 msg__->interfaceTag = (interfaceTag__); \ 1314 msg__->status = (status__); \ 1315 msg__->connectionStats = (connectionStats__); 1316 1317 #define CsrWifiSmeConnectionStatsGetCfmSendTo(dst__, src__, interfaceTag__, status__, connectionStats__) \ 1318 { \ 1319 CsrWifiSmeConnectionStatsGetCfm *msg__; \ 1320 CsrWifiSmeConnectionStatsGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionStats__); \ 1321 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1322 } 1323 1324 #define CsrWifiSmeConnectionStatsGetCfmSend(dst__, interfaceTag__, status__, connectionStats__) \ 1325 CsrWifiSmeConnectionStatsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionStats__) 1326 1327 /******************************************************************************* 1328 1329 NAME 1330 CsrWifiSmeCoreDumpIndSend 1331 1332 DESCRIPTION 1333 The SME will send this primitive to all the tasks that have registered to 1334 receive Wi-Fi Chip core dump data. 1335 The core dump data may be fragmented and sent using more than one 1336 indication. 1337 To indicate that all the data has been sent, the last indication contains 1338 a 'length' of 0 and 'data' of NULL. 1339 1340 PARAMETERS 1341 queue - Destination Task Queue 1342 dataLength - Number of bytes in the buffer pointed to by 'data' 1343 data - Pointer to the buffer containing 'dataLength' bytes of core 1344 dump data 1345 1346 *******************************************************************************/ 1347 #define CsrWifiSmeCoreDumpIndCreate(msg__, dst__, src__, dataLength__, data__) \ 1348 msg__ = kmalloc(sizeof(CsrWifiSmeCoreDumpInd), GFP_KERNEL); \ 1349 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CORE_DUMP_IND, dst__, src__); \ 1350 msg__->dataLength = (dataLength__); \ 1351 msg__->data = (data__); 1352 1353 #define CsrWifiSmeCoreDumpIndSendTo(dst__, src__, dataLength__, data__) \ 1354 { \ 1355 CsrWifiSmeCoreDumpInd *msg__; \ 1356 CsrWifiSmeCoreDumpIndCreate(msg__, dst__, src__, dataLength__, data__); \ 1357 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1358 } 1359 1360 #define CsrWifiSmeCoreDumpIndSend(dst__, dataLength__, data__) \ 1361 CsrWifiSmeCoreDumpIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, dataLength__, data__) 1362 1363 /******************************************************************************* 1364 1365 NAME 1366 CsrWifiSmeDeactivateReqSend 1367 1368 DESCRIPTION 1369 The WMA sends this primitive to deactivate the SME. 1370 1371 PARAMETERS 1372 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1373 1374 *******************************************************************************/ 1375 #define CsrWifiSmeDeactivateReqCreate(msg__, dst__, src__) \ 1376 msg__ = kmalloc(sizeof(CsrWifiSmeDeactivateReq), GFP_KERNEL); \ 1377 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DEACTIVATE_REQ, dst__, src__); 1378 1379 #define CsrWifiSmeDeactivateReqSendTo(dst__, src__) \ 1380 { \ 1381 CsrWifiSmeDeactivateReq *msg__; \ 1382 CsrWifiSmeDeactivateReqCreate(msg__, dst__, src__); \ 1383 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1384 } 1385 1386 #define CsrWifiSmeDeactivateReqSend(src__) \ 1387 CsrWifiSmeDeactivateReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 1388 1389 /******************************************************************************* 1390 1391 NAME 1392 CsrWifiSmeDeactivateCfmSend 1393 1394 DESCRIPTION 1395 The SME sends this primitive when the deactivation is complete. 1396 The WMA cannot send any more primitives until it actives the SME again 1397 sending another CSR_WIFI_SME_ACTIVATE_REQ. 1398 1399 PARAMETERS 1400 queue - Destination Task Queue 1401 status - Reports the result of the request 1402 1403 *******************************************************************************/ 1404 #define CsrWifiSmeDeactivateCfmCreate(msg__, dst__, src__, status__) \ 1405 msg__ = kmalloc(sizeof(CsrWifiSmeDeactivateCfm), GFP_KERNEL); \ 1406 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DEACTIVATE_CFM, dst__, src__); \ 1407 msg__->status = (status__); 1408 1409 #define CsrWifiSmeDeactivateCfmSendTo(dst__, src__, status__) \ 1410 { \ 1411 CsrWifiSmeDeactivateCfm *msg__; \ 1412 CsrWifiSmeDeactivateCfmCreate(msg__, dst__, src__, status__); \ 1413 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1414 } 1415 1416 #define CsrWifiSmeDeactivateCfmSend(dst__, status__) \ 1417 CsrWifiSmeDeactivateCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 1418 1419 /******************************************************************************* 1420 1421 NAME 1422 CsrWifiSmeDisconnectReqSend 1423 1424 DESCRIPTION 1425 The wireless manager application may disconnect from the current network 1426 by calling this primitive 1427 1428 PARAMETERS 1429 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1430 interfaceTag - Interface Identifier; unique identifier of an interface 1431 1432 *******************************************************************************/ 1433 #define CsrWifiSmeDisconnectReqCreate(msg__, dst__, src__, interfaceTag__) \ 1434 msg__ = kmalloc(sizeof(CsrWifiSmeDisconnectReq), GFP_KERNEL); \ 1435 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DISCONNECT_REQ, dst__, src__); \ 1436 msg__->interfaceTag = (interfaceTag__); 1437 1438 #define CsrWifiSmeDisconnectReqSendTo(dst__, src__, interfaceTag__) \ 1439 { \ 1440 CsrWifiSmeDisconnectReq *msg__; \ 1441 CsrWifiSmeDisconnectReqCreate(msg__, dst__, src__, interfaceTag__); \ 1442 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1443 } 1444 1445 #define CsrWifiSmeDisconnectReqSend(src__, interfaceTag__) \ 1446 CsrWifiSmeDisconnectReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__) 1447 1448 /******************************************************************************* 1449 1450 NAME 1451 CsrWifiSmeDisconnectCfmSend 1452 1453 DESCRIPTION 1454 On reception of CSR_WIFI_SME_DISCONNECT_REQ the SME will perform a 1455 disconnect operation, sending a CsrWifiSmeMediaStatusInd with 1456 CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED and then call this primitive when 1457 disconnection is complete. 1458 1459 PARAMETERS 1460 queue - Destination Task Queue 1461 interfaceTag - Interface Identifier; unique identifier of an interface 1462 status - Reports the result of the request 1463 1464 *******************************************************************************/ 1465 #define CsrWifiSmeDisconnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \ 1466 msg__ = kmalloc(sizeof(CsrWifiSmeDisconnectCfm), GFP_KERNEL); \ 1467 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DISCONNECT_CFM, dst__, src__); \ 1468 msg__->interfaceTag = (interfaceTag__); \ 1469 msg__->status = (status__); 1470 1471 #define CsrWifiSmeDisconnectCfmSendTo(dst__, src__, interfaceTag__, status__) \ 1472 { \ 1473 CsrWifiSmeDisconnectCfm *msg__; \ 1474 CsrWifiSmeDisconnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \ 1475 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1476 } 1477 1478 #define CsrWifiSmeDisconnectCfmSend(dst__, interfaceTag__, status__) \ 1479 CsrWifiSmeDisconnectCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__) 1480 1481 /******************************************************************************* 1482 1483 NAME 1484 CsrWifiSmeErrorIndSend 1485 1486 DESCRIPTION 1487 Important error message indicating a error of some importance 1488 1489 PARAMETERS 1490 queue - Destination Task Queue 1491 errorMessage - Contains the error message. 1492 1493 *******************************************************************************/ 1494 #define CsrWifiSmeErrorIndCreate(msg__, dst__, src__, errorMessage__) \ 1495 msg__ = kmalloc(sizeof(CsrWifiSmeErrorInd), GFP_KERNEL); \ 1496 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ERROR_IND, dst__, src__); \ 1497 msg__->errorMessage = (errorMessage__); 1498 1499 #define CsrWifiSmeErrorIndSendTo(dst__, src__, errorMessage__) \ 1500 { \ 1501 CsrWifiSmeErrorInd *msg__; \ 1502 CsrWifiSmeErrorIndCreate(msg__, dst__, src__, errorMessage__); \ 1503 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1504 } 1505 1506 #define CsrWifiSmeErrorIndSend(dst__, errorMessage__) \ 1507 CsrWifiSmeErrorIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, errorMessage__) 1508 1509 /******************************************************************************* 1510 1511 NAME 1512 CsrWifiSmeEventMaskSetReqSend 1513 1514 DESCRIPTION 1515 The wireless manager application may register with the SME to receive 1516 notification of interesting events. Indications will be sent only if the 1517 wireless manager explicitly registers to be notified of that event. 1518 indMask is a bit mask of values defined in CsrWifiSmeIndicationsMask. 1519 1520 PARAMETERS 1521 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1522 indMask - Set mask with values from CsrWifiSmeIndications 1523 1524 *******************************************************************************/ 1525 #define CsrWifiSmeEventMaskSetReqCreate(msg__, dst__, src__, indMask__) \ 1526 msg__ = kmalloc(sizeof(CsrWifiSmeEventMaskSetReq), GFP_KERNEL); \ 1527 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_EVENT_MASK_SET_REQ, dst__, src__); \ 1528 msg__->indMask = (indMask__); 1529 1530 #define CsrWifiSmeEventMaskSetReqSendTo(dst__, src__, indMask__) \ 1531 { \ 1532 CsrWifiSmeEventMaskSetReq *msg__; \ 1533 CsrWifiSmeEventMaskSetReqCreate(msg__, dst__, src__, indMask__); \ 1534 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1535 } 1536 1537 #define CsrWifiSmeEventMaskSetReqSend(src__, indMask__) \ 1538 CsrWifiSmeEventMaskSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, indMask__) 1539 1540 /******************************************************************************* 1541 1542 NAME 1543 CsrWifiSmeEventMaskSetCfmSend 1544 1545 DESCRIPTION 1546 The SME calls the primitive to report the result of the request 1547 primitive. 1548 1549 PARAMETERS 1550 queue - Destination Task Queue 1551 status - Reports the result of the request 1552 1553 *******************************************************************************/ 1554 #define CsrWifiSmeEventMaskSetCfmCreate(msg__, dst__, src__, status__) \ 1555 msg__ = kmalloc(sizeof(CsrWifiSmeEventMaskSetCfm), GFP_KERNEL); \ 1556 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_EVENT_MASK_SET_CFM, dst__, src__); \ 1557 msg__->status = (status__); 1558 1559 #define CsrWifiSmeEventMaskSetCfmSendTo(dst__, src__, status__) \ 1560 { \ 1561 CsrWifiSmeEventMaskSetCfm *msg__; \ 1562 CsrWifiSmeEventMaskSetCfmCreate(msg__, dst__, src__, status__); \ 1563 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1564 } 1565 1566 #define CsrWifiSmeEventMaskSetCfmSend(dst__, status__) \ 1567 CsrWifiSmeEventMaskSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 1568 1569 /******************************************************************************* 1570 1571 NAME 1572 CsrWifiSmeHostConfigGetReqSend 1573 1574 DESCRIPTION 1575 This primitive gets the value of the hostConfig parameter. 1576 1577 PARAMETERS 1578 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1579 interfaceTag - Interface Identifier; unique identifier of an interface 1580 1581 *******************************************************************************/ 1582 #define CsrWifiSmeHostConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \ 1583 msg__ = kmalloc(sizeof(CsrWifiSmeHostConfigGetReq), GFP_KERNEL); \ 1584 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_GET_REQ, dst__, src__); \ 1585 msg__->interfaceTag = (interfaceTag__); 1586 1587 #define CsrWifiSmeHostConfigGetReqSendTo(dst__, src__, interfaceTag__) \ 1588 { \ 1589 CsrWifiSmeHostConfigGetReq *msg__; \ 1590 CsrWifiSmeHostConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \ 1591 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1592 } 1593 1594 #define CsrWifiSmeHostConfigGetReqSend(src__, interfaceTag__) \ 1595 CsrWifiSmeHostConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__) 1596 1597 /******************************************************************************* 1598 1599 NAME 1600 CsrWifiSmeHostConfigGetCfmSend 1601 1602 DESCRIPTION 1603 This primitive reports the result of the request. 1604 1605 PARAMETERS 1606 queue - Destination Task Queue 1607 interfaceTag - Interface Identifier; unique identifier of an interface 1608 status - Reports the result of the request 1609 hostConfig - Current host power state. 1610 1611 *******************************************************************************/ 1612 #define CsrWifiSmeHostConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, hostConfig__) \ 1613 msg__ = kmalloc(sizeof(CsrWifiSmeHostConfigGetCfm), GFP_KERNEL); \ 1614 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_GET_CFM, dst__, src__); \ 1615 msg__->interfaceTag = (interfaceTag__); \ 1616 msg__->status = (status__); \ 1617 msg__->hostConfig = (hostConfig__); 1618 1619 #define CsrWifiSmeHostConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, hostConfig__) \ 1620 { \ 1621 CsrWifiSmeHostConfigGetCfm *msg__; \ 1622 CsrWifiSmeHostConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, hostConfig__); \ 1623 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1624 } 1625 1626 #define CsrWifiSmeHostConfigGetCfmSend(dst__, interfaceTag__, status__, hostConfig__) \ 1627 CsrWifiSmeHostConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, hostConfig__) 1628 1629 /******************************************************************************* 1630 1631 NAME 1632 CsrWifiSmeHostConfigSetReqSend 1633 1634 DESCRIPTION 1635 This primitive sets the value of the hostConfig parameter. 1636 1637 PARAMETERS 1638 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1639 interfaceTag - Interface Identifier; unique identifier of an interface 1640 hostConfig - Communicates a change of host power state (for example, on 1641 mains power, on battery power etc) and of the periodicity of 1642 traffic data 1643 1644 *******************************************************************************/ 1645 #define CsrWifiSmeHostConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, hostConfig__) \ 1646 msg__ = kmalloc(sizeof(CsrWifiSmeHostConfigSetReq), GFP_KERNEL); \ 1647 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_SET_REQ, dst__, src__); \ 1648 msg__->interfaceTag = (interfaceTag__); \ 1649 msg__->hostConfig = (hostConfig__); 1650 1651 #define CsrWifiSmeHostConfigSetReqSendTo(dst__, src__, interfaceTag__, hostConfig__) \ 1652 { \ 1653 CsrWifiSmeHostConfigSetReq *msg__; \ 1654 CsrWifiSmeHostConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, hostConfig__); \ 1655 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1656 } 1657 1658 #define CsrWifiSmeHostConfigSetReqSend(src__, interfaceTag__, hostConfig__) \ 1659 CsrWifiSmeHostConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, hostConfig__) 1660 1661 /******************************************************************************* 1662 1663 NAME 1664 CsrWifiSmeHostConfigSetCfmSend 1665 1666 DESCRIPTION 1667 This primitive reports the result of the request. 1668 1669 PARAMETERS 1670 queue - Destination Task Queue 1671 interfaceTag - Interface Identifier; unique identifier of an interface 1672 status - Reports the result of the request 1673 1674 *******************************************************************************/ 1675 #define CsrWifiSmeHostConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \ 1676 msg__ = kmalloc(sizeof(CsrWifiSmeHostConfigSetCfm), GFP_KERNEL); \ 1677 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_SET_CFM, dst__, src__); \ 1678 msg__->interfaceTag = (interfaceTag__); \ 1679 msg__->status = (status__); 1680 1681 #define CsrWifiSmeHostConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \ 1682 { \ 1683 CsrWifiSmeHostConfigSetCfm *msg__; \ 1684 CsrWifiSmeHostConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \ 1685 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1686 } 1687 1688 #define CsrWifiSmeHostConfigSetCfmSend(dst__, interfaceTag__, status__) \ 1689 CsrWifiSmeHostConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__) 1690 1691 /******************************************************************************* 1692 1693 NAME 1694 CsrWifiSmeIbssStationIndSend 1695 1696 DESCRIPTION 1697 The SME will send this primitive to indicate that a station has joined or 1698 left the ad-hoc network. 1699 1700 PARAMETERS 1701 queue - Destination Task Queue 1702 address - MAC address of the station that has joined or left 1703 isconnected - TRUE if the station joined, FALSE if the station left 1704 1705 *******************************************************************************/ 1706 #define CsrWifiSmeIbssStationIndCreate(msg__, dst__, src__, address__, isconnected__) \ 1707 msg__ = kmalloc(sizeof(CsrWifiSmeIbssStationInd), GFP_KERNEL); \ 1708 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_IBSS_STATION_IND, dst__, src__); \ 1709 msg__->address = (address__); \ 1710 msg__->isconnected = (isconnected__); 1711 1712 #define CsrWifiSmeIbssStationIndSendTo(dst__, src__, address__, isconnected__) \ 1713 { \ 1714 CsrWifiSmeIbssStationInd *msg__; \ 1715 CsrWifiSmeIbssStationIndCreate(msg__, dst__, src__, address__, isconnected__); \ 1716 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1717 } 1718 1719 #define CsrWifiSmeIbssStationIndSend(dst__, address__, isconnected__) \ 1720 CsrWifiSmeIbssStationIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, address__, isconnected__) 1721 1722 /******************************************************************************* 1723 1724 NAME 1725 CsrWifiSmeInfoIndSend 1726 1727 DESCRIPTION 1728 Message indicating a some info about current activity. Mostly of interest 1729 in testing but may be useful in the field. 1730 1731 PARAMETERS 1732 queue - Destination Task Queue 1733 infoMessage - Contains the message. 1734 1735 *******************************************************************************/ 1736 #define CsrWifiSmeInfoIndCreate(msg__, dst__, src__, infoMessage__) \ 1737 msg__ = kmalloc(sizeof(CsrWifiSmeInfoInd), GFP_KERNEL); \ 1738 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INFO_IND, dst__, src__); \ 1739 msg__->infoMessage = (infoMessage__); 1740 1741 #define CsrWifiSmeInfoIndSendTo(dst__, src__, infoMessage__) \ 1742 { \ 1743 CsrWifiSmeInfoInd *msg__; \ 1744 CsrWifiSmeInfoIndCreate(msg__, dst__, src__, infoMessage__); \ 1745 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1746 } 1747 1748 #define CsrWifiSmeInfoIndSend(dst__, infoMessage__) \ 1749 CsrWifiSmeInfoIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, infoMessage__) 1750 1751 /******************************************************************************* 1752 1753 NAME 1754 CsrWifiSmeInterfaceCapabilityGetReqSend 1755 1756 DESCRIPTION 1757 The Wireless Manager calls this primitive to ask the SME for the 1758 capabilities of the supported interfaces 1759 1760 PARAMETERS 1761 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1762 1763 *******************************************************************************/ 1764 #define CsrWifiSmeInterfaceCapabilityGetReqCreate(msg__, dst__, src__) \ 1765 msg__ = kmalloc(sizeof(CsrWifiSmeInterfaceCapabilityGetReq), GFP_KERNEL); \ 1766 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_REQ, dst__, src__); 1767 1768 #define CsrWifiSmeInterfaceCapabilityGetReqSendTo(dst__, src__) \ 1769 { \ 1770 CsrWifiSmeInterfaceCapabilityGetReq *msg__; \ 1771 CsrWifiSmeInterfaceCapabilityGetReqCreate(msg__, dst__, src__); \ 1772 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1773 } 1774 1775 #define CsrWifiSmeInterfaceCapabilityGetReqSend(src__) \ 1776 CsrWifiSmeInterfaceCapabilityGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 1777 1778 /******************************************************************************* 1779 1780 NAME 1781 CsrWifiSmeInterfaceCapabilityGetCfmSend 1782 1783 DESCRIPTION 1784 This primitive reports the result of the request. 1785 1786 PARAMETERS 1787 queue - Destination Task Queue 1788 status - Result of the request 1789 numInterfaces - Number of the interfaces supported 1790 capBitmap - Points to the list of capabilities bitmaps provided for each 1791 interface. 1792 The bits represent the following capabilities: 1793 -bits 7 to 4-Reserved 1794 -bit 3-AMP 1795 -bit 2-P2P 1796 -bit 1-AP 1797 -bit 0-STA 1798 1799 *******************************************************************************/ 1800 #define CsrWifiSmeInterfaceCapabilityGetCfmCreate(msg__, dst__, src__, status__, numInterfaces__, capBitmap__) \ 1801 msg__ = kmalloc(sizeof(CsrWifiSmeInterfaceCapabilityGetCfm), GFP_KERNEL); \ 1802 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_CFM, dst__, src__); \ 1803 msg__->status = (status__); \ 1804 msg__->numInterfaces = (numInterfaces__); \ 1805 memcpy(msg__->capBitmap, (capBitmap__), sizeof(u8) * 2); 1806 1807 #define CsrWifiSmeInterfaceCapabilityGetCfmSendTo(dst__, src__, status__, numInterfaces__, capBitmap__) \ 1808 { \ 1809 CsrWifiSmeInterfaceCapabilityGetCfm *msg__; \ 1810 CsrWifiSmeInterfaceCapabilityGetCfmCreate(msg__, dst__, src__, status__, numInterfaces__, capBitmap__); \ 1811 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1812 } 1813 1814 #define CsrWifiSmeInterfaceCapabilityGetCfmSend(dst__, status__, numInterfaces__, capBitmap__) \ 1815 CsrWifiSmeInterfaceCapabilityGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, numInterfaces__, capBitmap__) 1816 1817 /******************************************************************************* 1818 1819 NAME 1820 CsrWifiSmeKeyReqSend 1821 1822 DESCRIPTION 1823 The wireless manager application calls this primitive to add or remove 1824 keys that the chip should use for encryption of data. 1825 The interface allows the wireless manager application to add and remove 1826 keys according to the specified action. 1827 1828 PARAMETERS 1829 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1830 interfaceTag - Interface Identifier; unique identifier of an interface 1831 action - The value of the CsrWifiSmeListAction parameter instructs the 1832 driver to modify or provide the list of keys. 1833 CSR_WIFI_SME_LIST_ACTION_GET is not supported here. 1834 key - Key to be added or removed 1835 1836 *******************************************************************************/ 1837 #define CsrWifiSmeKeyReqCreate(msg__, dst__, src__, interfaceTag__, action__, key__) \ 1838 msg__ = kmalloc(sizeof(CsrWifiSmeKeyReq), GFP_KERNEL); \ 1839 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_KEY_REQ, dst__, src__); \ 1840 msg__->interfaceTag = (interfaceTag__); \ 1841 msg__->action = (action__); \ 1842 msg__->key = (key__); 1843 1844 #define CsrWifiSmeKeyReqSendTo(dst__, src__, interfaceTag__, action__, key__) \ 1845 { \ 1846 CsrWifiSmeKeyReq *msg__; \ 1847 CsrWifiSmeKeyReqCreate(msg__, dst__, src__, interfaceTag__, action__, key__); \ 1848 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1849 } 1850 1851 #define CsrWifiSmeKeyReqSend(src__, interfaceTag__, action__, key__) \ 1852 CsrWifiSmeKeyReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, key__) 1853 1854 /******************************************************************************* 1855 1856 NAME 1857 CsrWifiSmeKeyCfmSend 1858 1859 DESCRIPTION 1860 The SME calls the primitive to report the result of the request 1861 primitive. 1862 1863 PARAMETERS 1864 queue - Destination Task Queue 1865 interfaceTag - Interface Identifier; unique identifier of an interface 1866 status - Reports the result of the request 1867 action - Action in the request 1868 keyType - Type of the key added/deleted 1869 peerMacAddress - Peer MAC Address of the key added/deleted 1870 1871 *******************************************************************************/ 1872 #define CsrWifiSmeKeyCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, keyType__, peerMacAddress__) \ 1873 msg__ = kmalloc(sizeof(CsrWifiSmeKeyCfm), GFP_KERNEL); \ 1874 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_KEY_CFM, dst__, src__); \ 1875 msg__->interfaceTag = (interfaceTag__); \ 1876 msg__->status = (status__); \ 1877 msg__->action = (action__); \ 1878 msg__->keyType = (keyType__); \ 1879 msg__->peerMacAddress = (peerMacAddress__); 1880 1881 #define CsrWifiSmeKeyCfmSendTo(dst__, src__, interfaceTag__, status__, action__, keyType__, peerMacAddress__) \ 1882 { \ 1883 CsrWifiSmeKeyCfm *msg__; \ 1884 CsrWifiSmeKeyCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, keyType__, peerMacAddress__); \ 1885 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1886 } 1887 1888 #define CsrWifiSmeKeyCfmSend(dst__, interfaceTag__, status__, action__, keyType__, peerMacAddress__) \ 1889 CsrWifiSmeKeyCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, keyType__, peerMacAddress__) 1890 1891 /******************************************************************************* 1892 1893 NAME 1894 CsrWifiSmeLinkQualityGetReqSend 1895 1896 DESCRIPTION 1897 This primitive gets the value of the LinkQuality parameter. 1898 1899 PARAMETERS 1900 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 1901 interfaceTag - Interface Identifier; unique identifier of an interface 1902 1903 *******************************************************************************/ 1904 #define CsrWifiSmeLinkQualityGetReqCreate(msg__, dst__, src__, interfaceTag__) \ 1905 msg__ = kmalloc(sizeof(CsrWifiSmeLinkQualityGetReq), GFP_KERNEL); \ 1906 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_LINK_QUALITY_GET_REQ, dst__, src__); \ 1907 msg__->interfaceTag = (interfaceTag__); 1908 1909 #define CsrWifiSmeLinkQualityGetReqSendTo(dst__, src__, interfaceTag__) \ 1910 { \ 1911 CsrWifiSmeLinkQualityGetReq *msg__; \ 1912 CsrWifiSmeLinkQualityGetReqCreate(msg__, dst__, src__, interfaceTag__); \ 1913 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1914 } 1915 1916 #define CsrWifiSmeLinkQualityGetReqSend(src__, interfaceTag__) \ 1917 CsrWifiSmeLinkQualityGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__) 1918 1919 /******************************************************************************* 1920 1921 NAME 1922 CsrWifiSmeLinkQualityGetCfmSend 1923 1924 DESCRIPTION 1925 This primitive reports the result of the request. 1926 1927 PARAMETERS 1928 queue - Destination Task Queue 1929 interfaceTag - Interface Identifier; unique identifier of an interface 1930 status - Reports the result of the request 1931 linkQuality - Indicates the quality of the link 1932 1933 *******************************************************************************/ 1934 #define CsrWifiSmeLinkQualityGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, linkQuality__) \ 1935 msg__ = kmalloc(sizeof(CsrWifiSmeLinkQualityGetCfm), GFP_KERNEL); \ 1936 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_LINK_QUALITY_GET_CFM, dst__, src__); \ 1937 msg__->interfaceTag = (interfaceTag__); \ 1938 msg__->status = (status__); \ 1939 msg__->linkQuality = (linkQuality__); 1940 1941 #define CsrWifiSmeLinkQualityGetCfmSendTo(dst__, src__, interfaceTag__, status__, linkQuality__) \ 1942 { \ 1943 CsrWifiSmeLinkQualityGetCfm *msg__; \ 1944 CsrWifiSmeLinkQualityGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, linkQuality__); \ 1945 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1946 } 1947 1948 #define CsrWifiSmeLinkQualityGetCfmSend(dst__, interfaceTag__, status__, linkQuality__) \ 1949 CsrWifiSmeLinkQualityGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, linkQuality__) 1950 1951 /******************************************************************************* 1952 1953 NAME 1954 CsrWifiSmeMediaStatusIndSend 1955 1956 DESCRIPTION 1957 The SME sends this primitive to all the tasks that have registered to 1958 receive it when a network connection is established, lost or has moved to 1959 another AP. 1960 1961 PARAMETERS 1962 queue - Destination Task Queue 1963 interfaceTag - Interface Identifier; unique identifier of an interface 1964 mediaStatus - Indicates the media status 1965 connectionInfo - This parameter is relevant only if the mediaStatus is 1966 CSR_WIFI_SME_MEDIA_STATUS_CONNECTED: 1967 it points to the connection information for the new network 1968 disassocReason - This parameter is relevant only if the mediaStatus is 1969 CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED: 1970 if a disassociation has occurred it gives the reason of the 1971 disassociation 1972 deauthReason - This parameter is relevant only if the mediaStatus is 1973 CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED: 1974 if a deauthentication has occurred it gives the reason of 1975 the deauthentication 1976 1977 *******************************************************************************/ 1978 #define CsrWifiSmeMediaStatusIndCreate(msg__, dst__, src__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__) \ 1979 msg__ = kmalloc(sizeof(CsrWifiSmeMediaStatusInd), GFP_KERNEL); \ 1980 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MEDIA_STATUS_IND, dst__, src__); \ 1981 msg__->interfaceTag = (interfaceTag__); \ 1982 msg__->mediaStatus = (mediaStatus__); \ 1983 msg__->connectionInfo = (connectionInfo__); \ 1984 msg__->disassocReason = (disassocReason__); \ 1985 msg__->deauthReason = (deauthReason__); 1986 1987 #define CsrWifiSmeMediaStatusIndSendTo(dst__, src__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__) \ 1988 { \ 1989 CsrWifiSmeMediaStatusInd *msg__; \ 1990 CsrWifiSmeMediaStatusIndCreate(msg__, dst__, src__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__); \ 1991 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 1992 } 1993 1994 #define CsrWifiSmeMediaStatusIndSend(dst__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__) \ 1995 CsrWifiSmeMediaStatusIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__) 1996 1997 /******************************************************************************* 1998 1999 NAME 2000 CsrWifiSmeMibConfigGetReqSend 2001 2002 DESCRIPTION 2003 This primitive gets the value of the MibConfig parameter. 2004 2005 PARAMETERS 2006 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2007 2008 *******************************************************************************/ 2009 #define CsrWifiSmeMibConfigGetReqCreate(msg__, dst__, src__) \ 2010 msg__ = kmalloc(sizeof(CsrWifiSmeMibConfigGetReq), GFP_KERNEL); \ 2011 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_GET_REQ, dst__, src__); 2012 2013 #define CsrWifiSmeMibConfigGetReqSendTo(dst__, src__) \ 2014 { \ 2015 CsrWifiSmeMibConfigGetReq *msg__; \ 2016 CsrWifiSmeMibConfigGetReqCreate(msg__, dst__, src__); \ 2017 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2018 } 2019 2020 #define CsrWifiSmeMibConfigGetReqSend(src__) \ 2021 CsrWifiSmeMibConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 2022 2023 /******************************************************************************* 2024 2025 NAME 2026 CsrWifiSmeMibConfigGetCfmSend 2027 2028 DESCRIPTION 2029 This primitive reports the result of the request. 2030 2031 PARAMETERS 2032 queue - Destination Task Queue 2033 status - Reports the result of the request 2034 mibConfig - Reports various IEEE 802.11 attributes as currently configured 2035 2036 *******************************************************************************/ 2037 #define CsrWifiSmeMibConfigGetCfmCreate(msg__, dst__, src__, status__, mibConfig__) \ 2038 msg__ = kmalloc(sizeof(CsrWifiSmeMibConfigGetCfm), GFP_KERNEL); \ 2039 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_GET_CFM, dst__, src__); \ 2040 msg__->status = (status__); \ 2041 msg__->mibConfig = (mibConfig__); 2042 2043 #define CsrWifiSmeMibConfigGetCfmSendTo(dst__, src__, status__, mibConfig__) \ 2044 { \ 2045 CsrWifiSmeMibConfigGetCfm *msg__; \ 2046 CsrWifiSmeMibConfigGetCfmCreate(msg__, dst__, src__, status__, mibConfig__); \ 2047 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2048 } 2049 2050 #define CsrWifiSmeMibConfigGetCfmSend(dst__, status__, mibConfig__) \ 2051 CsrWifiSmeMibConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, mibConfig__) 2052 2053 /******************************************************************************* 2054 2055 NAME 2056 CsrWifiSmeMibConfigSetReqSend 2057 2058 DESCRIPTION 2059 This primitive sets the value of the MibConfig parameter. 2060 2061 PARAMETERS 2062 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2063 mibConfig - Conveys the desired value of various IEEE 802.11 attributes as 2064 currently configured 2065 2066 *******************************************************************************/ 2067 #define CsrWifiSmeMibConfigSetReqCreate(msg__, dst__, src__, mibConfig__) \ 2068 msg__ = kmalloc(sizeof(CsrWifiSmeMibConfigSetReq), GFP_KERNEL); \ 2069 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_SET_REQ, dst__, src__); \ 2070 msg__->mibConfig = (mibConfig__); 2071 2072 #define CsrWifiSmeMibConfigSetReqSendTo(dst__, src__, mibConfig__) \ 2073 { \ 2074 CsrWifiSmeMibConfigSetReq *msg__; \ 2075 CsrWifiSmeMibConfigSetReqCreate(msg__, dst__, src__, mibConfig__); \ 2076 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2077 } 2078 2079 #define CsrWifiSmeMibConfigSetReqSend(src__, mibConfig__) \ 2080 CsrWifiSmeMibConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibConfig__) 2081 2082 /******************************************************************************* 2083 2084 NAME 2085 CsrWifiSmeMibConfigSetCfmSend 2086 2087 DESCRIPTION 2088 This primitive reports the result of the request. 2089 2090 PARAMETERS 2091 queue - Destination Task Queue 2092 status - Reports the result of the request 2093 2094 *******************************************************************************/ 2095 #define CsrWifiSmeMibConfigSetCfmCreate(msg__, dst__, src__, status__) \ 2096 msg__ = kmalloc(sizeof(CsrWifiSmeMibConfigSetCfm), GFP_KERNEL); \ 2097 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_SET_CFM, dst__, src__); \ 2098 msg__->status = (status__); 2099 2100 #define CsrWifiSmeMibConfigSetCfmSendTo(dst__, src__, status__) \ 2101 { \ 2102 CsrWifiSmeMibConfigSetCfm *msg__; \ 2103 CsrWifiSmeMibConfigSetCfmCreate(msg__, dst__, src__, status__); \ 2104 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2105 } 2106 2107 #define CsrWifiSmeMibConfigSetCfmSend(dst__, status__) \ 2108 CsrWifiSmeMibConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 2109 2110 /******************************************************************************* 2111 2112 NAME 2113 CsrWifiSmeMibGetCfmSend 2114 2115 DESCRIPTION 2116 The SME calls this primitive to return the requested MIB variable values. 2117 2118 PARAMETERS 2119 queue - Destination Task Queue 2120 status - Reports the result of the request 2121 mibAttributeLength - Length of mibAttribute 2122 mibAttribute - Points to the VarBind or VarBindList containing the 2123 names and values of the MIB variables requested 2124 2125 *******************************************************************************/ 2126 #define CsrWifiSmeMibGetCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__) \ 2127 msg__ = kmalloc(sizeof(CsrWifiSmeMibGetCfm), GFP_KERNEL); \ 2128 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_CFM, dst__, src__); \ 2129 msg__->status = (status__); \ 2130 msg__->mibAttributeLength = (mibAttributeLength__); \ 2131 msg__->mibAttribute = (mibAttribute__); 2132 2133 #define CsrWifiSmeMibGetCfmSendTo(dst__, src__, status__, mibAttributeLength__, mibAttribute__) \ 2134 { \ 2135 CsrWifiSmeMibGetCfm *msg__; \ 2136 CsrWifiSmeMibGetCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__); \ 2137 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2138 } 2139 2140 #define CsrWifiSmeMibGetCfmSend(dst__, status__, mibAttributeLength__, mibAttribute__) \ 2141 CsrWifiSmeMibGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, mibAttributeLength__, mibAttribute__) 2142 2143 /******************************************************************************* 2144 2145 NAME 2146 CsrWifiSmeMibGetNextReqSend 2147 2148 DESCRIPTION 2149 To read a sequence of MIB parameters, for example a table, call this 2150 primitive to find the name of the next MIB variable 2151 2152 PARAMETERS 2153 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2154 mibAttributeLength - Length of mibAttribute 2155 mibAttribute - Points to a VarBind or VarBindList containing the 2156 name(s) of the MIB variable(s) to search from. 2157 2158 *******************************************************************************/ 2159 #define CsrWifiSmeMibGetNextReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__) \ 2160 msg__ = kmalloc(sizeof(CsrWifiSmeMibGetNextReq), GFP_KERNEL); \ 2161 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_NEXT_REQ, dst__, src__); \ 2162 msg__->mibAttributeLength = (mibAttributeLength__); \ 2163 msg__->mibAttribute = (mibAttribute__); 2164 2165 #define CsrWifiSmeMibGetNextReqSendTo(dst__, src__, mibAttributeLength__, mibAttribute__) \ 2166 { \ 2167 CsrWifiSmeMibGetNextReq *msg__; \ 2168 CsrWifiSmeMibGetNextReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__); \ 2169 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2170 } 2171 2172 #define CsrWifiSmeMibGetNextReqSend(src__, mibAttributeLength__, mibAttribute__) \ 2173 CsrWifiSmeMibGetNextReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibAttributeLength__, mibAttribute__) 2174 2175 /******************************************************************************* 2176 2177 NAME 2178 CsrWifiSmeMibGetNextCfmSend 2179 2180 DESCRIPTION 2181 The SME calls this primitive to return the requested MIB name(s). 2182 The wireless manager application can then read the value of the MIB 2183 variable using CSR_WIFI_SME_MIB_GET_REQ, using the names provided. 2184 2185 PARAMETERS 2186 queue - Destination Task Queue 2187 status - Reports the result of the request 2188 mibAttributeLength - Length of mibAttribute 2189 mibAttribute - Points to a VarBind or VarBindList containing the 2190 name(s) of the MIB variable(s) lexicographically 2191 following the name(s) given in the request 2192 2193 *******************************************************************************/ 2194 #define CsrWifiSmeMibGetNextCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__) \ 2195 msg__ = kmalloc(sizeof(CsrWifiSmeMibGetNextCfm), GFP_KERNEL); \ 2196 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_NEXT_CFM, dst__, src__); \ 2197 msg__->status = (status__); \ 2198 msg__->mibAttributeLength = (mibAttributeLength__); \ 2199 msg__->mibAttribute = (mibAttribute__); 2200 2201 #define CsrWifiSmeMibGetNextCfmSendTo(dst__, src__, status__, mibAttributeLength__, mibAttribute__) \ 2202 { \ 2203 CsrWifiSmeMibGetNextCfm *msg__; \ 2204 CsrWifiSmeMibGetNextCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__); \ 2205 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2206 } 2207 2208 #define CsrWifiSmeMibGetNextCfmSend(dst__, status__, mibAttributeLength__, mibAttribute__) \ 2209 CsrWifiSmeMibGetNextCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, mibAttributeLength__, mibAttribute__) 2210 2211 /******************************************************************************* 2212 2213 NAME 2214 CsrWifiSmeMibGetReqSend 2215 2216 DESCRIPTION 2217 The wireless manager application calls this primitive to retrieve one or 2218 more MIB variables. 2219 2220 PARAMETERS 2221 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2222 mibAttributeLength - Length of mibAttribute 2223 mibAttribute - Points to the VarBind or VarBindList containing the 2224 names of the MIB variables to be retrieved 2225 2226 *******************************************************************************/ 2227 #define CsrWifiSmeMibGetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__) \ 2228 msg__ = kmalloc(sizeof(CsrWifiSmeMibGetReq), GFP_KERNEL); \ 2229 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_REQ, dst__, src__); \ 2230 msg__->mibAttributeLength = (mibAttributeLength__); \ 2231 msg__->mibAttribute = (mibAttribute__); 2232 2233 #define CsrWifiSmeMibGetReqSendTo(dst__, src__, mibAttributeLength__, mibAttribute__) \ 2234 { \ 2235 CsrWifiSmeMibGetReq *msg__; \ 2236 CsrWifiSmeMibGetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__); \ 2237 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2238 } 2239 2240 #define CsrWifiSmeMibGetReqSend(src__, mibAttributeLength__, mibAttribute__) \ 2241 CsrWifiSmeMibGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibAttributeLength__, mibAttribute__) 2242 2243 /******************************************************************************* 2244 2245 NAME 2246 CsrWifiSmeMibSetReqSend 2247 2248 DESCRIPTION 2249 The SME provides raw access to the MIB on the chip, which may be used by 2250 some configuration or diagnostic utilities, but is not normally needed by 2251 the wireless manager application. 2252 The MIB access functions use BER encoded names (OID) of the MIB 2253 parameters and BER encoded values, as described in the chip Host 2254 Interface Protocol Specification. 2255 The MIB parameters are described in 'Wi-Fi 5.0.0 Management Information 2256 Base Reference Guide'. 2257 The wireless manager application calls this primitive to set one or more 2258 MIB variables 2259 2260 PARAMETERS 2261 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2262 mibAttributeLength - Length of mibAttribute 2263 mibAttribute - Points to the VarBind or VarBindList containing the 2264 names and values of the MIB variables to set 2265 2266 *******************************************************************************/ 2267 #define CsrWifiSmeMibSetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__) \ 2268 msg__ = kmalloc(sizeof(CsrWifiSmeMibSetReq), GFP_KERNEL); \ 2269 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_SET_REQ, dst__, src__); \ 2270 msg__->mibAttributeLength = (mibAttributeLength__); \ 2271 msg__->mibAttribute = (mibAttribute__); 2272 2273 #define CsrWifiSmeMibSetReqSendTo(dst__, src__, mibAttributeLength__, mibAttribute__) \ 2274 { \ 2275 CsrWifiSmeMibSetReq *msg__; \ 2276 CsrWifiSmeMibSetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__); \ 2277 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2278 } 2279 2280 #define CsrWifiSmeMibSetReqSend(src__, mibAttributeLength__, mibAttribute__) \ 2281 CsrWifiSmeMibSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibAttributeLength__, mibAttribute__) 2282 2283 /******************************************************************************* 2284 2285 NAME 2286 CsrWifiSmeMibSetCfmSend 2287 2288 DESCRIPTION 2289 The SME calls the primitive to report the result of the set primitive. 2290 2291 PARAMETERS 2292 queue - Destination Task Queue 2293 status - Reports the result of the request 2294 2295 *******************************************************************************/ 2296 #define CsrWifiSmeMibSetCfmCreate(msg__, dst__, src__, status__) \ 2297 msg__ = kmalloc(sizeof(CsrWifiSmeMibSetCfm), GFP_KERNEL); \ 2298 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_SET_CFM, dst__, src__); \ 2299 msg__->status = (status__); 2300 2301 #define CsrWifiSmeMibSetCfmSendTo(dst__, src__, status__) \ 2302 { \ 2303 CsrWifiSmeMibSetCfm *msg__; \ 2304 CsrWifiSmeMibSetCfmCreate(msg__, dst__, src__, status__); \ 2305 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2306 } 2307 2308 #define CsrWifiSmeMibSetCfmSend(dst__, status__) \ 2309 CsrWifiSmeMibSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 2310 2311 /******************************************************************************* 2312 2313 NAME 2314 CsrWifiSmeMicFailureIndSend 2315 2316 DESCRIPTION 2317 The SME sends this primitive to all the tasks that have registered to 2318 receive it whenever the chip firmware reports a MIC failure. 2319 2320 PARAMETERS 2321 queue - Destination Task Queue 2322 interfaceTag - Interface Identifier; unique identifier of an interface 2323 secondFailure - TRUE if this indication is for a second failure in 60 2324 seconds 2325 count - The number of MIC failure events since the connection was 2326 established 2327 address - MAC address of the transmitter that caused the MIC failure 2328 keyType - Type of key for which the failure occurred 2329 2330 *******************************************************************************/ 2331 #define CsrWifiSmeMicFailureIndCreate(msg__, dst__, src__, interfaceTag__, secondFailure__, count__, address__, keyType__) \ 2332 msg__ = kmalloc(sizeof(CsrWifiSmeMicFailureInd), GFP_KERNEL); \ 2333 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIC_FAILURE_IND, dst__, src__); \ 2334 msg__->interfaceTag = (interfaceTag__); \ 2335 msg__->secondFailure = (secondFailure__); \ 2336 msg__->count = (count__); \ 2337 msg__->address = (address__); \ 2338 msg__->keyType = (keyType__); 2339 2340 #define CsrWifiSmeMicFailureIndSendTo(dst__, src__, interfaceTag__, secondFailure__, count__, address__, keyType__) \ 2341 { \ 2342 CsrWifiSmeMicFailureInd *msg__; \ 2343 CsrWifiSmeMicFailureIndCreate(msg__, dst__, src__, interfaceTag__, secondFailure__, count__, address__, keyType__); \ 2344 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2345 } 2346 2347 #define CsrWifiSmeMicFailureIndSend(dst__, interfaceTag__, secondFailure__, count__, address__, keyType__) \ 2348 CsrWifiSmeMicFailureIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, secondFailure__, count__, address__, keyType__) 2349 2350 /******************************************************************************* 2351 2352 NAME 2353 CsrWifiSmeMulticastAddressReqSend 2354 2355 DESCRIPTION 2356 The wireless manager application calls this primitive to specify the 2357 multicast addresses which the chip should recognise. The interface allows 2358 the wireless manager application to query, add, remove and flush the 2359 multicast addresses for the network interface according to the specified 2360 action. 2361 2362 PARAMETERS 2363 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2364 interfaceTag - Interface Identifier; unique identifier of an interface 2365 action - The value of the CsrWifiSmeListAction parameter 2366 instructs the driver to modify or provide the list of 2367 MAC addresses. 2368 setAddressesCount - Number of MAC addresses sent with the primitive 2369 setAddresses - Pointer to the list of MAC Addresses sent with the 2370 primitive, set to NULL if none is sent. 2371 2372 *******************************************************************************/ 2373 #define CsrWifiSmeMulticastAddressReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \ 2374 msg__ = kmalloc(sizeof(CsrWifiSmeMulticastAddressReq), GFP_KERNEL); \ 2375 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MULTICAST_ADDRESS_REQ, dst__, src__); \ 2376 msg__->interfaceTag = (interfaceTag__); \ 2377 msg__->action = (action__); \ 2378 msg__->setAddressesCount = (setAddressesCount__); \ 2379 msg__->setAddresses = (setAddresses__); 2380 2381 #define CsrWifiSmeMulticastAddressReqSendTo(dst__, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \ 2382 { \ 2383 CsrWifiSmeMulticastAddressReq *msg__; \ 2384 CsrWifiSmeMulticastAddressReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__); \ 2385 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2386 } 2387 2388 #define CsrWifiSmeMulticastAddressReqSend(src__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \ 2389 CsrWifiSmeMulticastAddressReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__) 2390 2391 /******************************************************************************* 2392 2393 NAME 2394 CsrWifiSmeMulticastAddressCfmSend 2395 2396 DESCRIPTION 2397 The SME will call this primitive when the operation is complete. For a 2398 GET action, this primitive reports the current list of MAC addresses. 2399 2400 PARAMETERS 2401 queue - Destination Task Queue 2402 interfaceTag - Interface Identifier; unique identifier of an interface 2403 status - Reports the result of the request 2404 action - Action in the request 2405 getAddressesCount - This parameter is only relevant if action is 2406 CSR_WIFI_SME_LIST_ACTION_GET: 2407 number of MAC addresses sent with the primitive 2408 getAddresses - Pointer to the list of MAC Addresses sent with the 2409 primitive, set to NULL if none is sent. 2410 2411 *******************************************************************************/ 2412 #define CsrWifiSmeMulticastAddressCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__) \ 2413 msg__ = kmalloc(sizeof(CsrWifiSmeMulticastAddressCfm), GFP_KERNEL); \ 2414 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MULTICAST_ADDRESS_CFM, dst__, src__); \ 2415 msg__->interfaceTag = (interfaceTag__); \ 2416 msg__->status = (status__); \ 2417 msg__->action = (action__); \ 2418 msg__->getAddressesCount = (getAddressesCount__); \ 2419 msg__->getAddresses = (getAddresses__); 2420 2421 #define CsrWifiSmeMulticastAddressCfmSendTo(dst__, src__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__) \ 2422 { \ 2423 CsrWifiSmeMulticastAddressCfm *msg__; \ 2424 CsrWifiSmeMulticastAddressCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__); \ 2425 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2426 } 2427 2428 #define CsrWifiSmeMulticastAddressCfmSend(dst__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__) \ 2429 CsrWifiSmeMulticastAddressCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__) 2430 2431 /******************************************************************************* 2432 2433 NAME 2434 CsrWifiSmePacketFilterSetReqSend 2435 2436 DESCRIPTION 2437 The wireless manager application should call this primitive to enable or 2438 disable filtering of broadcast packets: uninteresting broadcast packets 2439 will be dropped by the Wi-Fi chip, instead of passing them up to the 2440 host. 2441 This has the advantage of saving power in the host application processor 2442 as it removes the need to process unwanted packets. 2443 All broadcast packets are filtered according to the filter and the filter 2444 mode provided, except ARP packets, which are filtered using 2445 arpFilterAddress. 2446 Filters are not cumulative: only the parameters specified in the most 2447 recent successful request are significant. 2448 For more information, see 'UniFi Firmware API Specification'. 2449 2450 PARAMETERS 2451 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2452 interfaceTag - Interface Identifier; unique identifier of an interface 2453 filterLength - Length of the filter in bytes. 2454 filterLength=0 disables the filter previously set 2455 filter - Points to the first byte of the filter provided, if any. 2456 This shall include zero or more instance of the 2457 information elements of one of these types 2458 * Traffic Classification (TCLAS) elements 2459 * WMM-SA TCLAS elements 2460 mode - Specifies whether the filter selects or excludes packets 2461 matching the filter 2462 arpFilterAddress - IPv4 address to be used for filtering the ARP packets. 2463 * If the specified address is the IPv4 broadcast address 2464 (255.255.255.255), all ARP packets are reported to the 2465 host, 2466 * If the specified address is NOT the IPv4 broadcast 2467 address, only ARP packets with the specified address in 2468 the Source or Target Protocol Address fields are reported 2469 to the host 2470 2471 *******************************************************************************/ 2472 #define CsrWifiSmePacketFilterSetReqCreate(msg__, dst__, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__) \ 2473 msg__ = kmalloc(sizeof(CsrWifiSmePacketFilterSetReq), GFP_KERNEL); \ 2474 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PACKET_FILTER_SET_REQ, dst__, src__); \ 2475 msg__->interfaceTag = (interfaceTag__); \ 2476 msg__->filterLength = (filterLength__); \ 2477 msg__->filter = (filter__); \ 2478 msg__->mode = (mode__); \ 2479 msg__->arpFilterAddress = (arpFilterAddress__); 2480 2481 #define CsrWifiSmePacketFilterSetReqSendTo(dst__, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__) \ 2482 { \ 2483 CsrWifiSmePacketFilterSetReq *msg__; \ 2484 CsrWifiSmePacketFilterSetReqCreate(msg__, dst__, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__); \ 2485 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2486 } 2487 2488 #define CsrWifiSmePacketFilterSetReqSend(src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__) \ 2489 CsrWifiSmePacketFilterSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__) 2490 2491 /******************************************************************************* 2492 2493 NAME 2494 CsrWifiSmePacketFilterSetCfmSend 2495 2496 DESCRIPTION 2497 The SME calls the primitive to report the result of the set primitive. 2498 2499 PARAMETERS 2500 queue - Destination Task Queue 2501 interfaceTag - Interface Identifier; unique identifier of an interface 2502 status - Reports the result of the request 2503 2504 *******************************************************************************/ 2505 #define CsrWifiSmePacketFilterSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \ 2506 msg__ = kmalloc(sizeof(CsrWifiSmePacketFilterSetCfm), GFP_KERNEL); \ 2507 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PACKET_FILTER_SET_CFM, dst__, src__); \ 2508 msg__->interfaceTag = (interfaceTag__); \ 2509 msg__->status = (status__); 2510 2511 #define CsrWifiSmePacketFilterSetCfmSendTo(dst__, src__, interfaceTag__, status__) \ 2512 { \ 2513 CsrWifiSmePacketFilterSetCfm *msg__; \ 2514 CsrWifiSmePacketFilterSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \ 2515 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2516 } 2517 2518 #define CsrWifiSmePacketFilterSetCfmSend(dst__, interfaceTag__, status__) \ 2519 CsrWifiSmePacketFilterSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__) 2520 2521 /******************************************************************************* 2522 2523 NAME 2524 CsrWifiSmePermanentMacAddressGetReqSend 2525 2526 DESCRIPTION 2527 This primitive retrieves the MAC address stored in EEPROM 2528 2529 PARAMETERS 2530 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2531 2532 *******************************************************************************/ 2533 #define CsrWifiSmePermanentMacAddressGetReqCreate(msg__, dst__, src__) \ 2534 msg__ = kmalloc(sizeof(CsrWifiSmePermanentMacAddressGetReq), GFP_KERNEL); \ 2535 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PERMANENT_MAC_ADDRESS_GET_REQ, dst__, src__); 2536 2537 #define CsrWifiSmePermanentMacAddressGetReqSendTo(dst__, src__) \ 2538 { \ 2539 CsrWifiSmePermanentMacAddressGetReq *msg__; \ 2540 CsrWifiSmePermanentMacAddressGetReqCreate(msg__, dst__, src__); \ 2541 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2542 } 2543 2544 #define CsrWifiSmePermanentMacAddressGetReqSend(src__) \ 2545 CsrWifiSmePermanentMacAddressGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 2546 2547 /******************************************************************************* 2548 2549 NAME 2550 CsrWifiSmePermanentMacAddressGetCfmSend 2551 2552 DESCRIPTION 2553 This primitive reports the result of the request. 2554 2555 PARAMETERS 2556 queue - Destination Task Queue 2557 status - Reports the result of the request 2558 permanentMacAddress - MAC address stored in the EEPROM 2559 2560 *******************************************************************************/ 2561 #define CsrWifiSmePermanentMacAddressGetCfmCreate(msg__, dst__, src__, status__, permanentMacAddress__) \ 2562 msg__ = kmalloc(sizeof(CsrWifiSmePermanentMacAddressGetCfm), GFP_KERNEL); \ 2563 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PERMANENT_MAC_ADDRESS_GET_CFM, dst__, src__); \ 2564 msg__->status = (status__); \ 2565 msg__->permanentMacAddress = (permanentMacAddress__); 2566 2567 #define CsrWifiSmePermanentMacAddressGetCfmSendTo(dst__, src__, status__, permanentMacAddress__) \ 2568 { \ 2569 CsrWifiSmePermanentMacAddressGetCfm *msg__; \ 2570 CsrWifiSmePermanentMacAddressGetCfmCreate(msg__, dst__, src__, status__, permanentMacAddress__); \ 2571 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2572 } 2573 2574 #define CsrWifiSmePermanentMacAddressGetCfmSend(dst__, status__, permanentMacAddress__) \ 2575 CsrWifiSmePermanentMacAddressGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, permanentMacAddress__) 2576 2577 /******************************************************************************* 2578 2579 NAME 2580 CsrWifiSmePmkidCandidateListIndSend 2581 2582 DESCRIPTION 2583 The SME will send this primitive to all the tasks that have registered to 2584 receive it when a new network supporting preauthentication and/or PMK 2585 caching is seen. 2586 2587 PARAMETERS 2588 queue - Destination Task Queue 2589 interfaceTag - Interface Identifier; unique identifier of an 2590 interface 2591 pmkidCandidatesCount - Number of PMKID candidates provided 2592 pmkidCandidates - Points to the first PMKID candidate 2593 2594 *******************************************************************************/ 2595 #define CsrWifiSmePmkidCandidateListIndCreate(msg__, dst__, src__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__) \ 2596 msg__ = kmalloc(sizeof(CsrWifiSmePmkidCandidateListInd), GFP_KERNEL); \ 2597 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PMKID_CANDIDATE_LIST_IND, dst__, src__); \ 2598 msg__->interfaceTag = (interfaceTag__); \ 2599 msg__->pmkidCandidatesCount = (pmkidCandidatesCount__); \ 2600 msg__->pmkidCandidates = (pmkidCandidates__); 2601 2602 #define CsrWifiSmePmkidCandidateListIndSendTo(dst__, src__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__) \ 2603 { \ 2604 CsrWifiSmePmkidCandidateListInd *msg__; \ 2605 CsrWifiSmePmkidCandidateListIndCreate(msg__, dst__, src__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__); \ 2606 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2607 } 2608 2609 #define CsrWifiSmePmkidCandidateListIndSend(dst__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__) \ 2610 CsrWifiSmePmkidCandidateListIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__) 2611 2612 /******************************************************************************* 2613 2614 NAME 2615 CsrWifiSmePmkidReqSend 2616 2617 DESCRIPTION 2618 The wireless manager application calls this primitive to request an 2619 operation on the SME PMKID list. 2620 The action argument specifies the operation to perform. 2621 When the connection is complete, the wireless manager application may 2622 then send and receive EAPOL packets to complete WPA or WPA2 2623 authentication if appropriate. 2624 The wireless manager application can then pass the resulting encryption 2625 keys using this primitive. 2626 2627 PARAMETERS 2628 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2629 interfaceTag - Interface Identifier; unique identifier of an interface 2630 action - The value of the CsrWifiSmeListAction parameter instructs 2631 the driver to modify or provide the list of PMKIDs. 2632 setPmkidsCount - Number of PMKIDs sent with the primitive 2633 setPmkids - Pointer to the list of PMKIDs sent with the primitive, set 2634 to NULL if none is sent. 2635 2636 *******************************************************************************/ 2637 #define CsrWifiSmePmkidReqCreate(msg__, dst__, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__) \ 2638 msg__ = kmalloc(sizeof(CsrWifiSmePmkidReq), GFP_KERNEL); \ 2639 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PMKID_REQ, dst__, src__); \ 2640 msg__->interfaceTag = (interfaceTag__); \ 2641 msg__->action = (action__); \ 2642 msg__->setPmkidsCount = (setPmkidsCount__); \ 2643 msg__->setPmkids = (setPmkids__); 2644 2645 #define CsrWifiSmePmkidReqSendTo(dst__, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__) \ 2646 { \ 2647 CsrWifiSmePmkidReq *msg__; \ 2648 CsrWifiSmePmkidReqCreate(msg__, dst__, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__); \ 2649 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2650 } 2651 2652 #define CsrWifiSmePmkidReqSend(src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__) \ 2653 CsrWifiSmePmkidReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__) 2654 2655 /******************************************************************************* 2656 2657 NAME 2658 CsrWifiSmePmkidCfmSend 2659 2660 DESCRIPTION 2661 The SME will call this primitive when the operation is complete. For a 2662 GET action, this primitive reports the current list of PMKIDs 2663 2664 PARAMETERS 2665 queue - Destination Task Queue 2666 interfaceTag - Interface Identifier; unique identifier of an interface 2667 status - Reports the result of the request 2668 action - Action in the request 2669 getPmkidsCount - This parameter is only relevant if action is 2670 CSR_WIFI_SME_LIST_ACTION_GET: 2671 number of PMKIDs sent with the primitive 2672 getPmkids - Pointer to the list of PMKIDs sent with the primitive, set 2673 to NULL if none is sent. 2674 2675 *******************************************************************************/ 2676 #define CsrWifiSmePmkidCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__) \ 2677 msg__ = kmalloc(sizeof(CsrWifiSmePmkidCfm), GFP_KERNEL); \ 2678 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PMKID_CFM, dst__, src__); \ 2679 msg__->interfaceTag = (interfaceTag__); \ 2680 msg__->status = (status__); \ 2681 msg__->action = (action__); \ 2682 msg__->getPmkidsCount = (getPmkidsCount__); \ 2683 msg__->getPmkids = (getPmkids__); 2684 2685 #define CsrWifiSmePmkidCfmSendTo(dst__, src__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__) \ 2686 { \ 2687 CsrWifiSmePmkidCfm *msg__; \ 2688 CsrWifiSmePmkidCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__); \ 2689 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2690 } 2691 2692 #define CsrWifiSmePmkidCfmSend(dst__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__) \ 2693 CsrWifiSmePmkidCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__) 2694 2695 /******************************************************************************* 2696 2697 NAME 2698 CsrWifiSmePowerConfigGetReqSend 2699 2700 DESCRIPTION 2701 This primitive gets the value of the PowerConfig parameter. 2702 2703 PARAMETERS 2704 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2705 2706 *******************************************************************************/ 2707 #define CsrWifiSmePowerConfigGetReqCreate(msg__, dst__, src__) \ 2708 msg__ = kmalloc(sizeof(CsrWifiSmePowerConfigGetReq), GFP_KERNEL); \ 2709 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_GET_REQ, dst__, src__); 2710 2711 #define CsrWifiSmePowerConfigGetReqSendTo(dst__, src__) \ 2712 { \ 2713 CsrWifiSmePowerConfigGetReq *msg__; \ 2714 CsrWifiSmePowerConfigGetReqCreate(msg__, dst__, src__); \ 2715 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2716 } 2717 2718 #define CsrWifiSmePowerConfigGetReqSend(src__) \ 2719 CsrWifiSmePowerConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 2720 2721 /******************************************************************************* 2722 2723 NAME 2724 CsrWifiSmePowerConfigGetCfmSend 2725 2726 DESCRIPTION 2727 This primitive reports the result of the request. 2728 2729 PARAMETERS 2730 queue - Destination Task Queue 2731 status - Reports the result of the request 2732 powerConfig - Returns the current parameters for the power configuration of 2733 the firmware 2734 2735 *******************************************************************************/ 2736 #define CsrWifiSmePowerConfigGetCfmCreate(msg__, dst__, src__, status__, powerConfig__) \ 2737 msg__ = kmalloc(sizeof(CsrWifiSmePowerConfigGetCfm), GFP_KERNEL); \ 2738 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_GET_CFM, dst__, src__); \ 2739 msg__->status = (status__); \ 2740 msg__->powerConfig = (powerConfig__); 2741 2742 #define CsrWifiSmePowerConfigGetCfmSendTo(dst__, src__, status__, powerConfig__) \ 2743 { \ 2744 CsrWifiSmePowerConfigGetCfm *msg__; \ 2745 CsrWifiSmePowerConfigGetCfmCreate(msg__, dst__, src__, status__, powerConfig__); \ 2746 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2747 } 2748 2749 #define CsrWifiSmePowerConfigGetCfmSend(dst__, status__, powerConfig__) \ 2750 CsrWifiSmePowerConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, powerConfig__) 2751 2752 /******************************************************************************* 2753 2754 NAME 2755 CsrWifiSmePowerConfigSetReqSend 2756 2757 DESCRIPTION 2758 This primitive sets the value of the PowerConfig parameter. 2759 2760 PARAMETERS 2761 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2762 powerConfig - Power saving configuration 2763 2764 *******************************************************************************/ 2765 #define CsrWifiSmePowerConfigSetReqCreate(msg__, dst__, src__, powerConfig__) \ 2766 msg__ = kmalloc(sizeof(CsrWifiSmePowerConfigSetReq), GFP_KERNEL); \ 2767 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_SET_REQ, dst__, src__); \ 2768 msg__->powerConfig = (powerConfig__); 2769 2770 #define CsrWifiSmePowerConfigSetReqSendTo(dst__, src__, powerConfig__) \ 2771 { \ 2772 CsrWifiSmePowerConfigSetReq *msg__; \ 2773 CsrWifiSmePowerConfigSetReqCreate(msg__, dst__, src__, powerConfig__); \ 2774 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2775 } 2776 2777 #define CsrWifiSmePowerConfigSetReqSend(src__, powerConfig__) \ 2778 CsrWifiSmePowerConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, powerConfig__) 2779 2780 /******************************************************************************* 2781 2782 NAME 2783 CsrWifiSmePowerConfigSetCfmSend 2784 2785 DESCRIPTION 2786 This primitive reports the result of the request. 2787 2788 PARAMETERS 2789 queue - Destination Task Queue 2790 status - Reports the result of the request 2791 2792 *******************************************************************************/ 2793 #define CsrWifiSmePowerConfigSetCfmCreate(msg__, dst__, src__, status__) \ 2794 msg__ = kmalloc(sizeof(CsrWifiSmePowerConfigSetCfm), GFP_KERNEL); \ 2795 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_SET_CFM, dst__, src__); \ 2796 msg__->status = (status__); 2797 2798 #define CsrWifiSmePowerConfigSetCfmSendTo(dst__, src__, status__) \ 2799 { \ 2800 CsrWifiSmePowerConfigSetCfm *msg__; \ 2801 CsrWifiSmePowerConfigSetCfmCreate(msg__, dst__, src__, status__); \ 2802 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2803 } 2804 2805 #define CsrWifiSmePowerConfigSetCfmSend(dst__, status__) \ 2806 CsrWifiSmePowerConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 2807 2808 /******************************************************************************* 2809 2810 NAME 2811 CsrWifiSmeRegulatoryDomainInfoGetReqSend 2812 2813 DESCRIPTION 2814 This primitive gets the value of the RegulatoryDomainInfo parameter. 2815 2816 PARAMETERS 2817 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2818 2819 *******************************************************************************/ 2820 #define CsrWifiSmeRegulatoryDomainInfoGetReqCreate(msg__, dst__, src__) \ 2821 msg__ = kmalloc(sizeof(CsrWifiSmeRegulatoryDomainInfoGetReq), GFP_KERNEL); \ 2822 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_REGULATORY_DOMAIN_INFO_GET_REQ, dst__, src__); 2823 2824 #define CsrWifiSmeRegulatoryDomainInfoGetReqSendTo(dst__, src__) \ 2825 { \ 2826 CsrWifiSmeRegulatoryDomainInfoGetReq *msg__; \ 2827 CsrWifiSmeRegulatoryDomainInfoGetReqCreate(msg__, dst__, src__); \ 2828 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2829 } 2830 2831 #define CsrWifiSmeRegulatoryDomainInfoGetReqSend(src__) \ 2832 CsrWifiSmeRegulatoryDomainInfoGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 2833 2834 /******************************************************************************* 2835 2836 NAME 2837 CsrWifiSmeRegulatoryDomainInfoGetCfmSend 2838 2839 DESCRIPTION 2840 This primitive reports the result of the request. 2841 2842 PARAMETERS 2843 queue - Destination Task Queue 2844 status - Reports the result of the request 2845 regDomInfo - Reports information and state related to regulatory domain 2846 operation. 2847 2848 *******************************************************************************/ 2849 #define CsrWifiSmeRegulatoryDomainInfoGetCfmCreate(msg__, dst__, src__, status__, regDomInfo__) \ 2850 msg__ = kmalloc(sizeof(CsrWifiSmeRegulatoryDomainInfoGetCfm), GFP_KERNEL); \ 2851 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_REGULATORY_DOMAIN_INFO_GET_CFM, dst__, src__); \ 2852 msg__->status = (status__); \ 2853 msg__->regDomInfo = (regDomInfo__); 2854 2855 #define CsrWifiSmeRegulatoryDomainInfoGetCfmSendTo(dst__, src__, status__, regDomInfo__) \ 2856 { \ 2857 CsrWifiSmeRegulatoryDomainInfoGetCfm *msg__; \ 2858 CsrWifiSmeRegulatoryDomainInfoGetCfmCreate(msg__, dst__, src__, status__, regDomInfo__); \ 2859 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2860 } 2861 2862 #define CsrWifiSmeRegulatoryDomainInfoGetCfmSend(dst__, status__, regDomInfo__) \ 2863 CsrWifiSmeRegulatoryDomainInfoGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, regDomInfo__) 2864 2865 /******************************************************************************* 2866 2867 NAME 2868 CsrWifiSmeRoamCompleteIndSend 2869 2870 DESCRIPTION 2871 The SME will send this primitive to all the tasks that have registered to 2872 receive it whenever it completes an attempt to roam to an AP. If the roam 2873 attempt was successful, status will be set to CSR_WIFI_SME_SUCCESS, 2874 otherwise it shall be set to the appropriate error code. 2875 2876 PARAMETERS 2877 queue - Destination Task Queue 2878 interfaceTag - Interface Identifier; unique identifier of an interface 2879 status - Reports the result of the roaming procedure 2880 2881 *******************************************************************************/ 2882 #define CsrWifiSmeRoamCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__) \ 2883 msg__ = kmalloc(sizeof(CsrWifiSmeRoamCompleteInd), GFP_KERNEL); \ 2884 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAM_COMPLETE_IND, dst__, src__); \ 2885 msg__->interfaceTag = (interfaceTag__); \ 2886 msg__->status = (status__); 2887 2888 #define CsrWifiSmeRoamCompleteIndSendTo(dst__, src__, interfaceTag__, status__) \ 2889 { \ 2890 CsrWifiSmeRoamCompleteInd *msg__; \ 2891 CsrWifiSmeRoamCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__); \ 2892 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2893 } 2894 2895 #define CsrWifiSmeRoamCompleteIndSend(dst__, interfaceTag__, status__) \ 2896 CsrWifiSmeRoamCompleteIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__) 2897 2898 /******************************************************************************* 2899 2900 NAME 2901 CsrWifiSmeRoamStartIndSend 2902 2903 DESCRIPTION 2904 The SME will send this primitive to all the tasks that have registered to 2905 receive it whenever it begins an attempt to roam to an AP. 2906 If the wireless manager application connect request specified the SSID 2907 and the BSSID was set to the broadcast address (0xFF 0xFF 0xFF 0xFF 0xFF 2908 0xFF), the SME monitors the signal quality and maintains a list of 2909 candidates to roam to. When the signal quality of the current connection 2910 falls below a threshold, and there is a candidate with better quality, 2911 the SME will attempt to the candidate AP. 2912 If the roaming procedure succeeds, the SME will also issue a Media 2913 Connect indication to inform the wireless manager application of the 2914 change. 2915 NOTE: to prevent the SME from initiating roaming the WMA must specify the 2916 BSSID in the connection request; this forces the SME to connect only to 2917 that AP. 2918 The wireless manager application can obtain statistics for roaming 2919 purposes using CSR_WIFI_SME_CONNECTION_QUALITY_IND and 2920 CSR_WIFI_SME_CONNECTION_STATS_GET_REQ. 2921 When the wireless manager application wishes to roam to another AP, it 2922 must issue a connection request specifying the BSSID of the desired AP. 2923 2924 PARAMETERS 2925 queue - Destination Task Queue 2926 interfaceTag - Interface Identifier; unique identifier of an interface 2927 roamReason - Indicates the reason for starting the roaming procedure 2928 reason80211 - Indicates the reason for deauthentication or disassociation 2929 2930 *******************************************************************************/ 2931 #define CsrWifiSmeRoamStartIndCreate(msg__, dst__, src__, interfaceTag__, roamReason__, reason80211__) \ 2932 msg__ = kmalloc(sizeof(CsrWifiSmeRoamStartInd), GFP_KERNEL); \ 2933 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAM_START_IND, dst__, src__); \ 2934 msg__->interfaceTag = (interfaceTag__); \ 2935 msg__->roamReason = (roamReason__); \ 2936 msg__->reason80211 = (reason80211__); 2937 2938 #define CsrWifiSmeRoamStartIndSendTo(dst__, src__, interfaceTag__, roamReason__, reason80211__) \ 2939 { \ 2940 CsrWifiSmeRoamStartInd *msg__; \ 2941 CsrWifiSmeRoamStartIndCreate(msg__, dst__, src__, interfaceTag__, roamReason__, reason80211__); \ 2942 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2943 } 2944 2945 #define CsrWifiSmeRoamStartIndSend(dst__, interfaceTag__, roamReason__, reason80211__) \ 2946 CsrWifiSmeRoamStartIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, roamReason__, reason80211__) 2947 2948 /******************************************************************************* 2949 2950 NAME 2951 CsrWifiSmeRoamingConfigGetReqSend 2952 2953 DESCRIPTION 2954 This primitive gets the value of the RoamingConfig parameter. 2955 2956 PARAMETERS 2957 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 2958 interfaceTag - Interface Identifier; unique identifier of an interface 2959 2960 *******************************************************************************/ 2961 #define CsrWifiSmeRoamingConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \ 2962 msg__ = kmalloc(sizeof(CsrWifiSmeRoamingConfigGetReq), GFP_KERNEL); \ 2963 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_GET_REQ, dst__, src__); \ 2964 msg__->interfaceTag = (interfaceTag__); 2965 2966 #define CsrWifiSmeRoamingConfigGetReqSendTo(dst__, src__, interfaceTag__) \ 2967 { \ 2968 CsrWifiSmeRoamingConfigGetReq *msg__; \ 2969 CsrWifiSmeRoamingConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \ 2970 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 2971 } 2972 2973 #define CsrWifiSmeRoamingConfigGetReqSend(src__, interfaceTag__) \ 2974 CsrWifiSmeRoamingConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__) 2975 2976 /******************************************************************************* 2977 2978 NAME 2979 CsrWifiSmeRoamingConfigGetCfmSend 2980 2981 DESCRIPTION 2982 This primitive reports the result of the request. 2983 2984 PARAMETERS 2985 queue - Destination Task Queue 2986 interfaceTag - Interface Identifier; unique identifier of an interface 2987 status - Reports the result of the request 2988 roamingConfig - Reports the roaming behaviour of the driver and firmware 2989 2990 *******************************************************************************/ 2991 #define CsrWifiSmeRoamingConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, roamingConfig__) \ 2992 msg__ = kmalloc(sizeof(CsrWifiSmeRoamingConfigGetCfm), GFP_KERNEL); \ 2993 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_GET_CFM, dst__, src__); \ 2994 msg__->interfaceTag = (interfaceTag__); \ 2995 msg__->status = (status__); \ 2996 msg__->roamingConfig = (roamingConfig__); 2997 2998 #define CsrWifiSmeRoamingConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, roamingConfig__) \ 2999 { \ 3000 CsrWifiSmeRoamingConfigGetCfm *msg__; \ 3001 CsrWifiSmeRoamingConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, roamingConfig__); \ 3002 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3003 } 3004 3005 #define CsrWifiSmeRoamingConfigGetCfmSend(dst__, interfaceTag__, status__, roamingConfig__) \ 3006 CsrWifiSmeRoamingConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, roamingConfig__) 3007 3008 /******************************************************************************* 3009 3010 NAME 3011 CsrWifiSmeRoamingConfigSetReqSend 3012 3013 DESCRIPTION 3014 This primitive sets the value of the RoamingConfig parameter. 3015 3016 PARAMETERS 3017 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3018 interfaceTag - Interface Identifier; unique identifier of an interface 3019 roamingConfig - Desired roaming behaviour values 3020 3021 *******************************************************************************/ 3022 #define CsrWifiSmeRoamingConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, roamingConfig__) \ 3023 msg__ = kmalloc(sizeof(CsrWifiSmeRoamingConfigSetReq), GFP_KERNEL); \ 3024 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_SET_REQ, dst__, src__); \ 3025 msg__->interfaceTag = (interfaceTag__); \ 3026 msg__->roamingConfig = (roamingConfig__); 3027 3028 #define CsrWifiSmeRoamingConfigSetReqSendTo(dst__, src__, interfaceTag__, roamingConfig__) \ 3029 { \ 3030 CsrWifiSmeRoamingConfigSetReq *msg__; \ 3031 CsrWifiSmeRoamingConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, roamingConfig__); \ 3032 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3033 } 3034 3035 #define CsrWifiSmeRoamingConfigSetReqSend(src__, interfaceTag__, roamingConfig__) \ 3036 CsrWifiSmeRoamingConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, roamingConfig__) 3037 3038 /******************************************************************************* 3039 3040 NAME 3041 CsrWifiSmeRoamingConfigSetCfmSend 3042 3043 DESCRIPTION 3044 This primitive sets the value of the RoamingConfig parameter. 3045 3046 PARAMETERS 3047 queue - Destination Task Queue 3048 interfaceTag - Interface Identifier; unique identifier of an interface 3049 status - Reports the result of the request 3050 3051 *******************************************************************************/ 3052 #define CsrWifiSmeRoamingConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \ 3053 msg__ = kmalloc(sizeof(CsrWifiSmeRoamingConfigSetCfm), GFP_KERNEL); \ 3054 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_SET_CFM, dst__, src__); \ 3055 msg__->interfaceTag = (interfaceTag__); \ 3056 msg__->status = (status__); 3057 3058 #define CsrWifiSmeRoamingConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \ 3059 { \ 3060 CsrWifiSmeRoamingConfigSetCfm *msg__; \ 3061 CsrWifiSmeRoamingConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \ 3062 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3063 } 3064 3065 #define CsrWifiSmeRoamingConfigSetCfmSend(dst__, interfaceTag__, status__) \ 3066 CsrWifiSmeRoamingConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__) 3067 3068 /******************************************************************************* 3069 3070 NAME 3071 CsrWifiSmeScanConfigGetReqSend 3072 3073 DESCRIPTION 3074 This primitive gets the value of the ScanConfig parameter. 3075 3076 PARAMETERS 3077 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3078 3079 *******************************************************************************/ 3080 #define CsrWifiSmeScanConfigGetReqCreate(msg__, dst__, src__) \ 3081 msg__ = kmalloc(sizeof(CsrWifiSmeScanConfigGetReq), GFP_KERNEL); \ 3082 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_GET_REQ, dst__, src__); 3083 3084 #define CsrWifiSmeScanConfigGetReqSendTo(dst__, src__) \ 3085 { \ 3086 CsrWifiSmeScanConfigGetReq *msg__; \ 3087 CsrWifiSmeScanConfigGetReqCreate(msg__, dst__, src__); \ 3088 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3089 } 3090 3091 #define CsrWifiSmeScanConfigGetReqSend(src__) \ 3092 CsrWifiSmeScanConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 3093 3094 /******************************************************************************* 3095 3096 NAME 3097 CsrWifiSmeScanConfigGetCfmSend 3098 3099 DESCRIPTION 3100 This primitive reports the result of the request. 3101 3102 PARAMETERS 3103 queue - Destination Task Queue 3104 status - Reports the result of the request 3105 scanConfig - Returns the current parameters for the autonomous scanning 3106 behaviour of the firmware 3107 3108 *******************************************************************************/ 3109 #define CsrWifiSmeScanConfigGetCfmCreate(msg__, dst__, src__, status__, scanConfig__) \ 3110 msg__ = kmalloc(sizeof(CsrWifiSmeScanConfigGetCfm), GFP_KERNEL); \ 3111 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_GET_CFM, dst__, src__); \ 3112 msg__->status = (status__); \ 3113 msg__->scanConfig = (scanConfig__); 3114 3115 #define CsrWifiSmeScanConfigGetCfmSendTo(dst__, src__, status__, scanConfig__) \ 3116 { \ 3117 CsrWifiSmeScanConfigGetCfm *msg__; \ 3118 CsrWifiSmeScanConfigGetCfmCreate(msg__, dst__, src__, status__, scanConfig__); \ 3119 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3120 } 3121 3122 #define CsrWifiSmeScanConfigGetCfmSend(dst__, status__, scanConfig__) \ 3123 CsrWifiSmeScanConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, scanConfig__) 3124 3125 /******************************************************************************* 3126 3127 NAME 3128 CsrWifiSmeScanConfigSetReqSend 3129 3130 DESCRIPTION 3131 This primitive sets the value of the ScanConfig parameter. 3132 The SME normally configures the firmware to perform autonomous scanning 3133 without involving the host. 3134 The firmware passes beacon / probe response or indicates loss of beacon 3135 on certain changes of state, for example: 3136 * A new AP is seen for the first time 3137 * An AP is no longer visible 3138 * The signal strength of an AP changes by more than a certain amount, as 3139 configured by the thresholds in the scanConfig parameter 3140 In addition to the autonomous scan, the wireless manager application may 3141 request a scan at any time using CSR_WIFI_SME_SCAN_FULL_REQ. 3142 3143 PARAMETERS 3144 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3145 scanConfig - Reports the configuration for the autonomous scanning behaviour 3146 of the firmware 3147 3148 *******************************************************************************/ 3149 #define CsrWifiSmeScanConfigSetReqCreate(msg__, dst__, src__, scanConfig__) \ 3150 msg__ = kmalloc(sizeof(CsrWifiSmeScanConfigSetReq), GFP_KERNEL); \ 3151 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_SET_REQ, dst__, src__); \ 3152 msg__->scanConfig = (scanConfig__); 3153 3154 #define CsrWifiSmeScanConfigSetReqSendTo(dst__, src__, scanConfig__) \ 3155 { \ 3156 CsrWifiSmeScanConfigSetReq *msg__; \ 3157 CsrWifiSmeScanConfigSetReqCreate(msg__, dst__, src__, scanConfig__); \ 3158 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3159 } 3160 3161 #define CsrWifiSmeScanConfigSetReqSend(src__, scanConfig__) \ 3162 CsrWifiSmeScanConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, scanConfig__) 3163 3164 /******************************************************************************* 3165 3166 NAME 3167 CsrWifiSmeScanConfigSetCfmSend 3168 3169 DESCRIPTION 3170 This primitive reports the result of the request. 3171 3172 PARAMETERS 3173 queue - Destination Task Queue 3174 status - Reports the result of the request 3175 3176 *******************************************************************************/ 3177 #define CsrWifiSmeScanConfigSetCfmCreate(msg__, dst__, src__, status__) \ 3178 msg__ = kmalloc(sizeof(CsrWifiSmeScanConfigSetCfm), GFP_KERNEL); \ 3179 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_SET_CFM, dst__, src__); \ 3180 msg__->status = (status__); 3181 3182 #define CsrWifiSmeScanConfigSetCfmSendTo(dst__, src__, status__) \ 3183 { \ 3184 CsrWifiSmeScanConfigSetCfm *msg__; \ 3185 CsrWifiSmeScanConfigSetCfmCreate(msg__, dst__, src__, status__); \ 3186 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3187 } 3188 3189 #define CsrWifiSmeScanConfigSetCfmSend(dst__, status__) \ 3190 CsrWifiSmeScanConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 3191 3192 /******************************************************************************* 3193 3194 NAME 3195 CsrWifiSmeScanFullReqSend 3196 3197 DESCRIPTION 3198 The wireless manager application should call this primitive to request a 3199 full scan. 3200 Channels are scanned actively or passively according to the requirement 3201 set by regulatory domain. 3202 If the SME receives this primitive while a full scan is going on, the new 3203 request is buffered and it will be served after the current full scan is 3204 completed. 3205 3206 PARAMETERS 3207 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3208 ssidCount - Number of SSIDs provided. 3209 If it is 0, the SME will attempt to detect any network 3210 ssid - Points to the first SSID provided, if any. 3211 bssid - BSS identifier. 3212 If it is equal to FF-FF-FF-FF-FF, the SME will listen for 3213 messages from any BSS. 3214 If it is different from FF-FF-FF-FF-FF and any SSID is 3215 provided, one SSID must match the network of the BSS. 3216 forceScan - Forces the scan even if the SME is in a state which would 3217 normally prevent it (e.g. autonomous scan is running). 3218 bssType - Type of BSS to scan for 3219 scanType - Type of scan to perform 3220 channelListCount - Number of channels provided. 3221 If it is 0, the SME will initiate a scan of all the 3222 supported channels that are permitted by the current 3223 regulatory domain. 3224 channelList - Points to the first channel , or NULL if channelListCount 3225 is zero. 3226 probeIeLength - Length of the information element in bytes to be sent 3227 with the probe message. 3228 probeIe - Points to the first byte of the information element to be 3229 sent with the probe message. 3230 3231 *******************************************************************************/ 3232 #define CsrWifiSmeScanFullReqCreate(msg__, dst__, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__) \ 3233 msg__ = kmalloc(sizeof(CsrWifiSmeScanFullReq), GFP_KERNEL); \ 3234 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_FULL_REQ, dst__, src__); \ 3235 msg__->ssidCount = (ssidCount__); \ 3236 msg__->ssid = (ssid__); \ 3237 msg__->bssid = (bssid__); \ 3238 msg__->forceScan = (forceScan__); \ 3239 msg__->bssType = (bssType__); \ 3240 msg__->scanType = (scanType__); \ 3241 msg__->channelListCount = (channelListCount__); \ 3242 msg__->channelList = (channelList__); \ 3243 msg__->probeIeLength = (probeIeLength__); \ 3244 msg__->probeIe = (probeIe__); 3245 3246 #define CsrWifiSmeScanFullReqSendTo(dst__, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__) \ 3247 { \ 3248 CsrWifiSmeScanFullReq *msg__; \ 3249 CsrWifiSmeScanFullReqCreate(msg__, dst__, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__); \ 3250 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3251 } 3252 3253 #define CsrWifiSmeScanFullReqSend(src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__) \ 3254 CsrWifiSmeScanFullReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__) 3255 3256 /******************************************************************************* 3257 3258 NAME 3259 CsrWifiSmeScanFullCfmSend 3260 3261 DESCRIPTION 3262 The SME calls this primitive when the results from the scan are 3263 available. 3264 3265 PARAMETERS 3266 queue - Destination Task Queue 3267 status - Reports the result of the request 3268 3269 *******************************************************************************/ 3270 #define CsrWifiSmeScanFullCfmCreate(msg__, dst__, src__, status__) \ 3271 msg__ = kmalloc(sizeof(CsrWifiSmeScanFullCfm), GFP_KERNEL); \ 3272 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_FULL_CFM, dst__, src__); \ 3273 msg__->status = (status__); 3274 3275 #define CsrWifiSmeScanFullCfmSendTo(dst__, src__, status__) \ 3276 { \ 3277 CsrWifiSmeScanFullCfm *msg__; \ 3278 CsrWifiSmeScanFullCfmCreate(msg__, dst__, src__, status__); \ 3279 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3280 } 3281 3282 #define CsrWifiSmeScanFullCfmSend(dst__, status__) \ 3283 CsrWifiSmeScanFullCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 3284 3285 /******************************************************************************* 3286 3287 NAME 3288 CsrWifiSmeScanResultIndSend 3289 3290 DESCRIPTION 3291 The SME sends this primitive to all the tasks that have registered to 3292 receive it whenever a scan indication is received from the firmware. 3293 3294 PARAMETERS 3295 queue - Destination Task Queue 3296 result - Points to a buffer containing a scan result. 3297 3298 *******************************************************************************/ 3299 #define CsrWifiSmeScanResultIndCreate(msg__, dst__, src__, result__) \ 3300 msg__ = kmalloc(sizeof(CsrWifiSmeScanResultInd), GFP_KERNEL); \ 3301 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULT_IND, dst__, src__); \ 3302 msg__->result = (result__); 3303 3304 #define CsrWifiSmeScanResultIndSendTo(dst__, src__, result__) \ 3305 { \ 3306 CsrWifiSmeScanResultInd *msg__; \ 3307 CsrWifiSmeScanResultIndCreate(msg__, dst__, src__, result__); \ 3308 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3309 } 3310 3311 #define CsrWifiSmeScanResultIndSend(dst__, result__) \ 3312 CsrWifiSmeScanResultIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, result__) 3313 3314 /******************************************************************************* 3315 3316 NAME 3317 CsrWifiSmeScanResultsFlushReqSend 3318 3319 DESCRIPTION 3320 The Wireless Manager calls this primitive to ask the SME to delete all 3321 scan results from its cache, except for the scan result of any currently 3322 connected network. 3323 As scan results are received by the SME from the firmware, they are 3324 cached in the SME memory. 3325 Any time the Wireless Manager requests scan results, they are returned 3326 from the SME internal cache. 3327 For some applications it may be desirable to clear this cache prior to 3328 requesting that a scan be performed; this will ensure that the cache then 3329 only contains the networks detected in the most recent scan. 3330 3331 PARAMETERS 3332 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3333 3334 *******************************************************************************/ 3335 #define CsrWifiSmeScanResultsFlushReqCreate(msg__, dst__, src__) \ 3336 msg__ = kmalloc(sizeof(CsrWifiSmeScanResultsFlushReq), GFP_KERNEL); \ 3337 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_FLUSH_REQ, dst__, src__); 3338 3339 #define CsrWifiSmeScanResultsFlushReqSendTo(dst__, src__) \ 3340 { \ 3341 CsrWifiSmeScanResultsFlushReq *msg__; \ 3342 CsrWifiSmeScanResultsFlushReqCreate(msg__, dst__, src__); \ 3343 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3344 } 3345 3346 #define CsrWifiSmeScanResultsFlushReqSend(src__) \ 3347 CsrWifiSmeScanResultsFlushReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 3348 3349 /******************************************************************************* 3350 3351 NAME 3352 CsrWifiSmeScanResultsFlushCfmSend 3353 3354 DESCRIPTION 3355 The SME will call this primitive when the cache has been cleared. 3356 3357 PARAMETERS 3358 queue - Destination Task Queue 3359 status - Reports the result of the request 3360 3361 *******************************************************************************/ 3362 #define CsrWifiSmeScanResultsFlushCfmCreate(msg__, dst__, src__, status__) \ 3363 msg__ = kmalloc(sizeof(CsrWifiSmeScanResultsFlushCfm), GFP_KERNEL); \ 3364 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_FLUSH_CFM, dst__, src__); \ 3365 msg__->status = (status__); 3366 3367 #define CsrWifiSmeScanResultsFlushCfmSendTo(dst__, src__, status__) \ 3368 { \ 3369 CsrWifiSmeScanResultsFlushCfm *msg__; \ 3370 CsrWifiSmeScanResultsFlushCfmCreate(msg__, dst__, src__, status__); \ 3371 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3372 } 3373 3374 #define CsrWifiSmeScanResultsFlushCfmSend(dst__, status__) \ 3375 CsrWifiSmeScanResultsFlushCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 3376 3377 /******************************************************************************* 3378 3379 NAME 3380 CsrWifiSmeScanResultsGetReqSend 3381 3382 DESCRIPTION 3383 The wireless manager application calls this primitive to retrieve the 3384 current set of scan results, either after receiving a successful 3385 CSR_WIFI_SME_SCAN_FULL_CFM, or to get autonomous scan results. 3386 3387 PARAMETERS 3388 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3389 3390 *******************************************************************************/ 3391 #define CsrWifiSmeScanResultsGetReqCreate(msg__, dst__, src__) \ 3392 msg__ = kmalloc(sizeof(CsrWifiSmeScanResultsGetReq), GFP_KERNEL); \ 3393 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_GET_REQ, dst__, src__); 3394 3395 #define CsrWifiSmeScanResultsGetReqSendTo(dst__, src__) \ 3396 { \ 3397 CsrWifiSmeScanResultsGetReq *msg__; \ 3398 CsrWifiSmeScanResultsGetReqCreate(msg__, dst__, src__); \ 3399 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3400 } 3401 3402 #define CsrWifiSmeScanResultsGetReqSend(src__) \ 3403 CsrWifiSmeScanResultsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 3404 3405 /******************************************************************************* 3406 3407 NAME 3408 CsrWifiSmeScanResultsGetCfmSend 3409 3410 DESCRIPTION 3411 The SME sends this primitive to provide the current set of scan results. 3412 3413 PARAMETERS 3414 queue - Destination Task Queue 3415 status - Reports the result of the request 3416 scanResultsCount - Number of scan results 3417 scanResults - Points to a buffer containing an array of 3418 CsrWifiSmeScanResult structures. 3419 3420 *******************************************************************************/ 3421 #define CsrWifiSmeScanResultsGetCfmCreate(msg__, dst__, src__, status__, scanResultsCount__, scanResults__) \ 3422 msg__ = kmalloc(sizeof(CsrWifiSmeScanResultsGetCfm), GFP_KERNEL); \ 3423 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_GET_CFM, dst__, src__); \ 3424 msg__->status = (status__); \ 3425 msg__->scanResultsCount = (scanResultsCount__); \ 3426 msg__->scanResults = (scanResults__); 3427 3428 #define CsrWifiSmeScanResultsGetCfmSendTo(dst__, src__, status__, scanResultsCount__, scanResults__) \ 3429 { \ 3430 CsrWifiSmeScanResultsGetCfm *msg__; \ 3431 CsrWifiSmeScanResultsGetCfmCreate(msg__, dst__, src__, status__, scanResultsCount__, scanResults__); \ 3432 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3433 } 3434 3435 #define CsrWifiSmeScanResultsGetCfmSend(dst__, status__, scanResultsCount__, scanResults__) \ 3436 CsrWifiSmeScanResultsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, scanResultsCount__, scanResults__) 3437 3438 /******************************************************************************* 3439 3440 NAME 3441 CsrWifiSmeSetReqSend 3442 3443 DESCRIPTION 3444 Used to pass custom data to the SME. Format is the same as 802.11 Info 3445 Elements => | Id | Length | Data 3446 1) Cmanr Test Mode "Id:0 Length:1 Data:0x00 = OFF 0x01 = ON" "0x00 0x01 3447 (0x00|0x01)" 3448 3449 PARAMETERS 3450 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3451 dataLength - Number of bytes in the buffer pointed to by 'data' 3452 data - Pointer to the buffer containing 'dataLength' bytes 3453 3454 *******************************************************************************/ 3455 #define CsrWifiSmeSetReqCreate(msg__, dst__, src__, dataLength__, data__) \ 3456 msg__ = kmalloc(sizeof(CsrWifiSmeSetReq), GFP_KERNEL); \ 3457 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SET_REQ, dst__, src__); \ 3458 msg__->dataLength = (dataLength__); \ 3459 msg__->data = (data__); 3460 3461 #define CsrWifiSmeSetReqSendTo(dst__, src__, dataLength__, data__) \ 3462 { \ 3463 CsrWifiSmeSetReq *msg__; \ 3464 CsrWifiSmeSetReqCreate(msg__, dst__, src__, dataLength__, data__); \ 3465 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3466 } 3467 3468 #define CsrWifiSmeSetReqSend(src__, dataLength__, data__) \ 3469 CsrWifiSmeSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, dataLength__, data__) 3470 3471 /******************************************************************************* 3472 3473 NAME 3474 CsrWifiSmeSmeCommonConfigGetReqSend 3475 3476 DESCRIPTION 3477 This primitive gets the value of the Sme common parameter. 3478 3479 PARAMETERS 3480 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3481 3482 *******************************************************************************/ 3483 #define CsrWifiSmeSmeCommonConfigGetReqCreate(msg__, dst__, src__) \ 3484 msg__ = kmalloc(sizeof(CsrWifiSmeSmeCommonConfigGetReq), GFP_KERNEL); \ 3485 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_GET_REQ, dst__, src__); 3486 3487 #define CsrWifiSmeSmeCommonConfigGetReqSendTo(dst__, src__) \ 3488 { \ 3489 CsrWifiSmeSmeCommonConfigGetReq *msg__; \ 3490 CsrWifiSmeSmeCommonConfigGetReqCreate(msg__, dst__, src__); \ 3491 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3492 } 3493 3494 #define CsrWifiSmeSmeCommonConfigGetReqSend(src__) \ 3495 CsrWifiSmeSmeCommonConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 3496 3497 /******************************************************************************* 3498 3499 NAME 3500 CsrWifiSmeSmeCommonConfigGetCfmSend 3501 3502 DESCRIPTION 3503 This primitive reports the result of the request. 3504 3505 PARAMETERS 3506 queue - Destination Task Queue 3507 status - Reports the result of the request 3508 deviceConfig - Configuration options in the SME 3509 3510 *******************************************************************************/ 3511 #define CsrWifiSmeSmeCommonConfigGetCfmCreate(msg__, dst__, src__, status__, deviceConfig__) \ 3512 msg__ = kmalloc(sizeof(CsrWifiSmeSmeCommonConfigGetCfm), GFP_KERNEL); \ 3513 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_GET_CFM, dst__, src__); \ 3514 msg__->status = (status__); \ 3515 msg__->deviceConfig = (deviceConfig__); 3516 3517 #define CsrWifiSmeSmeCommonConfigGetCfmSendTo(dst__, src__, status__, deviceConfig__) \ 3518 { \ 3519 CsrWifiSmeSmeCommonConfigGetCfm *msg__; \ 3520 CsrWifiSmeSmeCommonConfigGetCfmCreate(msg__, dst__, src__, status__, deviceConfig__); \ 3521 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3522 } 3523 3524 #define CsrWifiSmeSmeCommonConfigGetCfmSend(dst__, status__, deviceConfig__) \ 3525 CsrWifiSmeSmeCommonConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, deviceConfig__) 3526 3527 /******************************************************************************* 3528 3529 NAME 3530 CsrWifiSmeSmeCommonConfigSetReqSend 3531 3532 DESCRIPTION 3533 This primitive sets the value of the Sme common. 3534 3535 PARAMETERS 3536 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3537 deviceConfig - Configuration options in the SME 3538 3539 *******************************************************************************/ 3540 #define CsrWifiSmeSmeCommonConfigSetReqCreate(msg__, dst__, src__, deviceConfig__) \ 3541 msg__ = kmalloc(sizeof(CsrWifiSmeSmeCommonConfigSetReq), GFP_KERNEL); \ 3542 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_SET_REQ, dst__, src__); \ 3543 msg__->deviceConfig = (deviceConfig__); 3544 3545 #define CsrWifiSmeSmeCommonConfigSetReqSendTo(dst__, src__, deviceConfig__) \ 3546 { \ 3547 CsrWifiSmeSmeCommonConfigSetReq *msg__; \ 3548 CsrWifiSmeSmeCommonConfigSetReqCreate(msg__, dst__, src__, deviceConfig__); \ 3549 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3550 } 3551 3552 #define CsrWifiSmeSmeCommonConfigSetReqSend(src__, deviceConfig__) \ 3553 CsrWifiSmeSmeCommonConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, deviceConfig__) 3554 3555 /******************************************************************************* 3556 3557 NAME 3558 CsrWifiSmeSmeCommonConfigSetCfmSend 3559 3560 DESCRIPTION 3561 Reports the result of the request 3562 3563 PARAMETERS 3564 queue - Destination Task Queue 3565 status - Reports the result of the request 3566 3567 *******************************************************************************/ 3568 #define CsrWifiSmeSmeCommonConfigSetCfmCreate(msg__, dst__, src__, status__) \ 3569 msg__ = kmalloc(sizeof(CsrWifiSmeSmeCommonConfigSetCfm), GFP_KERNEL); \ 3570 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_SET_CFM, dst__, src__); \ 3571 msg__->status = (status__); 3572 3573 #define CsrWifiSmeSmeCommonConfigSetCfmSendTo(dst__, src__, status__) \ 3574 { \ 3575 CsrWifiSmeSmeCommonConfigSetCfm *msg__; \ 3576 CsrWifiSmeSmeCommonConfigSetCfmCreate(msg__, dst__, src__, status__); \ 3577 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3578 } 3579 3580 #define CsrWifiSmeSmeCommonConfigSetCfmSend(dst__, status__) \ 3581 CsrWifiSmeSmeCommonConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 3582 3583 /******************************************************************************* 3584 3585 NAME 3586 CsrWifiSmeSmeStaConfigGetReqSend 3587 3588 DESCRIPTION 3589 This primitive gets the value of the SmeStaConfig parameter. 3590 3591 PARAMETERS 3592 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3593 interfaceTag - Interface Identifier; unique identifier of an interface 3594 3595 *******************************************************************************/ 3596 #define CsrWifiSmeSmeStaConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \ 3597 msg__ = kmalloc(sizeof(CsrWifiSmeSmeStaConfigGetReq), GFP_KERNEL); \ 3598 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_GET_REQ, dst__, src__); \ 3599 msg__->interfaceTag = (interfaceTag__); 3600 3601 #define CsrWifiSmeSmeStaConfigGetReqSendTo(dst__, src__, interfaceTag__) \ 3602 { \ 3603 CsrWifiSmeSmeStaConfigGetReq *msg__; \ 3604 CsrWifiSmeSmeStaConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \ 3605 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3606 } 3607 3608 #define CsrWifiSmeSmeStaConfigGetReqSend(src__, interfaceTag__) \ 3609 CsrWifiSmeSmeStaConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__) 3610 3611 /******************************************************************************* 3612 3613 NAME 3614 CsrWifiSmeSmeStaConfigGetCfmSend 3615 3616 DESCRIPTION 3617 This primitive reports the result of the request. 3618 3619 PARAMETERS 3620 queue - Destination Task Queue 3621 interfaceTag - Interface Identifier; unique identifier of an interface 3622 status - Reports the result of the request 3623 smeConfig - Current SME Station Parameters 3624 3625 *******************************************************************************/ 3626 #define CsrWifiSmeSmeStaConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, smeConfig__) \ 3627 msg__ = kmalloc(sizeof(CsrWifiSmeSmeStaConfigGetCfm), GFP_KERNEL); \ 3628 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_GET_CFM, dst__, src__); \ 3629 msg__->interfaceTag = (interfaceTag__); \ 3630 msg__->status = (status__); \ 3631 msg__->smeConfig = (smeConfig__); 3632 3633 #define CsrWifiSmeSmeStaConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, smeConfig__) \ 3634 { \ 3635 CsrWifiSmeSmeStaConfigGetCfm *msg__; \ 3636 CsrWifiSmeSmeStaConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, smeConfig__); \ 3637 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3638 } 3639 3640 #define CsrWifiSmeSmeStaConfigGetCfmSend(dst__, interfaceTag__, status__, smeConfig__) \ 3641 CsrWifiSmeSmeStaConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, smeConfig__) 3642 3643 /******************************************************************************* 3644 3645 NAME 3646 CsrWifiSmeSmeStaConfigSetReqSend 3647 3648 DESCRIPTION 3649 This primitive sets the value of the SmeConfig parameter. 3650 3651 PARAMETERS 3652 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3653 interfaceTag - Interface Identifier; unique identifier of an interface 3654 smeConfig - SME Station Parameters to be set 3655 3656 *******************************************************************************/ 3657 #define CsrWifiSmeSmeStaConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, smeConfig__) \ 3658 msg__ = kmalloc(sizeof(CsrWifiSmeSmeStaConfigSetReq), GFP_KERNEL); \ 3659 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_SET_REQ, dst__, src__); \ 3660 msg__->interfaceTag = (interfaceTag__); \ 3661 msg__->smeConfig = (smeConfig__); 3662 3663 #define CsrWifiSmeSmeStaConfigSetReqSendTo(dst__, src__, interfaceTag__, smeConfig__) \ 3664 { \ 3665 CsrWifiSmeSmeStaConfigSetReq *msg__; \ 3666 CsrWifiSmeSmeStaConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, smeConfig__); \ 3667 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3668 } 3669 3670 #define CsrWifiSmeSmeStaConfigSetReqSend(src__, interfaceTag__, smeConfig__) \ 3671 CsrWifiSmeSmeStaConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, smeConfig__) 3672 3673 /******************************************************************************* 3674 3675 NAME 3676 CsrWifiSmeSmeStaConfigSetCfmSend 3677 3678 DESCRIPTION 3679 This primitive reports the result of the request. 3680 3681 PARAMETERS 3682 queue - Destination Task Queue 3683 interfaceTag - Interface Identifier; unique identifier of an interface 3684 status - Reports the result of the request 3685 3686 *******************************************************************************/ 3687 #define CsrWifiSmeSmeStaConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \ 3688 msg__ = kmalloc(sizeof(CsrWifiSmeSmeStaConfigSetCfm), GFP_KERNEL); \ 3689 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_SET_CFM, dst__, src__); \ 3690 msg__->interfaceTag = (interfaceTag__); \ 3691 msg__->status = (status__); 3692 3693 #define CsrWifiSmeSmeStaConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \ 3694 { \ 3695 CsrWifiSmeSmeStaConfigSetCfm *msg__; \ 3696 CsrWifiSmeSmeStaConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \ 3697 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3698 } 3699 3700 #define CsrWifiSmeSmeStaConfigSetCfmSend(dst__, interfaceTag__, status__) \ 3701 CsrWifiSmeSmeStaConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__) 3702 3703 /******************************************************************************* 3704 3705 NAME 3706 CsrWifiSmeStationMacAddressGetReqSend 3707 3708 DESCRIPTION 3709 This primitives is used to retrieve the current MAC address used by the 3710 station. 3711 3712 PARAMETERS 3713 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3714 3715 *******************************************************************************/ 3716 #define CsrWifiSmeStationMacAddressGetReqCreate(msg__, dst__, src__) \ 3717 msg__ = kmalloc(sizeof(CsrWifiSmeStationMacAddressGetReq), GFP_KERNEL); \ 3718 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_STATION_MAC_ADDRESS_GET_REQ, dst__, src__); 3719 3720 #define CsrWifiSmeStationMacAddressGetReqSendTo(dst__, src__) \ 3721 { \ 3722 CsrWifiSmeStationMacAddressGetReq *msg__; \ 3723 CsrWifiSmeStationMacAddressGetReqCreate(msg__, dst__, src__); \ 3724 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3725 } 3726 3727 #define CsrWifiSmeStationMacAddressGetReqSend(src__) \ 3728 CsrWifiSmeStationMacAddressGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 3729 3730 /******************************************************************************* 3731 3732 NAME 3733 CsrWifiSmeStationMacAddressGetCfmSend 3734 3735 DESCRIPTION 3736 This primitive reports the result of the request. 3737 3738 PARAMETERS 3739 queue - Destination Task Queue 3740 status - Reports the result of the request 3741 stationMacAddress - Current MAC address of the station. 3742 3743 *******************************************************************************/ 3744 #define CsrWifiSmeStationMacAddressGetCfmCreate(msg__, dst__, src__, status__, stationMacAddress__) \ 3745 msg__ = kmalloc(sizeof(CsrWifiSmeStationMacAddressGetCfm), GFP_KERNEL); \ 3746 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_STATION_MAC_ADDRESS_GET_CFM, dst__, src__); \ 3747 msg__->status = (status__); \ 3748 memcpy(msg__->stationMacAddress, (stationMacAddress__), sizeof(CsrWifiMacAddress) * 2); 3749 3750 #define CsrWifiSmeStationMacAddressGetCfmSendTo(dst__, src__, status__, stationMacAddress__) \ 3751 { \ 3752 CsrWifiSmeStationMacAddressGetCfm *msg__; \ 3753 CsrWifiSmeStationMacAddressGetCfmCreate(msg__, dst__, src__, status__, stationMacAddress__); \ 3754 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3755 } 3756 3757 #define CsrWifiSmeStationMacAddressGetCfmSend(dst__, status__, stationMacAddress__) \ 3758 CsrWifiSmeStationMacAddressGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, stationMacAddress__) 3759 3760 /******************************************************************************* 3761 3762 NAME 3763 CsrWifiSmeTspecReqSend 3764 3765 DESCRIPTION 3766 The wireless manager application should call this primitive to use the 3767 TSPEC feature. 3768 The chip supports the use of TSPECs and TCLAS for the use of IEEE 3769 802.11/WMM Quality of Service features. 3770 The API allows the wireless manager application to supply a correctly 3771 formatted TSPEC and TCLAS pair to the driver. 3772 After performing basic validation, the driver negotiates the installation 3773 of the TSPEC with the AP as defined by the 802.11 specification. 3774 The driver retains all TSPEC and TCLAS pairs until they are specifically 3775 removed. 3776 It is not compulsory for a TSPEC to have a TCLAS (NULL is used to 3777 indicate that no TCLAS is supplied), while a TCLASS always require a 3778 TSPEC. 3779 The format of the TSPEC element is specified in 'WMM (including WMM Power 3780 Save) Specification - Version 1.1' and 'ANSI/IEEE Std 802.11-REVmb/D3.0'. 3781 For more information, see 'UniFi Configuring WMM and WMM-PS'. 3782 3783 PARAMETERS 3784 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3785 interfaceTag - Interface Identifier; unique identifier of an interface 3786 action - Specifies the action to be carried out on the list of TSPECs. 3787 CSR_WIFI_SME_LIST_ACTION_FLUSH is not applicable here. 3788 transactionId - Unique Transaction ID for the TSPEC, as assigned by the 3789 driver 3790 strict - If it set to false, allows the SME to perform automatic 3791 TSPEC negotiation 3792 ctrlMask - Additional TSPEC configuration for CCX. 3793 Set mask with values from CsrWifiSmeTspecCtrl. 3794 CURRENTLY NOT SUPPORTED 3795 tspecLength - Length of the TSPEC. 3796 tspec - Points to the first byte of the TSPEC 3797 tclasLength - Length of the TCLAS. 3798 If it is equal to 0, no TCLASS is provided for the TSPEC 3799 tclas - Points to the first byte of the TCLAS, if any. 3800 3801 *******************************************************************************/ 3802 #define CsrWifiSmeTspecReqCreate(msg__, dst__, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__) \ 3803 msg__ = kmalloc(sizeof(CsrWifiSmeTspecReq), GFP_KERNEL); \ 3804 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_TSPEC_REQ, dst__, src__); \ 3805 msg__->interfaceTag = (interfaceTag__); \ 3806 msg__->action = (action__); \ 3807 msg__->transactionId = (transactionId__); \ 3808 msg__->strict = (strict__); \ 3809 msg__->ctrlMask = (ctrlMask__); \ 3810 msg__->tspecLength = (tspecLength__); \ 3811 msg__->tspec = (tspec__); \ 3812 msg__->tclasLength = (tclasLength__); \ 3813 msg__->tclas = (tclas__); 3814 3815 #define CsrWifiSmeTspecReqSendTo(dst__, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__) \ 3816 { \ 3817 CsrWifiSmeTspecReq *msg__; \ 3818 CsrWifiSmeTspecReqCreate(msg__, dst__, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__); \ 3819 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3820 } 3821 3822 #define CsrWifiSmeTspecReqSend(src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__) \ 3823 CsrWifiSmeTspecReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__) 3824 3825 /******************************************************************************* 3826 3827 NAME 3828 CsrWifiSmeTspecIndSend 3829 3830 DESCRIPTION 3831 The SME will send this primitive to all the task that have registered to 3832 receive it when a status change in the TSPEC occurs. 3833 3834 PARAMETERS 3835 queue - Destination Task Queue 3836 interfaceTag - Interface Identifier; unique identifier of an interface 3837 transactionId - Unique Transaction ID for the TSPEC, as assigned by the 3838 driver 3839 tspecResultCode - Specifies the TSPEC operation requested by the peer 3840 station 3841 tspecLength - Length of the TSPEC. 3842 tspec - Points to the first byte of the TSPEC 3843 3844 *******************************************************************************/ 3845 #define CsrWifiSmeTspecIndCreate(msg__, dst__, src__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \ 3846 msg__ = kmalloc(sizeof(CsrWifiSmeTspecInd), GFP_KERNEL); \ 3847 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_TSPEC_IND, dst__, src__); \ 3848 msg__->interfaceTag = (interfaceTag__); \ 3849 msg__->transactionId = (transactionId__); \ 3850 msg__->tspecResultCode = (tspecResultCode__); \ 3851 msg__->tspecLength = (tspecLength__); \ 3852 msg__->tspec = (tspec__); 3853 3854 #define CsrWifiSmeTspecIndSendTo(dst__, src__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \ 3855 { \ 3856 CsrWifiSmeTspecInd *msg__; \ 3857 CsrWifiSmeTspecIndCreate(msg__, dst__, src__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__); \ 3858 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3859 } 3860 3861 #define CsrWifiSmeTspecIndSend(dst__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \ 3862 CsrWifiSmeTspecIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__) 3863 3864 /******************************************************************************* 3865 3866 NAME 3867 CsrWifiSmeTspecCfmSend 3868 3869 DESCRIPTION 3870 The SME calls the primitive to report the result of the TSpec primitive 3871 request. 3872 3873 PARAMETERS 3874 queue - Destination Task Queue 3875 interfaceTag - Interface Identifier; unique identifier of an interface 3876 status - Reports the result of the request 3877 transactionId - Unique Transaction ID for the TSPEC, as assigned by the 3878 driver 3879 tspecResultCode - Specifies the result of the negotiated TSPEC operation 3880 tspecLength - Length of the TSPEC. 3881 tspec - Points to the first byte of the TSPEC 3882 3883 *******************************************************************************/ 3884 #define CsrWifiSmeTspecCfmCreate(msg__, dst__, src__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \ 3885 msg__ = kmalloc(sizeof(CsrWifiSmeTspecCfm), GFP_KERNEL); \ 3886 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_TSPEC_CFM, dst__, src__); \ 3887 msg__->interfaceTag = (interfaceTag__); \ 3888 msg__->status = (status__); \ 3889 msg__->transactionId = (transactionId__); \ 3890 msg__->tspecResultCode = (tspecResultCode__); \ 3891 msg__->tspecLength = (tspecLength__); \ 3892 msg__->tspec = (tspec__); 3893 3894 #define CsrWifiSmeTspecCfmSendTo(dst__, src__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \ 3895 { \ 3896 CsrWifiSmeTspecCfm *msg__; \ 3897 CsrWifiSmeTspecCfmCreate(msg__, dst__, src__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__); \ 3898 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3899 } 3900 3901 #define CsrWifiSmeTspecCfmSend(dst__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \ 3902 CsrWifiSmeTspecCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__) 3903 3904 /******************************************************************************* 3905 3906 NAME 3907 CsrWifiSmeVersionsGetReqSend 3908 3909 DESCRIPTION 3910 This primitive gets the value of the Versions parameter. 3911 3912 PARAMETERS 3913 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3914 3915 *******************************************************************************/ 3916 #define CsrWifiSmeVersionsGetReqCreate(msg__, dst__, src__) \ 3917 msg__ = kmalloc(sizeof(CsrWifiSmeVersionsGetReq), GFP_KERNEL); \ 3918 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_VERSIONS_GET_REQ, dst__, src__); 3919 3920 #define CsrWifiSmeVersionsGetReqSendTo(dst__, src__) \ 3921 { \ 3922 CsrWifiSmeVersionsGetReq *msg__; \ 3923 CsrWifiSmeVersionsGetReqCreate(msg__, dst__, src__); \ 3924 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3925 } 3926 3927 #define CsrWifiSmeVersionsGetReqSend(src__) \ 3928 CsrWifiSmeVersionsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 3929 3930 /******************************************************************************* 3931 3932 NAME 3933 CsrWifiSmeVersionsGetCfmSend 3934 3935 DESCRIPTION 3936 This primitive reports the result of the request. 3937 3938 PARAMETERS 3939 queue - Destination Task Queue 3940 status - Reports the result of the request 3941 versions - Version IDs of the product 3942 3943 *******************************************************************************/ 3944 #define CsrWifiSmeVersionsGetCfmCreate(msg__, dst__, src__, status__, versions__) \ 3945 msg__ = kmalloc(sizeof(CsrWifiSmeVersionsGetCfm), GFP_KERNEL); \ 3946 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_VERSIONS_GET_CFM, dst__, src__); \ 3947 msg__->status = (status__); \ 3948 msg__->versions = (versions__); 3949 3950 #define CsrWifiSmeVersionsGetCfmSendTo(dst__, src__, status__, versions__) \ 3951 { \ 3952 CsrWifiSmeVersionsGetCfm *msg__; \ 3953 CsrWifiSmeVersionsGetCfmCreate(msg__, dst__, src__, status__, versions__); \ 3954 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 3955 } 3956 3957 #define CsrWifiSmeVersionsGetCfmSend(dst__, status__, versions__) \ 3958 CsrWifiSmeVersionsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, versions__) 3959 3960 /******************************************************************************* 3961 3962 NAME 3963 CsrWifiSmeWifiFlightmodeReqSend 3964 3965 DESCRIPTION 3966 The wireless manager application may call this primitive on boot-up of 3967 the platform to ensure that the chip is placed in a mode that prevents 3968 any emission of RF energy. 3969 This primitive is an alternative to CSR_WIFI_SME_WIFI_ON_REQ. 3970 As in CSR_WIFI_SME_WIFI_ON_REQ, it causes the download of the patch file 3971 (if any) and the programming of the initial MIB settings (if supplied by 3972 the WMA), but it also ensures that the chip is left in its lowest 3973 possible power-mode with the radio subsystems disabled. 3974 This feature is useful on platforms where power cannot be removed from 3975 the chip (leaving the chip not initialised will cause it to consume more 3976 power so calling this function ensures that the chip is initialised into 3977 a low power mode but without entering a state where it could emit any RF 3978 energy). 3979 NOTE: this primitive does not cause the Wi-Fi to change state: Wi-Fi 3980 stays conceptually off. Configuration primitives can be sent after 3981 CSR_WIFI_SME_WIFI_FLIGHTMODE_REQ and the configuration will be maintained. 3982 Requests that require the state of the Wi-Fi to be ON will return 3983 CSR_WIFI_SME_STATUS_WIFI_OFF in their confirms. 3984 3985 PARAMETERS 3986 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 3987 address - Optionally specifies a station MAC address. 3988 In normal use, the manager should set the address to 0xFF 3989 0xFF 0xFF 0xFF 0xFF 0xFF, which will cause the chip to use 3990 the MAC address in the MIB. 3991 mibFilesCount - Number of provided data blocks with initial MIB values 3992 mibFiles - Points to the first data block with initial MIB values. 3993 These data blocks are typically the contents of the provided 3994 files ufmib.dat and localmib.dat, available from the host 3995 file system, if they exist. 3996 These files typically contain radio tuning and calibration 3997 values. 3998 More values can be created using the Host Tools. 3999 4000 *******************************************************************************/ 4001 #define CsrWifiSmeWifiFlightmodeReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__) \ 4002 msg__ = kmalloc(sizeof(CsrWifiSmeWifiFlightmodeReq), GFP_KERNEL); \ 4003 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_FLIGHTMODE_REQ, dst__, src__); \ 4004 msg__->address = (address__); \ 4005 msg__->mibFilesCount = (mibFilesCount__); \ 4006 msg__->mibFiles = (mibFiles__); 4007 4008 #define CsrWifiSmeWifiFlightmodeReqSendTo(dst__, src__, address__, mibFilesCount__, mibFiles__) \ 4009 { \ 4010 CsrWifiSmeWifiFlightmodeReq *msg__; \ 4011 CsrWifiSmeWifiFlightmodeReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__); \ 4012 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 4013 } 4014 4015 #define CsrWifiSmeWifiFlightmodeReqSend(src__, address__, mibFilesCount__, mibFiles__) \ 4016 CsrWifiSmeWifiFlightmodeReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, address__, mibFilesCount__, mibFiles__) 4017 4018 /******************************************************************************* 4019 4020 NAME 4021 CsrWifiSmeWifiFlightmodeCfmSend 4022 4023 DESCRIPTION 4024 The SME calls this primitive when the chip is initialised for low power 4025 mode and with the radio subsystem disabled. To leave flight mode, and 4026 enable Wi-Fi, the wireless manager application should call 4027 CSR_WIFI_SME_WIFI_ON_REQ. 4028 4029 PARAMETERS 4030 queue - Destination Task Queue 4031 status - Reports the result of the request 4032 4033 *******************************************************************************/ 4034 #define CsrWifiSmeWifiFlightmodeCfmCreate(msg__, dst__, src__, status__) \ 4035 msg__ = kmalloc(sizeof(CsrWifiSmeWifiFlightmodeCfm), GFP_KERNEL); \ 4036 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_FLIGHTMODE_CFM, dst__, src__); \ 4037 msg__->status = (status__); 4038 4039 #define CsrWifiSmeWifiFlightmodeCfmSendTo(dst__, src__, status__) \ 4040 { \ 4041 CsrWifiSmeWifiFlightmodeCfm *msg__; \ 4042 CsrWifiSmeWifiFlightmodeCfmCreate(msg__, dst__, src__, status__); \ 4043 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 4044 } 4045 4046 #define CsrWifiSmeWifiFlightmodeCfmSend(dst__, status__) \ 4047 CsrWifiSmeWifiFlightmodeCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 4048 4049 /******************************************************************************* 4050 4051 NAME 4052 CsrWifiSmeWifiOffReqSend 4053 4054 DESCRIPTION 4055 The wireless manager application calls this primitive to turn off the 4056 chip, thus saving power when Wi-Fi is not in use. 4057 4058 PARAMETERS 4059 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 4060 4061 *******************************************************************************/ 4062 #define CsrWifiSmeWifiOffReqCreate(msg__, dst__, src__) \ 4063 msg__ = kmalloc(sizeof(CsrWifiSmeWifiOffReq), GFP_KERNEL); \ 4064 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_OFF_REQ, dst__, src__); 4065 4066 #define CsrWifiSmeWifiOffReqSendTo(dst__, src__) \ 4067 { \ 4068 CsrWifiSmeWifiOffReq *msg__; \ 4069 CsrWifiSmeWifiOffReqCreate(msg__, dst__, src__); \ 4070 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 4071 } 4072 4073 #define CsrWifiSmeWifiOffReqSend(src__) \ 4074 CsrWifiSmeWifiOffReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__) 4075 4076 /******************************************************************************* 4077 4078 NAME 4079 CsrWifiSmeWifiOffIndSend 4080 4081 DESCRIPTION 4082 The SME sends this primitive to all the tasks that have registered to 4083 receive it to report that the chip has been turned off. 4084 4085 PARAMETERS 4086 queue - Destination Task Queue 4087 reason - Indicates the reason why the Wi-Fi has been switched off. 4088 4089 *******************************************************************************/ 4090 #define CsrWifiSmeWifiOffIndCreate(msg__, dst__, src__, reason__) \ 4091 msg__ = kmalloc(sizeof(CsrWifiSmeWifiOffInd), GFP_KERNEL); \ 4092 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_OFF_IND, dst__, src__); \ 4093 msg__->reason = (reason__); 4094 4095 #define CsrWifiSmeWifiOffIndSendTo(dst__, src__, reason__) \ 4096 { \ 4097 CsrWifiSmeWifiOffInd *msg__; \ 4098 CsrWifiSmeWifiOffIndCreate(msg__, dst__, src__, reason__); \ 4099 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 4100 } 4101 4102 #define CsrWifiSmeWifiOffIndSend(dst__, reason__) \ 4103 CsrWifiSmeWifiOffIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, reason__) 4104 4105 /******************************************************************************* 4106 4107 NAME 4108 CsrWifiSmeWifiOffCfmSend 4109 4110 DESCRIPTION 4111 After receiving CSR_WIFI_SME_WIFI_OFF_REQ, if the chip is connected to a 4112 network, the SME will perform a disconnect operation, will send a 4113 CSR_WIFI_SME_MEDIA_STATUS_IND with 4114 CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED, and then will call 4115 CSR_WIFI_SME_WIFI_OFF_CFM when the chip is off. 4116 4117 PARAMETERS 4118 queue - Destination Task Queue 4119 status - Reports the result of the request 4120 4121 *******************************************************************************/ 4122 #define CsrWifiSmeWifiOffCfmCreate(msg__, dst__, src__, status__) \ 4123 msg__ = kmalloc(sizeof(CsrWifiSmeWifiOffCfm), GFP_KERNEL); \ 4124 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_OFF_CFM, dst__, src__); \ 4125 msg__->status = (status__); 4126 4127 #define CsrWifiSmeWifiOffCfmSendTo(dst__, src__, status__) \ 4128 { \ 4129 CsrWifiSmeWifiOffCfm *msg__; \ 4130 CsrWifiSmeWifiOffCfmCreate(msg__, dst__, src__, status__); \ 4131 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 4132 } 4133 4134 #define CsrWifiSmeWifiOffCfmSend(dst__, status__) \ 4135 CsrWifiSmeWifiOffCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 4136 4137 /******************************************************************************* 4138 4139 NAME 4140 CsrWifiSmeWifiOnReqSend 4141 4142 DESCRIPTION 4143 The wireless manager application calls this primitive to turn on the 4144 Wi-Fi chip. 4145 If the Wi-Fi chip is currently off, the SME turns the Wi-Fi chip on, 4146 downloads the patch file (if any), and programs the initial MIB settings 4147 (if supplied by the WMA). 4148 The patch file is not provided with the SME API; its downloading is 4149 automatic and handled internally by the system. 4150 The MIB settings, when provided, override the default values that the 4151 firmware loads from EEPROM. 4152 If the Wi-Fi chip is already on, the SME takes no action and returns a 4153 successful status in the confirm. 4154 4155 PARAMETERS 4156 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 4157 address - Optionally specifies a station MAC address. 4158 In normal use, the manager should set the address to 0xFF 4159 0xFF 0xFF 0xFF 0xFF 0xFF, which will cause the chip to use 4160 the MAC address in the MIB 4161 mibFilesCount - Number of provided data blocks with initial MIB values 4162 mibFiles - Points to the first data block with initial MIB values. 4163 These data blocks are typically the contents of the provided 4164 files ufmib.dat and localmib.dat, available from the host 4165 file system, if they exist. 4166 These files typically contain radio tuning and calibration 4167 values. 4168 More values can be created using the Host Tools. 4169 4170 *******************************************************************************/ 4171 #define CsrWifiSmeWifiOnReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__) \ 4172 msg__ = kmalloc(sizeof(CsrWifiSmeWifiOnReq), GFP_KERNEL); \ 4173 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_ON_REQ, dst__, src__); \ 4174 msg__->address = (address__); \ 4175 msg__->mibFilesCount = (mibFilesCount__); \ 4176 msg__->mibFiles = (mibFiles__); 4177 4178 #define CsrWifiSmeWifiOnReqSendTo(dst__, src__, address__, mibFilesCount__, mibFiles__) \ 4179 { \ 4180 CsrWifiSmeWifiOnReq *msg__; \ 4181 CsrWifiSmeWifiOnReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__); \ 4182 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 4183 } 4184 4185 #define CsrWifiSmeWifiOnReqSend(src__, address__, mibFilesCount__, mibFiles__) \ 4186 CsrWifiSmeWifiOnReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, address__, mibFilesCount__, mibFiles__) 4187 4188 /******************************************************************************* 4189 4190 NAME 4191 CsrWifiSmeWifiOnIndSend 4192 4193 DESCRIPTION 4194 The SME sends this primitive to all tasks that have registered to receive 4195 it once the chip becomes available and ready to use. 4196 4197 PARAMETERS 4198 queue - Destination Task Queue 4199 address - Current MAC address 4200 4201 *******************************************************************************/ 4202 #define CsrWifiSmeWifiOnIndCreate(msg__, dst__, src__, address__) \ 4203 msg__ = kmalloc(sizeof(CsrWifiSmeWifiOnInd), GFP_KERNEL); \ 4204 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_ON_IND, dst__, src__); \ 4205 msg__->address = (address__); 4206 4207 #define CsrWifiSmeWifiOnIndSendTo(dst__, src__, address__) \ 4208 { \ 4209 CsrWifiSmeWifiOnInd *msg__; \ 4210 CsrWifiSmeWifiOnIndCreate(msg__, dst__, src__, address__); \ 4211 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 4212 } 4213 4214 #define CsrWifiSmeWifiOnIndSend(dst__, address__) \ 4215 CsrWifiSmeWifiOnIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, address__) 4216 4217 /******************************************************************************* 4218 4219 NAME 4220 CsrWifiSmeWifiOnCfmSend 4221 4222 DESCRIPTION 4223 The SME sends this primitive to the task that has sent the request once 4224 the chip has been initialised and is available for use. 4225 4226 PARAMETERS 4227 queue - Destination Task Queue 4228 status - Reports the result of the request 4229 4230 *******************************************************************************/ 4231 #define CsrWifiSmeWifiOnCfmCreate(msg__, dst__, src__, status__) \ 4232 msg__ = kmalloc(sizeof(CsrWifiSmeWifiOnCfm), GFP_KERNEL); \ 4233 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_ON_CFM, dst__, src__); \ 4234 msg__->status = (status__); 4235 4236 #define CsrWifiSmeWifiOnCfmSendTo(dst__, src__, status__) \ 4237 { \ 4238 CsrWifiSmeWifiOnCfm *msg__; \ 4239 CsrWifiSmeWifiOnCfmCreate(msg__, dst__, src__, status__); \ 4240 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 4241 } 4242 4243 #define CsrWifiSmeWifiOnCfmSend(dst__, status__) \ 4244 CsrWifiSmeWifiOnCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 4245 4246 /******************************************************************************* 4247 4248 NAME 4249 CsrWifiSmeWpsConfigurationReqSend 4250 4251 DESCRIPTION 4252 This primitive passes the WPS information for the device to SME. This may 4253 be accepted only if no interface is active. 4254 4255 PARAMETERS 4256 queue - Message Source Task Queue (Cfm's will be sent to this Queue) 4257 wpsConfig - WPS config. 4258 4259 *******************************************************************************/ 4260 #define CsrWifiSmeWpsConfigurationReqCreate(msg__, dst__, src__, wpsConfig__) \ 4261 msg__ = kmalloc(sizeof(CsrWifiSmeWpsConfigurationReq), GFP_KERNEL); \ 4262 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WPS_CONFIGURATION_REQ, dst__, src__); \ 4263 msg__->wpsConfig = (wpsConfig__); 4264 4265 #define CsrWifiSmeWpsConfigurationReqSendTo(dst__, src__, wpsConfig__) \ 4266 { \ 4267 CsrWifiSmeWpsConfigurationReq *msg__; \ 4268 CsrWifiSmeWpsConfigurationReqCreate(msg__, dst__, src__, wpsConfig__); \ 4269 CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \ 4270 } 4271 4272 #define CsrWifiSmeWpsConfigurationReqSend(src__, wpsConfig__) \ 4273 CsrWifiSmeWpsConfigurationReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, wpsConfig__) 4274 4275 /******************************************************************************* 4276 4277 NAME 4278 CsrWifiSmeWpsConfigurationCfmSend 4279 4280 DESCRIPTION 4281 Confirm. 4282 4283 PARAMETERS 4284 queue - Destination Task Queue 4285 status - Status of the request. 4286 4287 *******************************************************************************/ 4288 #define CsrWifiSmeWpsConfigurationCfmCreate(msg__, dst__, src__, status__) \ 4289 msg__ = kmalloc(sizeof(CsrWifiSmeWpsConfigurationCfm), GFP_KERNEL); \ 4290 CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WPS_CONFIGURATION_CFM, dst__, src__); \ 4291 msg__->status = (status__); 4292 4293 #define CsrWifiSmeWpsConfigurationCfmSendTo(dst__, src__, status__) \ 4294 { \ 4295 CsrWifiSmeWpsConfigurationCfm *msg__; \ 4296 CsrWifiSmeWpsConfigurationCfmCreate(msg__, dst__, src__, status__); \ 4297 CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \ 4298 } 4299 4300 #define CsrWifiSmeWpsConfigurationCfmSend(dst__, status__) \ 4301 CsrWifiSmeWpsConfigurationCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__) 4302 4303 #endif /* CSR_WIFI_SME_LIB_H__ */ 4304