Root/drivers/staging/csr/csr_wifi_sme_lib.h

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

Archive Download this file



interactive