Merge tag 'staging-3.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh...
[linux-3.10.git] / drivers / staging / csr / unifi_sme.c
1 /*
2  * ***************************************************************************
3  *  FILE:     unifi_sme.c
4  *
5  *  PURPOSE:    SME related functions.
6  *
7  *  Copyright (C) 2007-2009 by Cambridge Silicon Radio Ltd.
8  *
9  * Refer to LICENSE.txt included with this source code for details on
10  * the license terms.
11  *
12  * ***************************************************************************
13  */
14
15 #include "unifi_priv.h"
16 #include "csr_wifi_hip_unifi.h"
17 #include "csr_wifi_hip_conversions.h"
18 #include <linux/sched/rt.h>
19
20
21
22     int
23 convert_sme_error(CsrResult error)
24 {
25     switch (error) {
26         case CSR_RESULT_SUCCESS:
27             return 0;
28         case CSR_RESULT_FAILURE:
29         case CSR_WIFI_RESULT_NOT_FOUND:
30         case CSR_WIFI_RESULT_TIMED_OUT:
31         case CSR_WIFI_RESULT_CANCELLED:
32         case CSR_WIFI_RESULT_UNAVAILABLE:
33             return -EIO;
34         case CSR_WIFI_RESULT_NO_ROOM:
35             return -EBUSY;
36         case CSR_WIFI_RESULT_INVALID_PARAMETER:
37             return -EINVAL;
38         case CSR_WIFI_RESULT_UNSUPPORTED:
39             return -EOPNOTSUPP;
40         default:
41             return -EIO;
42     }
43 }
44
45
46 /*
47  * ---------------------------------------------------------------------------
48  *  sme_log_event
49  *
50  *      Callback function to be registered as the SME event callback.
51  *      Copies the signal content into a new udi_log_t struct and adds
52  *      it to the read queue for the SME client.
53  *
54  *  Arguments:
55  *      arg             This is the value given to unifi_add_udi_hook, in
56  *                      this case a pointer to the client instance.
57  *      signal          Pointer to the received signal.
58  *      signal_len      Size of the signal structure in bytes.
59  *      bulkdata        Pointers to any associated bulk data.
60  *      dir             Direction of the signal. Zero means from host,
61  *                      non-zero means to host.
62  *
63  *  Returns:
64  *      None.
65  * ---------------------------------------------------------------------------
66  */
67     void
68 sme_log_event(ul_client_t *pcli,
69         const u8 *signal, int signal_len,
70         const bulk_data_param_t *bulkdata,
71         int dir)
72 {
73     unifi_priv_t *priv;
74     CSR_SIGNAL unpacked_signal;
75     CsrWifiSmeDataBlock mlmeCommand;
76     CsrWifiSmeDataBlock dataref1;
77     CsrWifiSmeDataBlock dataref2;
78     CsrResult result = CSR_RESULT_SUCCESS;
79     int r;
80
81     /* Just a sanity check */
82     if ((signal == NULL) || (signal_len <= 0)) {
83         return;
84     }
85
86     priv = uf_find_instance(pcli->instance);
87     if (!priv) {
88         unifi_error(priv, "sme_log_event: invalid priv\n");
89         return;
90     }
91
92     if (priv->smepriv == NULL) {
93         unifi_error(priv, "sme_log_event: invalid smepriv\n");
94         return;
95     }
96
97     unifi_trace(priv, UDBG3,
98             "sme_log_event: Process signal 0x%.4X\n",
99             CSR_GET_UINT16_FROM_LITTLE_ENDIAN(signal));
100
101
102     /* If the signal is known, then do any filtering required, otherwise it pass it to the SME. */
103     r = read_unpack_signal(signal, &unpacked_signal);
104     if (r == CSR_RESULT_SUCCESS) {
105         if ((unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_DEBUG_STRING_INDICATION_ID) ||
106             (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_DEBUG_WORD16_INDICATION_ID))
107         {
108             return;
109         }
110         if (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_INDICATION_ID)
111         {
112             u16 frmCtrl;
113             u8 unicastPdu = TRUE;
114             u8 *macHdrLocation;
115             u8 *raddr = NULL, *taddr = NULL;
116             CsrWifiMacAddress peerMacAddress;
117             /* Check if we need to send CsrWifiRouterCtrlMicFailureInd*/
118             CSR_MA_PACKET_INDICATION *ind = &unpacked_signal.u.MaPacketIndication;
119
120             macHdrLocation = (u8 *) bulkdata->d[0].os_data_ptr;
121             /* Fetch the frame control value from  mac header */
122             frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation);
123
124             /* Point to the addresses */
125             raddr = macHdrLocation + MAC_HEADER_ADDR1_OFFSET;
126             taddr = macHdrLocation + MAC_HEADER_ADDR2_OFFSET;
127
128             memcpy(peerMacAddress.a, taddr, ETH_ALEN);
129
130             if(ind->ReceptionStatus == CSR_MICHAEL_MIC_ERROR)
131             {
132                 if (*raddr & 0x1)
133                     unicastPdu = FALSE;
134
135                 CsrWifiRouterCtrlMicFailureIndSend (priv->CSR_WIFI_SME_IFACEQUEUE, 0,
136                         (ind->VirtualInterfaceIdentifier & 0xff),peerMacAddress,
137                         unicastPdu);
138                 return;
139             }
140             else
141             {
142                 if(ind->ReceptionStatus == CSR_RX_SUCCESS)
143                 {
144                     u8 pmBit = (frmCtrl & 0x1000)?0x01:0x00;
145                     u16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0xff);
146                     CsrWifiRouterCtrlStaInfo_t *srcStaInfo =  CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,taddr,interfaceTag);
147                     if((srcStaInfo != NULL) && (uf_check_broadcast_bssid(priv, bulkdata)== FALSE))
148                     {
149                         uf_process_pm_bit_for_peer(priv,srcStaInfo,pmBit,interfaceTag);
150
151                         /* Update station last activity flag */
152                         srcStaInfo->activity_flag = TRUE;
153                     }
154                 }
155             }
156         }
157
158         if (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_CONFIRM_ID)
159         {
160             CSR_MA_PACKET_CONFIRM *cfm = &unpacked_signal.u.MaPacketConfirm;
161             u16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
162             netInterface_priv_t *interfacePriv;
163             CSR_MA_PACKET_REQUEST *req;
164             CsrWifiMacAddress peerMacAddress;
165
166             if (interfaceTag >= CSR_WIFI_NUM_INTERFACES)
167             {
168                 unifi_error(priv, "Bad MA_PACKET_CONFIRM interfaceTag %d\n", interfaceTag);
169                 return;
170             }
171
172             unifi_trace(priv,UDBG1,"MA-PACKET Confirm (%x, %x)\n", cfm->HostTag, cfm->TransmissionStatus);
173
174             interfacePriv = priv->interfacePriv[interfaceTag];
175 #ifdef CSR_SUPPORT_SME
176             if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
177                  interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
178
179                 if(cfm->HostTag == interfacePriv->multicastPduHostTag){
180                     uf_process_ma_pkt_cfm_for_ap(priv ,interfaceTag, cfm);
181                 }
182             }
183 #endif
184
185             req = &interfacePriv->m4_signal.u.MaPacketRequest;
186
187             if(cfm->HostTag & 0x80000000)
188             {
189                 if (cfm->TransmissionStatus != CSR_TX_SUCCESSFUL)
190                 {
191                     result = CSR_RESULT_FAILURE;
192                 }
193 #ifdef CSR_SUPPORT_SME
194                 memcpy(peerMacAddress.a, req->Ra.x, ETH_ALEN);
195                 /* Check if this is a confirm for EAPOL M4 frame and we need to send transmistted ind*/
196                 if (interfacePriv->m4_sent && (cfm->HostTag == interfacePriv->m4_hostTag))
197                 {
198                     unifi_trace(priv, UDBG1, "%s: Sending M4 Transmit CFM\n", __FUNCTION__);
199                     CsrWifiRouterCtrlM4TransmittedIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0,
200                             interfaceTag,
201                             peerMacAddress,
202                             result);
203                     interfacePriv->m4_sent = FALSE;
204                     interfacePriv->m4_hostTag = 0xffffffff;
205                 }
206 #endif
207                 /* If EAPOL was requested via router APIs then send cfm else ignore*/
208                 if((cfm->HostTag & 0x80000000) != CSR_WIFI_EAPOL_M4_HOST_TAG) {
209                     CsrWifiRouterMaPacketCfmSend((u16)signal[2],
210                         cfm->VirtualInterfaceIdentifier,
211                         result,
212                         (cfm->HostTag & 0x3fffffff), cfm->Rate);
213                 } else {
214                     unifi_trace(priv, UDBG1, "%s: M4 received from netdevice\n", __FUNCTION__);
215                 }
216                 return;
217             }
218         }
219     }
220
221     mlmeCommand.length = signal_len;
222     mlmeCommand.data = (u8*)signal;
223
224     dataref1.length = bulkdata->d[0].data_length;
225     if (dataref1.length > 0) {
226         dataref1.data = (u8 *) bulkdata->d[0].os_data_ptr;
227     } else
228     {
229         dataref1.data = NULL;
230     }
231
232     dataref2.length = bulkdata->d[1].data_length;
233     if (dataref2.length > 0) {
234         dataref2.data = (u8 *) bulkdata->d[1].os_data_ptr;
235     } else
236     {
237         dataref2.data = NULL;
238     }
239
240     CsrWifiRouterCtrlHipIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, mlmeCommand.length, mlmeCommand.data,
241             dataref1.length, dataref1.data,
242             dataref2.length, dataref2.data);
243
244 } /* sme_log_event() */
245
246
247 /*
248  * ---------------------------------------------------------------------------
249  * uf_sme_port_state
250  *
251  *      Return the state of the controlled port.
252  *
253  * Arguments:
254  *      priv            Pointer to device private context struct
255  *      address    Pointer to the destination for tx or sender for rx address
256  *      queue           Controlled or uncontrolled queue
257  *
258  * Returns:
259  *      An unifi_ControlledPortAction value.
260  * ---------------------------------------------------------------------------
261  */
262 CsrWifiRouterCtrlPortAction
263 uf_sme_port_state(unifi_priv_t *priv, unsigned char *address, int queue, u16 interfaceTag)
264 {
265     int i;
266     unifi_port_config_t *port;
267     netInterface_priv_t *interfacePriv;
268
269     if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
270         unifi_error(priv, "uf_sme_port_state: bad interfaceTag\n");
271         return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
272     }
273
274     interfacePriv = priv->interfacePriv[interfaceTag];
275
276     if (queue == UF_CONTROLLED_PORT_Q) {
277         port = &interfacePriv->controlled_data_port;
278     } else {
279         port = &interfacePriv->uncontrolled_data_port;
280     }
281
282     if (!port->entries_in_use) {
283         unifi_trace(priv, UDBG5, "No port configurations, return Discard.\n");
284         return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
285     }
286
287     /* If the port configuration is common for all destinations, return it. */
288     if (port->overide_action == UF_DATA_PORT_OVERIDE) {
289         unifi_trace(priv, UDBG5, "Single port configuration (%d).\n",
290                 port->port_cfg[0].port_action);
291         return port->port_cfg[0].port_action;
292     }
293
294     unifi_trace(priv, UDBG5, "Multiple (%d) port configurations.\n", port->entries_in_use);
295
296     /* If multiple configurations exist.. */
297     for (i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
298         /* .. go through the list and match the destination address. */
299         if (port->port_cfg[i].in_use &&
300             memcmp(address, port->port_cfg[i].mac_address.a, ETH_ALEN) == 0) {
301             /* Return the desired action. */
302             return port->port_cfg[i].port_action;
303         }
304     }
305
306     /* Could not find any information, return Open. */
307     unifi_trace(priv, UDBG5, "port configuration not found, return Open.\n");
308     return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN;
309 } /* uf_sme_port_state() */
310
311 /*
312  * ---------------------------------------------------------------------------
313  * uf_sme_port_config_handle
314  *
315  *      Return the port config handle of the controlled/uncontrolled port.
316  *
317  * Arguments:
318  *      priv            Pointer to device private context struct
319  *      address    Pointer to the destination for tx or sender for rx address
320  *      queue           Controlled or uncontrolled queue
321  *
322  * Returns:
323  *      An  unifi_port_cfg_t* .
324  * ---------------------------------------------------------------------------
325  */
326 unifi_port_cfg_t*
327 uf_sme_port_config_handle(unifi_priv_t *priv, unsigned char *address, int queue, u16 interfaceTag)
328 {
329     int i;
330     unifi_port_config_t *port;
331     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
332
333     if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
334         unifi_error(priv, "uf_sme_port_config_handle: bad interfaceTag\n");
335         return NULL;
336     }
337
338     if (queue == UF_CONTROLLED_PORT_Q) {
339         port = &interfacePriv->controlled_data_port;
340     } else {
341         port = &interfacePriv->uncontrolled_data_port;
342     }
343
344     if (!port->entries_in_use) {
345         unifi_trace(priv, UDBG5, "No port configurations, return Discard.\n");
346         return NULL;
347     }
348
349     /* If the port configuration is common for all destinations, return it. */
350     if (port->overide_action == UF_DATA_PORT_OVERIDE) {
351         unifi_trace(priv, UDBG5, "Single port configuration (%d).\n",
352                 port->port_cfg[0].port_action);
353         if (address) {
354             unifi_trace(priv, UDBG5, "addr[0] = %x, addr[1] = %x, addr[2] = %x, addr[3] = %x\n", address[0], address[1], address[2], address[3]);
355         }
356         return &port->port_cfg[0];
357     }
358
359     unifi_trace(priv, UDBG5, "Multiple port configurations.\n");
360
361     /* If multiple configurations exist.. */
362     for (i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
363         /* .. go through the list and match the destination address. */
364         if (port->port_cfg[i].in_use &&
365             memcmp(address, port->port_cfg[i].mac_address.a, ETH_ALEN) == 0) {
366             /* Return the desired action. */
367             return &port->port_cfg[i];
368         }
369     }
370
371     /* Could not find any information, return Open. */
372     unifi_trace(priv, UDBG5, "port configuration not found, returning NULL (debug).\n");
373     return NULL;
374 } /* uf_sme_port_config_handle */
375
376 void
377 uf_multicast_list_wq(struct work_struct *work)
378 {
379     unifi_priv_t *priv = container_of(work, unifi_priv_t,
380             multicast_list_task);
381     int i;
382     u16 interfaceTag = 0;
383     CsrWifiMacAddress* multicast_address_list = NULL;
384     int mc_count;
385     u8 *mc_list;
386     netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
387
388     if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
389         unifi_error(priv, "uf_multicast_list_wq: bad interfaceTag\n");
390         return;
391     }
392
393     unifi_trace(priv, UDBG5,
394             "uf_multicast_list_wq: list count = %d\n",
395             interfacePriv->mc_list_count);
396
397     /* Flush the current list */
398     CsrWifiRouterCtrlMulticastAddressIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, interfaceTag, CSR_WIFI_SME_LIST_ACTION_FLUSH, 0, NULL);
399
400     mc_count = interfacePriv->mc_list_count;
401     mc_list = interfacePriv->mc_list;
402     /*
403      * Allocate a new list, need to free it later
404      * in unifi_mgt_multicast_address_cfm().
405      */
406     multicast_address_list = kmalloc(mc_count * sizeof(CsrWifiMacAddress), GFP_KERNEL);
407
408     if (multicast_address_list == NULL) {
409         return;
410     }
411
412     for (i = 0; i < mc_count; i++) {
413         memcpy(multicast_address_list[i].a, mc_list, ETH_ALEN);
414         mc_list += ETH_ALEN;
415     }
416
417     if (priv->smepriv == NULL) {
418         kfree(multicast_address_list);
419         return;
420     }
421
422     CsrWifiRouterCtrlMulticastAddressIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,
423             interfaceTag,
424             CSR_WIFI_SME_LIST_ACTION_ADD,
425             mc_count, multicast_address_list);
426
427     /* The SME will take a copy of the addreses*/
428     kfree(multicast_address_list);
429 }
430
431
432 int unifi_cfg_power(unifi_priv_t *priv, unsigned char *arg)
433 {
434     unifi_cfg_power_t cfg_power;
435     int rc;
436     int wol;
437
438     if (get_user(cfg_power, (unifi_cfg_power_t*)(((unifi_cfg_command_t*)arg) + 1))) {
439         unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
440         return -EFAULT;
441     }
442
443     switch (cfg_power) {
444         case UNIFI_CFG_POWER_OFF:
445             priv->wol_suspend = (enable_wol == UNIFI_WOL_OFF) ? FALSE : TRUE;
446             rc = sme_sys_suspend(priv);
447             if (rc) {
448                 return rc;
449             }
450             break;
451         case UNIFI_CFG_POWER_ON:
452             wol = priv->wol_suspend;
453             rc = sme_sys_resume(priv);
454             if (rc) {
455                 return rc;
456             }
457             if (wol) {
458                 /* Kick the BH to ensure pending transfers are handled when
459                  * a suspend happened with card powered.
460                  */
461                 unifi_send_signal(priv->card, NULL, 0, NULL);
462             }
463             break;
464         default:
465             unifi_error(priv, "WIFI POWER: Unknown value.\n");
466             return -EINVAL;
467     }
468
469     return 0;
470 }
471
472
473 int unifi_cfg_power_save(unifi_priv_t *priv, unsigned char *arg)
474 {
475     unifi_cfg_powersave_t cfg_power_save;
476     CsrWifiSmePowerConfig powerConfig;
477     int rc;
478
479     if (get_user(cfg_power_save, (unifi_cfg_powersave_t*)(((unifi_cfg_command_t*)arg) + 1))) {
480         unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
481         return -EFAULT;
482     }
483
484     /* Get the coex info from the SME */
485     rc = sme_mgt_power_config_get(priv, &powerConfig);
486     if (rc) {
487         unifi_error(priv, "UNIFI_CFG: Get unifi_PowerConfigValue failed.\n");
488         return rc;
489     }
490
491     switch (cfg_power_save) {
492         case UNIFI_CFG_POWERSAVE_NONE:
493             powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW;
494             break;
495         case UNIFI_CFG_POWERSAVE_FAST:
496             powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_MED;
497             break;
498         case UNIFI_CFG_POWERSAVE_FULL:
499             powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH;
500             break;
501         case UNIFI_CFG_POWERSAVE_AUTO:
502             powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_AUTO;
503             break;
504         default:
505             unifi_error(priv, "POWERSAVE: Unknown value.\n");
506             return -EINVAL;
507     }
508
509     rc = sme_mgt_power_config_set(priv, &powerConfig);
510
511     if (rc) {
512         unifi_error(priv, "UNIFI_CFG: Set unifi_PowerConfigValue failed.\n");
513     }
514
515     return rc;
516 }
517
518
519 int unifi_cfg_power_supply(unifi_priv_t *priv, unsigned char *arg)
520 {
521     unifi_cfg_powersupply_t cfg_power_supply;
522     CsrWifiSmeHostConfig hostConfig;
523     int rc;
524
525     if (get_user(cfg_power_supply, (unifi_cfg_powersupply_t*)(((unifi_cfg_command_t*)arg) + 1))) {
526         unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
527         return -EFAULT;
528     }
529
530     /* Get the coex info from the SME */
531     rc = sme_mgt_host_config_get(priv, &hostConfig);
532     if (rc) {
533         unifi_error(priv, "UNIFI_CFG: Get unifi_HostConfigValue failed.\n");
534         return rc;
535     }
536
537     switch (cfg_power_supply) {
538         case UNIFI_CFG_POWERSUPPLY_MAINS:
539             hostConfig.powerMode = CSR_WIFI_SME_HOST_POWER_MODE_ACTIVE;
540             break;
541         case UNIFI_CFG_POWERSUPPLY_BATTERIES:
542             hostConfig.powerMode = CSR_WIFI_SME_HOST_POWER_MODE_POWER_SAVE;
543             break;
544         default:
545             unifi_error(priv, "POWERSUPPLY: Unknown value.\n");
546             return -EINVAL;
547     }
548
549     rc = sme_mgt_host_config_set(priv, &hostConfig);
550     if (rc) {
551         unifi_error(priv, "UNIFI_CFG: Set unifi_HostConfigValue failed.\n");
552     }
553
554     return rc;
555 }
556
557
558 int unifi_cfg_packet_filters(unifi_priv_t *priv, unsigned char *arg)
559 {
560     unsigned char *tclas_buffer;
561     unsigned int tclas_buffer_length;
562     tclas_t *dhcp_tclas;
563     int rc;
564
565     /* Free any TCLASs previously allocated */
566     if (priv->packet_filters.tclas_ies_length) {
567         kfree(priv->filter_tclas_ies);
568         priv->filter_tclas_ies = NULL;
569     }
570
571     tclas_buffer = ((unsigned char*)arg) + sizeof(unifi_cfg_command_t) + sizeof(unsigned int);
572     if (copy_from_user(&priv->packet_filters, (void*)tclas_buffer,
573                 sizeof(uf_cfg_bcast_packet_filter_t))) {
574         unifi_error(priv, "UNIFI_CFG: Failed to get the filter struct\n");
575         return -EFAULT;
576     }
577
578     tclas_buffer_length = priv->packet_filters.tclas_ies_length;
579
580     /* Allocate TCLASs if necessary */
581     if (priv->packet_filters.dhcp_filter) {
582         priv->packet_filters.tclas_ies_length += sizeof(tclas_t);
583     }
584     if (priv->packet_filters.tclas_ies_length > 0) {
585         priv->filter_tclas_ies = kmalloc(priv->packet_filters.tclas_ies_length, GFP_KERNEL);
586         if (priv->filter_tclas_ies == NULL) {
587             return -ENOMEM;
588         }
589         if (tclas_buffer_length) {
590             tclas_buffer += sizeof(uf_cfg_bcast_packet_filter_t) - sizeof(unsigned char*);
591             if (copy_from_user(priv->filter_tclas_ies,
592                         tclas_buffer,
593                         tclas_buffer_length)) {
594                 unifi_error(priv, "UNIFI_CFG: Failed to get the TCLAS buffer\n");
595                 return -EFAULT;
596             }
597         }
598     }
599
600     if(priv->packet_filters.dhcp_filter)
601     {
602         /* Append the DHCP tclas IE */
603         dhcp_tclas = (tclas_t*)(priv->filter_tclas_ies + tclas_buffer_length);
604         memset(dhcp_tclas, 0, sizeof(tclas_t));
605         dhcp_tclas->element_id = 14;
606         dhcp_tclas->length = sizeof(tcpip_clsfr_t) + 1;
607         dhcp_tclas->user_priority = 0;
608         dhcp_tclas->tcp_ip_cls_fr.cls_fr_type = 1;
609         dhcp_tclas->tcp_ip_cls_fr.version = 4;
610         ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[0] = 0x00;
611         ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[1] = 0x44;
612         ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[0] = 0x00;
613         ((u8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[1] = 0x43;
614         dhcp_tclas->tcp_ip_cls_fr.protocol = 0x11;
615         dhcp_tclas->tcp_ip_cls_fr.cls_fr_mask = 0x58; //bits: 3,4,6
616     }
617
618     rc = sme_mgt_packet_filter_set(priv);
619
620     return rc;
621 }
622
623
624 int unifi_cfg_wmm_qos_info(unifi_priv_t *priv, unsigned char *arg)
625 {
626     u8 wmm_qos_info;
627     int rc = 0;
628
629     if (get_user(wmm_qos_info, (u8*)(((unifi_cfg_command_t*)arg) + 1))) {
630         unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
631         return -EFAULT;
632     }
633
634     /* Store the value in the connection info */
635     priv->connection_config.wmmQosInfo = wmm_qos_info;
636
637     return rc;
638 }
639
640
641 int unifi_cfg_wmm_addts(unifi_priv_t *priv, unsigned char *arg)
642 {
643     u32 addts_tid;
644     u8 addts_ie_length;
645     u8 *addts_ie;
646     u8 *addts_params;
647     CsrWifiSmeDataBlock tspec;
648     CsrWifiSmeDataBlock tclas;
649     int rc;
650
651     addts_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
652     if (get_user(addts_tid, (u32*)addts_params)) {
653         unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n");
654         return -EFAULT;
655     }
656
657     addts_params += sizeof(u32);
658     if (get_user(addts_ie_length, (u8*)addts_params)) {
659         unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n");
660         return -EFAULT;
661     }
662
663     unifi_trace(priv, UDBG4, "addts: tid = 0x%x ie_length = %d\n",
664             addts_tid, addts_ie_length);
665
666     addts_ie = kmalloc(addts_ie_length, GFP_KERNEL);
667     if (addts_ie == NULL) {
668         unifi_error(priv,
669                 "unifi_cfg_wmm_addts: Failed to malloc %d bytes for addts_ie buffer\n",
670                 addts_ie_length);
671         return -ENOMEM;
672     }
673
674     addts_params += sizeof(u8);
675     rc = copy_from_user(addts_ie, addts_params, addts_ie_length);
676     if (rc) {
677         unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the addts buffer\n");
678         kfree(addts_ie);
679         return -EFAULT;
680     }
681
682     tspec.data = addts_ie;
683     tspec.length = addts_ie_length;
684     tclas.data = NULL;
685     tclas.length = 0;
686
687     rc = sme_mgt_tspec(priv, CSR_WIFI_SME_LIST_ACTION_ADD, addts_tid,
688             &tspec, &tclas);
689
690     kfree(addts_ie);
691     return rc;
692 }
693
694
695 int unifi_cfg_wmm_delts(unifi_priv_t *priv, unsigned char *arg)
696 {
697     u32 delts_tid;
698     u8 *delts_params;
699     CsrWifiSmeDataBlock tspec;
700     CsrWifiSmeDataBlock tclas;
701     int rc;
702
703     delts_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
704     if (get_user(delts_tid, (u32*)delts_params)) {
705         unifi_error(priv, "unifi_cfg_wmm_delts: Failed to get the argument\n");
706         return -EFAULT;
707     }
708
709     unifi_trace(priv, UDBG4, "delts: tid = 0x%x\n", delts_tid);
710
711     tspec.data = tclas.data = NULL;
712     tspec.length = tclas.length = 0;
713
714     rc = sme_mgt_tspec(priv, CSR_WIFI_SME_LIST_ACTION_REMOVE, delts_tid,
715             &tspec, &tclas);
716
717     return rc;
718 }
719
720 int unifi_cfg_strict_draft_n(unifi_priv_t *priv, unsigned char *arg)
721 {
722     u8 strict_draft_n;
723     u8 *strict_draft_n_params;
724     int rc;
725
726     CsrWifiSmeStaConfig  staConfig;
727     CsrWifiSmeDeviceConfig  deviceConfig;
728
729     strict_draft_n_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
730     if (get_user(strict_draft_n, (u8*)strict_draft_n_params)) {
731         unifi_error(priv, "unifi_cfg_strict_draft_n: Failed to get the argument\n");
732         return -EFAULT;
733     }
734
735     unifi_trace(priv, UDBG4, "strict_draft_n: = %s\n", ((strict_draft_n) ? "yes":"no"));
736
737     rc = sme_mgt_sme_config_get(priv, &staConfig, &deviceConfig);
738
739     if (rc) {
740         unifi_warning(priv, "unifi_cfg_strict_draft_n: Get unifi_SMEConfigValue failed.\n");
741         return -EFAULT;
742     }
743
744     deviceConfig.enableStrictDraftN = strict_draft_n;
745
746     rc = sme_mgt_sme_config_set(priv, &staConfig, &deviceConfig);
747     if (rc) {
748         unifi_warning(priv, "unifi_cfg_strict_draft_n: Set unifi_SMEConfigValue failed.\n");
749         rc = -EFAULT;
750     }
751
752     return rc;
753 }
754
755
756 int unifi_cfg_enable_okc(unifi_priv_t *priv, unsigned char *arg)
757 {
758     u8 enable_okc;
759     u8 *enable_okc_params;
760     int rc;
761
762     CsrWifiSmeStaConfig staConfig;
763     CsrWifiSmeDeviceConfig deviceConfig;
764
765     enable_okc_params = (u8*)(((unifi_cfg_command_t*)arg) + 1);
766     if (get_user(enable_okc, (u8*)enable_okc_params)) {
767         unifi_error(priv, "unifi_cfg_enable_okc: Failed to get the argument\n");
768         return -EFAULT;
769     }
770
771     unifi_trace(priv, UDBG4, "enable_okc: = %s\n", ((enable_okc) ? "yes":"no"));
772
773     rc = sme_mgt_sme_config_get(priv, &staConfig, &deviceConfig);
774     if (rc) {
775         unifi_warning(priv, "unifi_cfg_enable_okc: Get unifi_SMEConfigValue failed.\n");
776         return -EFAULT;
777     }
778
779     staConfig.enableOpportunisticKeyCaching = enable_okc;
780
781     rc = sme_mgt_sme_config_set(priv, &staConfig, &deviceConfig);
782     if (rc) {
783         unifi_warning(priv, "unifi_cfg_enable_okc: Set unifi_SMEConfigValue failed.\n");
784         rc = -EFAULT;
785     }
786
787     return rc;
788 }
789
790
791 int unifi_cfg_get_info(unifi_priv_t *priv, unsigned char *arg)
792 {
793     unifi_cfg_get_t get_cmd;
794     char inst_name[IFNAMSIZ];
795     int rc;
796
797     if (get_user(get_cmd, (unifi_cfg_get_t*)(((unifi_cfg_command_t*)arg) + 1))) {
798         unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
799         return -EFAULT;
800     }
801
802     switch (get_cmd) {
803         case UNIFI_CFG_GET_COEX:
804             {
805                 CsrWifiSmeCoexInfo coexInfo;
806                 /* Get the coex info from the SME */
807                 rc = sme_mgt_coex_info_get(priv, &coexInfo);
808                 if (rc) {
809                     unifi_error(priv, "UNIFI_CFG: Get unifi_CoexInfoValue failed.\n");
810                     return rc;
811                 }
812
813                 /* Copy the info to the out buffer */
814                 if (copy_to_user((void*)arg,
815                             &coexInfo,
816                             sizeof(CsrWifiSmeCoexInfo))) {
817                     unifi_error(priv, "UNIFI_CFG: Failed to copy the coex info\n");
818                     return -EFAULT;
819                 }
820                 break;
821             }
822         case UNIFI_CFG_GET_POWER_MODE:
823             {
824                 CsrWifiSmePowerConfig powerConfig;
825                 rc = sme_mgt_power_config_get(priv, &powerConfig);
826                 if (rc) {
827                     unifi_error(priv, "UNIFI_CFG: Get unifi_PowerConfigValue failed.\n");
828                     return rc;
829                 }
830
831                 /* Copy the info to the out buffer */
832                 if (copy_to_user((void*)arg,
833                             &powerConfig.powerSaveLevel,
834                             sizeof(CsrWifiSmePowerSaveLevel))) {
835                     unifi_error(priv, "UNIFI_CFG: Failed to copy the power save info\n");
836                     return -EFAULT;
837                 }
838                 break;
839             }
840         case UNIFI_CFG_GET_POWER_SUPPLY:
841             {
842                 CsrWifiSmeHostConfig hostConfig;
843                 rc = sme_mgt_host_config_get(priv, &hostConfig);
844                 if (rc) {
845                     unifi_error(priv, "UNIFI_CFG: Get unifi_HostConfigValue failed.\n");
846                     return rc;
847                 }
848
849                 /* Copy the info to the out buffer */
850                 if (copy_to_user((void*)arg,
851                             &hostConfig.powerMode,
852                             sizeof(CsrWifiSmeHostPowerMode))) {
853                     unifi_error(priv, "UNIFI_CFG: Failed to copy the host power mode\n");
854                     return -EFAULT;
855                 }
856                 break;
857             }
858         case UNIFI_CFG_GET_VERSIONS:
859             break;
860         case UNIFI_CFG_GET_INSTANCE:
861             {
862                 u16 InterfaceId=0;
863                 uf_net_get_name(priv->netdev[InterfaceId], &inst_name[0], sizeof(inst_name));
864
865                 /* Copy the info to the out buffer */
866                 if (copy_to_user((void*)arg,
867                             &inst_name[0],
868                             sizeof(inst_name))) {
869                     unifi_error(priv, "UNIFI_CFG: Failed to copy the instance name\n");
870                     return -EFAULT;
871                 }
872             }
873             break;
874
875         case UNIFI_CFG_GET_AP_CONFIG:
876             {
877 #ifdef CSR_SUPPORT_WEXT_AP
878                 uf_cfg_ap_config_t cfg_ap_config;
879                 cfg_ap_config.channel = priv->ap_config.channel;
880                 cfg_ap_config.beaconInterval = priv->ap_mac_config.beaconInterval;
881                 cfg_ap_config.wmmEnabled = priv->ap_mac_config.wmmEnabled;
882                 cfg_ap_config.dtimPeriod = priv->ap_mac_config.dtimPeriod;
883                 cfg_ap_config.phySupportedBitmap = priv->ap_mac_config.phySupportedBitmap;
884                 if (copy_to_user((void*)arg,
885                             &cfg_ap_config,
886                             sizeof(uf_cfg_ap_config_t))) {
887                     unifi_error(priv, "UNIFI_CFG: Failed to copy the AP configuration\n");
888                     return -EFAULT;
889                 }
890 #else
891                    return -EPERM;
892 #endif
893             }
894             break;
895
896
897         default:
898             unifi_error(priv, "unifi_cfg_get_info: Unknown value.\n");
899             return -EINVAL;
900     }
901
902     return 0;
903 }
904 #ifdef CSR_SUPPORT_WEXT_AP
905 int
906  uf_configure_supported_rates(u8 * supportedRates, u8 phySupportedBitmap)
907 {
908     int i=0;
909     u8 b=FALSE, g = FALSE, n = FALSE;
910     b = phySupportedBitmap & CSR_WIFI_SME_AP_PHY_SUPPORT_B;
911     n = phySupportedBitmap & CSR_WIFI_SME_AP_PHY_SUPPORT_N;
912     g = phySupportedBitmap & CSR_WIFI_SME_AP_PHY_SUPPORT_G;
913     if(b || g) {
914         supportedRates[i++]=0x82;
915         supportedRates[i++]=0x84;
916         supportedRates[i++]=0x8b;
917         supportedRates[i++]=0x96;
918     } else if(n) {
919         /* For some strange reasons WiFi stack needs both b and g rates*/
920         supportedRates[i++]=0x02;
921         supportedRates[i++]=0x04;
922         supportedRates[i++]=0x0b;
923         supportedRates[i++]=0x16;
924         supportedRates[i++]=0x0c;
925         supportedRates[i++]=0x12;
926         supportedRates[i++]=0x18;
927         supportedRates[i++]=0x24;
928         supportedRates[i++]=0x30;
929         supportedRates[i++]=0x48;
930         supportedRates[i++]=0x60;
931         supportedRates[i++]=0x6c;
932     }
933     if(g) {
934         if(!b) {
935             supportedRates[i++]=0x8c;
936             supportedRates[i++]=0x98;
937             supportedRates[i++]=0xb0;
938         } else {
939             supportedRates[i++]=0x0c;
940             supportedRates[i++]=0x18;
941             supportedRates[i++]=0x30;
942         }
943         supportedRates[i++]=0x48;
944         supportedRates[i++]=0x12;
945         supportedRates[i++]=0x24;
946         supportedRates[i++]=0x60;
947         supportedRates[i++]=0x6c;
948     }
949     return i;
950 }
951 int unifi_cfg_set_ap_config(unifi_priv_t * priv,unsigned char* arg)
952 {
953     uf_cfg_ap_config_t cfg_ap_config;
954     char *buffer;
955
956     buffer = ((unsigned char*)arg) + sizeof(unifi_cfg_command_t) + sizeof(unsigned int);
957     if (copy_from_user(&cfg_ap_config, (void*)buffer,
958                 sizeof(uf_cfg_ap_config_t))) {
959         unifi_error(priv, "UNIFI_CFG: Failed to get the ap config struct\n");
960         return -EFAULT;
961     }
962     priv->ap_config.channel = cfg_ap_config.channel;
963     priv->ap_mac_config.dtimPeriod = cfg_ap_config.dtimPeriod;
964     priv->ap_mac_config.beaconInterval = cfg_ap_config.beaconInterval;
965     priv->group_sec_config.apGroupkeyTimeout = cfg_ap_config.groupkeyTimeout;
966     priv->group_sec_config.apStrictGtkRekey = cfg_ap_config.strictGtkRekeyEnabled;
967     priv->group_sec_config.apGmkTimeout = cfg_ap_config.gmkTimeout;
968     priv->group_sec_config.apResponseTimeout = cfg_ap_config.responseTimeout;
969     priv->group_sec_config.apRetransLimit = cfg_ap_config.retransLimit;
970
971     priv->ap_mac_config.shortSlotTimeEnabled = cfg_ap_config.shortSlotTimeEnabled;
972     priv->ap_mac_config.ctsProtectionType=cfg_ap_config.ctsProtectionType;
973
974     priv->ap_mac_config.wmmEnabled = cfg_ap_config.wmmEnabled;
975
976     priv->ap_mac_config.apHtParams.rxStbc=cfg_ap_config.rxStbc;
977     priv->ap_mac_config.apHtParams.rifsModeAllowed=cfg_ap_config.rifsModeAllowed;
978
979     priv->ap_mac_config.phySupportedBitmap = cfg_ap_config.phySupportedBitmap;
980     priv->ap_mac_config.maxListenInterval=cfg_ap_config.maxListenInterval;
981
982     priv->ap_mac_config.supportedRatesCount=     uf_configure_supported_rates(priv->ap_mac_config.supportedRates,priv->ap_mac_config.phySupportedBitmap);
983
984     return 0;
985 }
986
987 #endif
988 #ifdef CSR_SUPPORT_WEXT
989
990     void
991 uf_sme_config_wq(struct work_struct *work)
992 {
993     CsrWifiSmeStaConfig  staConfig;
994     CsrWifiSmeDeviceConfig  deviceConfig;
995     unifi_priv_t *priv = container_of(work, unifi_priv_t, sme_config_task);
996
997     /* Register to receive indications from the SME */
998     CsrWifiSmeEventMaskSetReqSend(0,
999             CSR_WIFI_SME_INDICATIONS_WIFIOFF | CSR_WIFI_SME_INDICATIONS_CONNECTIONQUALITY |
1000             CSR_WIFI_SME_INDICATIONS_MEDIASTATUS | CSR_WIFI_SME_INDICATIONS_MICFAILURE);
1001
1002     if (sme_mgt_sme_config_get(priv, &staConfig, &deviceConfig)) {
1003         unifi_warning(priv, "uf_sme_config_wq: Get unifi_SMEConfigValue failed.\n");
1004         return;
1005     }
1006
1007     if (priv->if_index == CSR_INDEX_5G) {
1008         staConfig.ifIndex = CSR_WIFI_SME_RADIO_IF_GHZ_5_0;
1009     } else {
1010         staConfig.ifIndex = CSR_WIFI_SME_RADIO_IF_GHZ_2_4;
1011     }
1012
1013     deviceConfig.trustLevel = (CsrWifiSme80211dTrustLevel)tl_80211d;
1014     if (sme_mgt_sme_config_set(priv, &staConfig, &deviceConfig)) {
1015         unifi_warning(priv,
1016                 "SME config for 802.11d Trust Level and Radio Band failed.\n");
1017         return;
1018     }
1019
1020 } /* uf_sme_config_wq() */
1021
1022 #endif /* CSR_SUPPORT_WEXT */
1023
1024
1025 /*
1026  * ---------------------------------------------------------------------------
1027  *  uf_ta_ind_wq
1028  *
1029  *      Deferred work queue function to send Traffic Analysis protocols
1030  *      indications to the SME.
1031  *      These are done in a deferred work queue for two reasons:
1032  *       - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context
1033  *       - we want to load the main driver data path as lightly as possible
1034  *
1035  *      The TA classifications already come from a workqueue.
1036  *
1037  *  Arguments:
1038  *      work    Pointer to work queue item.
1039  *
1040  *  Returns:
1041  *      None.
1042  * ---------------------------------------------------------------------------
1043  */
1044     void
1045 uf_ta_ind_wq(struct work_struct *work)
1046 {
1047     struct ta_ind *ind = container_of(work, struct ta_ind, task);
1048     unifi_priv_t *priv = container_of(ind, unifi_priv_t, ta_ind_work);
1049     u16 interfaceTag = 0;
1050
1051
1052     CsrWifiRouterCtrlTrafficProtocolIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,
1053             interfaceTag,
1054             ind->packet_type,
1055             ind->direction,
1056             ind->src_addr);
1057     ind->in_use = 0;
1058
1059 } /* uf_ta_ind_wq() */
1060
1061
1062 /*
1063  * ---------------------------------------------------------------------------
1064  *  uf_ta_sample_ind_wq
1065  *
1066  *      Deferred work queue function to send Traffic Analysis sample
1067  *      indications to the SME.
1068  *      These are done in a deferred work queue for two reasons:
1069  *       - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context
1070  *       - we want to load the main driver data path as lightly as possible
1071  *
1072  *      The TA classifications already come from a workqueue.
1073  *
1074  *  Arguments:
1075  *      work    Pointer to work queue item.
1076  *
1077  *  Returns:
1078  *      None.
1079  * ---------------------------------------------------------------------------
1080  */
1081     void
1082 uf_ta_sample_ind_wq(struct work_struct *work)
1083 {
1084     struct ta_sample_ind *ind = container_of(work, struct ta_sample_ind, task);
1085     unifi_priv_t *priv = container_of(ind, unifi_priv_t, ta_sample_ind_work);
1086     u16 interfaceTag = 0;
1087
1088      unifi_trace(priv, UDBG5, "rxtcp %d txtcp %d rxudp %d txudp %d prio %d\n",
1089         priv->rxTcpThroughput,
1090         priv->txTcpThroughput,
1091         priv->rxUdpThroughput,
1092         priv->txUdpThroughput,
1093         priv->bh_thread.prio);
1094
1095     if(priv->rxTcpThroughput > 1000)
1096     {
1097         if (bh_priority == -1 && priv->bh_thread.prio != 1)
1098         {
1099             struct sched_param param;
1100             priv->bh_thread.prio = 1;
1101             unifi_trace(priv, UDBG1, "%s new thread (RT) priority = %d\n",
1102                         priv->bh_thread.name, priv->bh_thread.prio);
1103             param.sched_priority = priv->bh_thread.prio;
1104             sched_setscheduler(priv->bh_thread.thread_task, SCHED_FIFO, &param);
1105         }
1106     } else
1107     {
1108         if (bh_priority == -1 && priv->bh_thread.prio != DEFAULT_PRIO)
1109         {
1110             struct sched_param param;
1111             param.sched_priority = 0;
1112             sched_setscheduler(priv->bh_thread.thread_task, SCHED_NORMAL, &param);
1113             priv->bh_thread.prio = DEFAULT_PRIO;
1114             unifi_trace(priv, UDBG1, "%s new thread priority = %d\n",
1115                         priv->bh_thread.name, priv->bh_thread.prio);
1116             set_user_nice(priv->bh_thread.thread_task, PRIO_TO_NICE(priv->bh_thread.prio));
1117         }
1118     }
1119
1120     CsrWifiRouterCtrlTrafficSampleIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, interfaceTag, ind->stats);
1121
1122     ind->in_use = 0;
1123
1124 } /* uf_ta_sample_ind_wq() */
1125
1126
1127 /*
1128  * ---------------------------------------------------------------------------
1129  *  uf_send_m4_ready_wq
1130  *
1131  *      Deferred work queue function to send M4 ReadyToSend inds to the SME.
1132  *      These are done in a deferred work queue for two reasons:
1133  *       - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context
1134  *       - we want to load the main driver data path as lightly as possible
1135  *
1136  *  Arguments:
1137  *      work    Pointer to work queue item.
1138  *
1139  *  Returns:
1140  *      None.
1141  * ---------------------------------------------------------------------------
1142  */
1143 void
1144 uf_send_m4_ready_wq(struct work_struct *work)
1145 {
1146     netInterface_priv_t *InterfacePriv = container_of(work, netInterface_priv_t, send_m4_ready_task);
1147     u16 iface = InterfacePriv->InterfaceTag;
1148     unifi_priv_t *priv = InterfacePriv->privPtr;
1149     CSR_MA_PACKET_REQUEST *req = &InterfacePriv->m4_signal.u.MaPacketRequest;
1150     CsrWifiMacAddress peer;
1151     unsigned long flags;
1152
1153     /* The peer address was stored in the signal */
1154     spin_lock_irqsave(&priv->m4_lock, flags);
1155     memcpy(peer.a, req->Ra.x, sizeof(peer.a));
1156     spin_unlock_irqrestore(&priv->m4_lock, flags);
1157
1158     /* Send a signal to SME */
1159     CsrWifiRouterCtrlM4ReadyToSendIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, iface, peer);
1160
1161         unifi_trace(priv, UDBG1, "M4ReadyToSendInd sent for peer %pMF\n",
1162                 peer.a);
1163
1164 } /* uf_send_m4_ready_wq() */
1165
1166 #if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
1167 /*
1168  * ---------------------------------------------------------------------------
1169  *  uf_send_pkt_to_encrypt
1170  *
1171  *      Deferred work queue function to send the WAPI data pkts to SME when unicast KeyId = 1
1172  *      These are done in a deferred work queue for two reasons:
1173  *       - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context
1174  *       - we want to load the main driver data path as lightly as possible
1175  *
1176  *  Arguments:
1177  *      work    Pointer to work queue item.
1178  *
1179  *  Returns:
1180  *      None.
1181  * ---------------------------------------------------------------------------
1182  */
1183 void uf_send_pkt_to_encrypt(struct work_struct *work)
1184 {
1185     netInterface_priv_t *interfacePriv = container_of(work, netInterface_priv_t, send_pkt_to_encrypt);
1186     u16 interfaceTag = interfacePriv->InterfaceTag;
1187     unifi_priv_t *priv = interfacePriv->privPtr;
1188
1189     u32 pktBulkDataLength;
1190     u8 *pktBulkData;
1191     unsigned long flags;
1192
1193     if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA) {
1194
1195         pktBulkDataLength = interfacePriv->wapi_unicast_bulk_data.data_length;
1196
1197         if (pktBulkDataLength > 0) {
1198                     pktBulkData = kmalloc(pktBulkDataLength, GFP_KERNEL);
1199             } else {
1200                     unifi_error(priv, "uf_send_pkt_to_encrypt() : invalid buffer\n");
1201                     return;
1202             }
1203
1204         spin_lock_irqsave(&priv->wapi_lock, flags);
1205         /* Copy over the MA PKT REQ bulk data */
1206         memcpy(pktBulkData, (u8*)interfacePriv->wapi_unicast_bulk_data.os_data_ptr, pktBulkDataLength);
1207         /* Free any bulk data buffers allocated for the WAPI Data pkt */
1208         unifi_net_data_free(priv, &interfacePriv->wapi_unicast_bulk_data);
1209         interfacePriv->wapi_unicast_bulk_data.net_buf_length = 0;
1210         interfacePriv->wapi_unicast_bulk_data.data_length = 0;
1211         interfacePriv->wapi_unicast_bulk_data.os_data_ptr = interfacePriv->wapi_unicast_bulk_data.os_net_buf_ptr = NULL;
1212         spin_unlock_irqrestore(&priv->wapi_lock, flags);
1213
1214         CsrWifiRouterCtrlWapiUnicastTxEncryptIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, pktBulkDataLength, pktBulkData);
1215         unifi_trace(priv, UDBG1, "WapiUnicastTxEncryptInd sent to SME\n");
1216
1217         kfree(pktBulkData); /* Would have been copied over by the SME Handler */
1218
1219     } else {
1220             unifi_warning(priv, "uf_send_pkt_to_encrypt() is NOT applicable for interface mode - %d\n",interfacePriv->interfaceMode);
1221     }
1222 }/* uf_send_pkt_to_encrypt() */
1223 #endif