Root/drivers/staging/csr/unifi_pdu_processing.c

1/*
2 * ---------------------------------------------------------------------------
3 * FILE: unifi_pdu_processing.c
4 *
5 * PURPOSE:
6 * This file provides the PDU handling functionality before it gets sent to unfi and after
7 * receiving a PDU from unifi
8 *
9 * Copyright (C) 2010 by Cambridge Silicon Radio Ltd.
10 *
11 * Refer to LICENSE.txt included with this source code for details on
12 * the license terms.
13 *
14 * ---------------------------------------------------------------------------
15 */
16
17
18#include <linux/types.h>
19#include <linux/etherdevice.h>
20#include <linux/vmalloc.h>
21
22#include "csr_wifi_hip_unifi.h"
23#include "csr_wifi_hip_conversions.h"
24#include "csr_time.h"
25#include "unifi_priv.h"
26#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,13)
27#include <net/iw_handler.h>
28#endif
29#include <net/pkt_sched.h>
30
31#ifdef CSR_SUPPORT_SME
32static void _update_buffered_pkt_params_after_alignment(unifi_priv_t *priv, bulk_data_param_t *bulkdata,
33                                                        tx_buffered_packets_t* buffered_pkt)
34{
35    struct sk_buff *skb ;
36    u32 align_offset;
37
38    if (priv == NULL || bulkdata == NULL || buffered_pkt == NULL){
39        return;
40    }
41
42    skb = (struct sk_buff*)bulkdata->d[0].os_net_buf_ptr;
43    align_offset = (u32)(long)(bulkdata->d[0].os_data_ptr) & (CSR_WIFI_ALIGN_BYTES-1);
44    if(align_offset){
45        skb_pull(skb,align_offset);
46    }
47
48    buffered_pkt->bulkdata.os_data_ptr = bulkdata->d[0].os_data_ptr;
49    buffered_pkt->bulkdata.data_length = bulkdata->d[0].data_length;
50    buffered_pkt->bulkdata.os_net_buf_ptr = bulkdata->d[0].os_net_buf_ptr;
51    buffered_pkt->bulkdata.net_buf_length = bulkdata->d[0].net_buf_length;
52}
53#endif
54
55void
56unifi_frame_ma_packet_req(unifi_priv_t *priv, CSR_PRIORITY priority,
57                          CSR_RATE TransmitRate, CSR_CLIENT_TAG hostTag,
58                          u16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
59                          CSR_PROCESS_ID leSenderProcessId, u8 *peerMacAddress,
60                          CSR_SIGNAL *signal)
61{
62
63    CSR_MA_PACKET_REQUEST *req = &signal->u.MaPacketRequest;
64    netInterface_priv_t *interfacePriv;
65    u8 ba_session_idx = 0;
66    ba_session_tx_struct *ba_session = NULL;
67    u8 *ba_addr = NULL;
68
69    interfacePriv = priv->interfacePriv[interfaceTag];
70
71    unifi_trace(priv, UDBG5,
72        "In unifi_frame_ma_packet_req, Frame for Peer: %pMF\n",
73        peerMacAddress);
74    signal->SignalPrimitiveHeader.SignalId = CSR_MA_PACKET_REQUEST_ID;
75    signal->SignalPrimitiveHeader.ReceiverProcessId = 0;
76    signal->SignalPrimitiveHeader.SenderProcessId = leSenderProcessId;
77
78    /* Fill the MA-PACKET.req */
79    req->Priority = priority;
80    unifi_trace(priv, UDBG3, "Tx Frame with Priority: 0x%x\n", req->Priority);
81
82    /* A value of 0 is used for auto selection of rates. But for P2P GO case
83     * for action frames the rate is governed by SME. Hence instead of 0,
84     * the rate is filled in with the value passed here
85     */
86    req->TransmitRate = TransmitRate;
87
88    /* packets from netdev then no confirm required but packets from
89     * Nme/Sme eapol data frames requires the confirmation
90     */
91    req->TransmissionControl = transmissionControl;
92    req->VirtualInterfaceIdentifier =
93           uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag);
94    memcpy(req->Ra.x, peerMacAddress, ETH_ALEN);
95
96    if (hostTag == 0xffffffff) {
97        req->HostTag = interfacePriv->tag++;
98        req->HostTag |= 0x40000000;
99        unifi_trace(priv, UDBG3, "new host tag assigned = 0x%x\n", req->HostTag);
100        interfacePriv->tag &= 0x0fffffff;
101    } else {
102        req->HostTag = hostTag;
103        unifi_trace(priv, UDBG3, "host tag got from SME = 0x%x\n", req->HostTag);
104    }
105    /* check if BA session exists for the peer MAC address on same tID */
106    if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
107       interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO){
108        ba_addr = peerMacAddress;
109    }else{
110        ba_addr = interfacePriv->bssid.a;
111    }
112    for (ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_TX; ba_session_idx++){
113        ba_session = interfacePriv->ba_session_tx[ba_session_idx];
114        if (ba_session){
115           if ((!memcmp(ba_session->macAddress.a, ba_addr, ETH_ALEN)) && (ba_session->tID == priority)){
116                req->TransmissionControl |= CSR_ALLOW_BA;
117                break;
118            }
119        }
120    }
121
122    unifi_trace(priv, UDBG5, "leaving unifi_frame_ma_packet_req\n");
123}
124
125#ifdef CSR_SUPPORT_SME
126
127#define TRANSMISSION_CONTROL_TRIGGER_MASK 0x0001
128#define TRANSMISSION_CONTROL_EOSP_MASK 0x0002
129
130static
131int frame_and_send_queued_pdu(unifi_priv_t* priv,tx_buffered_packets_t* buffered_pkt,
132            CsrWifiRouterCtrlStaInfo_t *staRecord,u8 moreData , u8 eosp)
133{
134
135    CSR_SIGNAL signal;
136    bulk_data_param_t bulkdata;
137    int result;
138    u8 toDs, fromDs, macHeaderLengthInBytes = MAC_HEADER_SIZE;
139    u8 *qc;
140    u16 *fc = (u16*)(buffered_pkt->bulkdata.os_data_ptr);
141    unsigned long lock_flags;
142    unifi_trace(priv, UDBG3, "frame_and_send_queued_pdu with moreData: %d , EOSP: %d\n",moreData,eosp);
143    unifi_frame_ma_packet_req(priv, buffered_pkt->priority, buffered_pkt->rate, buffered_pkt->hostTag,
144               buffered_pkt->interfaceTag, buffered_pkt->transmissionControl,
145               buffered_pkt->leSenderProcessId, buffered_pkt->peerMacAddress.a, &signal);
146    bulkdata.d[0].os_data_ptr = buffered_pkt->bulkdata.os_data_ptr;
147    bulkdata.d[0].data_length = buffered_pkt->bulkdata.data_length;
148    bulkdata.d[0].os_net_buf_ptr = buffered_pkt->bulkdata.os_net_buf_ptr;
149    bulkdata.d[0].net_buf_length = buffered_pkt->bulkdata.net_buf_length;
150    bulkdata.d[1].os_data_ptr = NULL;
151    bulkdata.d[1].data_length = 0;
152    bulkdata.d[1].os_net_buf_ptr =0;
153    bulkdata.d[1].net_buf_length =0;
154
155    if(moreData) {
156        *fc |= cpu_to_le16(IEEE802_11_FC_MOREDATA_MASK);
157    } else {
158        *fc &= cpu_to_le16(~IEEE802_11_FC_MOREDATA_MASK);
159    }
160
161    if((staRecord != NULL)&& (staRecord->wmmOrQosEnabled == TRUE))
162    {
163        unifi_trace(priv, UDBG3, "frame_and_send_queued_pdu WMM Enabled: %d \n",staRecord->wmmOrQosEnabled);
164
165        toDs = (*fc & cpu_to_le16(IEEE802_11_FC_TO_DS_MASK))?1 : 0;
166        fromDs = (*fc & cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK))? 1: 0;
167
168        switch(le16_to_cpu(*fc) & IEEE80211_FC_SUBTYPE_MASK)
169        {
170            case IEEE802_11_FC_TYPE_QOS_DATA & IEEE80211_FC_SUBTYPE_MASK:
171            case IEEE802_11_FC_TYPE_QOS_NULL & IEEE80211_FC_SUBTYPE_MASK:
172                /* If both are set then the Address4 exists (only for AP) */
173                if (fromDs && toDs) {
174                    /* 6 is the size of Address4 field */
175                    macHeaderLengthInBytes += (QOS_CONTROL_HEADER_SIZE + 6);
176                } else {
177                    macHeaderLengthInBytes += QOS_CONTROL_HEADER_SIZE;
178                }
179
180                /* If order bit set then HT control field is the part of MAC header */
181                if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
182                    macHeaderLengthInBytes += HT_CONTROL_HEADER_SIZE;
183                    qc = (u8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-6));
184                } else {
185                    qc = (u8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-2));
186                }
187                *qc = eosp ? *qc | (1 << 4) : *qc & (~(1 << 4));
188                break;
189            default:
190                if (fromDs && toDs)
191                    macHeaderLengthInBytes += 6;
192        }
193
194    }
195    result = ul_send_signal_unpacked(priv, &signal, &bulkdata);
196    if(result){
197        _update_buffered_pkt_params_after_alignment(priv, &bulkdata,buffered_pkt);
198    }
199
200 /* Decrement the packet counts queued in driver */
201    if (result != -ENOSPC) {
202        /* protect entire counter updation by disabling preemption */
203        if (!priv->noOfPktQueuedInDriver) {
204            unifi_error(priv, "packets queued in driver 0 still decrementing\n");
205        } else {
206            spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
207            priv->noOfPktQueuedInDriver--;
208            spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
209        }
210        /* Sta Record is available for all unicast (except genericMgt Frames) & in other case its NULL */
211        if (staRecord) {
212            spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
213            if (!staRecord->noOfPktQueued) {
214                unifi_error(priv, "packets queued in driver per station is 0 still decrementing\n");
215            } else {
216                staRecord->noOfPktQueued--;
217            }
218            /* if the STA alive probe frame has failed then reset the saved host tag */
219            if (result){
220                if (staRecord->nullDataHostTag == buffered_pkt->hostTag){
221                    staRecord->nullDataHostTag = INVALID_HOST_TAG;
222                }
223            }
224            spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
225        }
226
227    }
228    return result;
229}
230#ifdef CSR_SUPPORT_SME
231static
232void set_eosp_transmit_ctrl(unifi_priv_t *priv, struct list_head *txList)
233{
234    /* dequeue the tx data packets from the appropriate queue */
235    tx_buffered_packets_t *tx_q_item = NULL;
236    struct list_head *listHead;
237    struct list_head *placeHolder;
238    unsigned long lock_flags;
239
240
241    unifi_trace(priv, UDBG5, "entering set_eosp_transmit_ctrl\n");
242    /* check for list empty */
243    if (list_empty(txList)) {
244        unifi_warning(priv, "In set_eosp_transmit_ctrl, the list is empty\n");
245        return;
246    }
247
248    /* return the last node , and modify it. */
249
250    spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
251    list_for_each_prev_safe(listHead, placeHolder, txList) {
252        tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
253        tx_q_item->transmissionControl |= TRANSMISSION_CONTROL_EOSP_MASK;
254        tx_q_item->transmissionControl = (tx_q_item->transmissionControl & ~(CSR_NO_CONFIRM_REQUIRED));
255        unifi_trace(priv, UDBG1,
256                "set_eosp_transmit_ctrl Transmission Control = 0x%x hostTag = 0x%x \n",tx_q_item->transmissionControl,tx_q_item->hostTag);
257        unifi_trace(priv,UDBG3,"in set_eosp_transmit_ctrl no.of buffered frames %d\n",priv->noOfPktQueuedInDriver);
258        break;
259    }
260    spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
261    unifi_trace(priv, UDBG1,"List Empty %d\n",list_empty(txList));
262    unifi_trace(priv, UDBG5, "leaving set_eosp_transmit_ctrl\n");
263    return;
264}
265
266static
267void send_vif_availibility_rsp(unifi_priv_t *priv,CSR_VIF_IDENTIFIER vif,CSR_RESULT_CODE resultCode)
268{
269    CSR_SIGNAL signal;
270    CSR_MA_VIF_AVAILABILITY_RESPONSE *rsp;
271    bulk_data_param_t *bulkdata = NULL;
272    int r;
273
274    unifi_trace(priv, UDBG3, "send_vif_availibility_rsp : invoked with resultCode = %d \n", resultCode);
275
276    memset(&signal,0,sizeof(CSR_SIGNAL));
277    rsp = &signal.u.MaVifAvailabilityResponse;
278    rsp->VirtualInterfaceIdentifier = vif;
279    rsp->ResultCode = resultCode;
280    signal.SignalPrimitiveHeader.SignalId = CSR_MA_VIF_AVAILABILITY_RESPONSE_ID;
281    signal.SignalPrimitiveHeader.ReceiverProcessId = 0;
282    signal.SignalPrimitiveHeader.SenderProcessId = priv->netdev_client->sender_id;
283
284    /* Send the signal to UniFi */
285    r = ul_send_signal_unpacked(priv, &signal, bulkdata);
286    if(r) {
287        unifi_error(priv,"Availibility response sending failed %x status %d\n",vif,r);
288    }
289    else {
290        unifi_trace(priv, UDBG3, "send_vif_availibility_rsp : status = %d \n", r);
291    }
292}
293#endif
294
295static
296void verify_and_accomodate_tx_packet(unifi_priv_t *priv)
297{
298    tx_buffered_packets_t *tx_q_item;
299    unsigned long lock_flags;
300    struct list_head *listHead, *list;
301    struct list_head *placeHolder;
302    u8 i, j,eospFramedeleted=0;
303    u8 thresholdExcedeDueToBroadcast = TRUE;
304    /* it will be made it interface Specific in the future when multi interfaces are supported ,
305    right now interface 0 is considered */
306    netInterface_priv_t *interfacePriv = priv->interfacePriv[0];
307    CsrWifiRouterCtrlStaInfo_t *staInfo = NULL;
308
309    unifi_trace(priv, UDBG3, "entering verify_and_accomodate_tx_packet\n");
310
311    for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
312        staInfo = interfacePriv->staInfo[i];
313            if (staInfo && (staInfo->noOfPktQueued >= CSR_WIFI_DRIVER_MAX_PKT_QUEUING_THRESHOLD_PER_PEER)) {
314            /* remove the first(oldest) packet from the all the access catogory, since data
315             * packets for station record crossed the threshold limit (64 for AP supporting
316             * 8 peers)
317             */
318            unifi_trace(priv,UDBG3,"number of station pkts queued= %d for sta id = %d\n", staInfo->noOfPktQueued, staInfo->aid);
319            for(j = 0; j < MAX_ACCESS_CATOGORY; j++) {
320                list = &staInfo->dataPdu[j];
321                spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
322                list_for_each_safe(listHead, placeHolder, list) {
323                    tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
324                    list_del(listHead);
325                    thresholdExcedeDueToBroadcast = FALSE;
326                    unifi_net_data_free(priv, &tx_q_item->bulkdata);
327                    kfree(tx_q_item);
328                    tx_q_item = NULL;
329                    if (!priv->noOfPktQueuedInDriver) {
330                        unifi_error(priv, "packets queued in driver 0 still decrementing in %s\n", __FUNCTION__);
331                    } else {
332                        /* protection provided by spinlock */
333                        priv->noOfPktQueuedInDriver--;
334
335                    }
336                    /* Sta Record is available for all unicast (except genericMgt Frames) & in other case its NULL */
337                    if (!staInfo->noOfPktQueued) {
338                        unifi_error(priv, "packets queued in driver per station is 0 still decrementing in %s\n", __FUNCTION__);
339                    } else {
340                        spin_lock(&priv->staRecord_lock);
341                        staInfo->noOfPktQueued--;
342                        spin_unlock(&priv->staRecord_lock);
343                    }
344                    break;
345                }
346                spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
347            }
348        }
349    }
350    if (thresholdExcedeDueToBroadcast && interfacePriv->noOfbroadcastPktQueued > CSR_WIFI_DRIVER_MINIMUM_BROADCAST_PKT_THRESHOLD ) {
351        /* Remove the packets from genericMulticastOrBroadCastFrames queue
352         * (the max packets in driver is reached due to broadcast/multicast frames)
353         */
354        spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
355        list_for_each_safe(listHead, placeHolder, &interfacePriv->genericMulticastOrBroadCastFrames) {
356            tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
357            if(eospFramedeleted){
358                tx_q_item->transmissionControl |= TRANSMISSION_CONTROL_EOSP_MASK;
359                tx_q_item->transmissionControl = (tx_q_item->transmissionControl & ~(CSR_NO_CONFIRM_REQUIRED));
360                unifi_trace(priv, UDBG1,"updating eosp for next packet hostTag:= 0x%x ",tx_q_item->hostTag);
361                eospFramedeleted =0;
362                break;
363            }
364
365            if(tx_q_item->transmissionControl & TRANSMISSION_CONTROL_EOSP_MASK ){
366               eospFramedeleted = 1;
367            }
368            unifi_trace(priv,UDBG1, "freeing of multicast packets ToC = 0x%x hostTag = 0x%x \n",tx_q_item->transmissionControl,tx_q_item->hostTag);
369            list_del(listHead);
370            unifi_net_data_free(priv, &tx_q_item->bulkdata);
371            kfree(tx_q_item);
372            priv->noOfPktQueuedInDriver--;
373            spin_lock(&priv->staRecord_lock);
374            interfacePriv->noOfbroadcastPktQueued--;
375            spin_unlock(&priv->staRecord_lock);
376            if(!eospFramedeleted){
377                break;
378            }
379        }
380        spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
381    }
382    unifi_trace(priv, UDBG3, "leaving verify_and_accomodate_tx_packet\n");
383}
384
385static
386CsrResult enque_tx_data_pdu(unifi_priv_t *priv, bulk_data_param_t *bulkdata,
387                            struct list_head *list, CSR_SIGNAL *signal,
388                            u8 requeueOnSamePos)
389{
390
391    /* queue the tx data packets on to appropriate queue */
392    CSR_MA_PACKET_REQUEST *req = &signal->u.MaPacketRequest;
393    tx_buffered_packets_t *tx_q_item;
394    unsigned long lock_flags;
395
396    unifi_trace(priv, UDBG5, "entering enque_tx_data_pdu\n");
397    if(!list) {
398       unifi_error(priv,"List is not specified\n");
399       return CSR_RESULT_FAILURE;
400    }
401
402    /* Removes aged packets & adds the incoming packet */
403    if (priv->noOfPktQueuedInDriver >= CSR_WIFI_DRIVER_SUPPORT_FOR_MAX_PKT_QUEUEING) {
404        unifi_trace(priv,UDBG3,"number of pkts queued= %d \n", priv->noOfPktQueuedInDriver);
405        verify_and_accomodate_tx_packet(priv);
406    }
407
408
409
410    tx_q_item = (tx_buffered_packets_t *)kmalloc(sizeof(tx_buffered_packets_t), GFP_ATOMIC);
411    if (tx_q_item == NULL) {
412        unifi_error(priv,
413                "Failed to allocate %d bytes for tx packet record\n",
414                sizeof(tx_buffered_packets_t));
415        func_exit();
416        return CSR_RESULT_FAILURE;
417    }
418
419    /* disable the preemption */
420    spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
421    INIT_LIST_HEAD(&tx_q_item->q);
422    /* fill the tx_q structure members */
423    tx_q_item->bulkdata.os_data_ptr = bulkdata->d[0].os_data_ptr;
424    tx_q_item->bulkdata.data_length = bulkdata->d[0].data_length;
425    tx_q_item->bulkdata.os_net_buf_ptr = bulkdata->d[0].os_net_buf_ptr;
426    tx_q_item->bulkdata.net_buf_length = bulkdata->d[0].net_buf_length;
427    tx_q_item->interfaceTag = req->VirtualInterfaceIdentifier & 0xff;
428    tx_q_item->hostTag = req->HostTag;
429    tx_q_item->leSenderProcessId = signal->SignalPrimitiveHeader.SenderProcessId;
430    tx_q_item->transmissionControl = req->TransmissionControl;
431    tx_q_item->priority = req->Priority;
432    tx_q_item->rate = req->TransmitRate;
433    memcpy(tx_q_item->peerMacAddress.a, req->Ra.x, ETH_ALEN);
434
435
436
437    if (requeueOnSamePos) {
438        list_add(&tx_q_item->q, list);
439    } else {
440        list_add_tail(&tx_q_item->q, list);
441    }
442
443    /* Count of packet queued in driver */
444    priv->noOfPktQueuedInDriver++;
445    spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
446    unifi_trace(priv, UDBG5, "leaving enque_tx_data_pdu\n");
447    return CSR_RESULT_SUCCESS;
448}
449
450#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
451CsrResult unifi_reque_ma_packet_request (void *ospriv, u32 host_tag,
452                                         u16 txStatus, bulk_data_desc_t *bulkDataDesc)
453{
454    CsrResult status = CSR_RESULT_SUCCESS;
455    unifi_priv_t *priv = (unifi_priv_t*)ospriv;
456    netInterface_priv_t *interfacePriv;
457    struct list_head *list = NULL;
458    CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
459    bulk_data_param_t bulkData;
460    CSR_SIGNAL signal;
461    CSR_PRIORITY priority = 0;
462    u16 interfaceTag = 0;
463    unifi_TrafficQueue priority_q;
464    u16 frameControl = 0, frameType = 0;
465    unsigned long lock_flags;
466
467    interfacePriv = priv->interfacePriv[interfaceTag];
468
469    /* If the current mode is not AP or P2PGO then just return failure
470     * to clear the hip slot
471     */
472    if(!((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP) ||
473        (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO))) {
474        return CSR_RESULT_FAILURE;
475    }
476
477    unifi_trace(priv, UDBG6, "unifi_reque_ma_packet_request: host_tag = 0x%x\n", host_tag);
478
479    staRecord = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,
480                                                                    (((u8 *) bulkDataDesc->os_data_ptr) + 4),
481                                                                    interfaceTag);
482    if (NULL == staRecord) {
483        unifi_trace(priv, UDBG5, "unifi_reque_ma_packet_request: Invalid STA record \n");
484        return CSR_RESULT_FAILURE;
485    }
486
487    /* Update TIM if MA-PACKET.cfm fails with status as Tx-retry-limit or No-BSS and then just return failure
488     * to clear the hip slot associated with the Packet
489     */
490    if (CSR_TX_RETRY_LIMIT == txStatus || CSR_TX_NO_BSS == txStatus) {
491        if (staRecord->timSet == CSR_WIFI_TIM_RESET || staRecord->timSet == CSR_WIFI_TIM_RESETTING)
492        {
493            unifi_trace(priv, UDBG2, "unifi_reque_ma_packet_request: CFM failed with Retry Limit or No BSS-->update TIM\n");
494            if (!staRecord->timRequestPendingFlag) {
495                update_tim(priv, staRecord->aid, 1, interfaceTag, staRecord->assignedHandle);
496            }
497            else {
498                /* Cache the TimSet value so that it will processed immidiatly after
499                 * completing the current setTim Request
500                 */
501                staRecord->updateTimReqQueued = 1;
502                unifi_trace(priv, UDBG6, "unifi_reque_ma_packet_request: One more UpdateTim Request(:%d)Queued for AID %x\n",
503                                         staRecord->updateTimReqQueued, staRecord->aid);
504            }
505        }
506        return CSR_RESULT_FAILURE;
507    }
508    else if ((CSR_TX_LIFETIME == txStatus) || (CSR_TX_BLOCK_ACK_TIMEOUT == txStatus) ||
509             (CSR_TX_FAIL_TRANSMISSION_VIF_INTERRUPTED == txStatus) ||
510             (CSR_TX_REJECTED_PEER_STATION_SLEEPING == txStatus) ||
511             (CSR_TX_REJECTED_DTIM_STARTED == txStatus)) {
512        /* Extract the Frame control and the frame type */
513        frameControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(bulkDataDesc->os_data_ptr);
514        frameType = ((frameControl & IEEE80211_FC_TYPE_MASK) >> FRAME_CONTROL_TYPE_FIELD_OFFSET);
515
516        /* Mgmt frames will not be re-queued for Tx
517         * so just return failure to clear the hip slot
518         */
519        if (IEEE802_11_FRAMETYPE_MANAGEMENT == frameType) {
520            return CSR_RESULT_FAILURE;
521        }
522        else if (IEEE802_11_FRAMETYPE_DATA == frameType) {
523            /* QOS NULL and DATA NULL frames will not be re-queued for Tx
524             * so just return failure to clear the hip slot
525             */
526            if ((((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> FRAME_CONTROL_SUBTYPE_FIELD_OFFSET) == QOS_DATA_NULL) ||
527                (((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> FRAME_CONTROL_SUBTYPE_FIELD_OFFSET)== DATA_NULL )) {
528                return CSR_RESULT_FAILURE;
529            }
530        }
531
532        /* Extract the Packet priority */
533        if (TRUE == staRecord->wmmOrQosEnabled) {
534            u16 qosControl = 0;
535            u8 dataFrameType = 0;
536
537            dataFrameType =((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> 4);
538
539            if (dataFrameType == QOS_DATA) {
540                /* QoS control field is offset from frame control by 2 (frame control)
541                 * + 2 (duration/ID) + 2 (sequence control) + 3*ETH_ALEN or 4*ETH_ALEN
542                 */
543                if((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK)) {
544                    qosControl= CSR_GET_UINT16_FROM_LITTLE_ENDIAN(bulkDataDesc->os_data_ptr + 30);
545                }
546                else {
547                    qosControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(bulkDataDesc->os_data_ptr + 24);
548                }
549            }
550
551            priority = (CSR_PRIORITY)(qosControl & IEEE802_11_QC_TID_MASK);
552
553            if (priority < CSR_QOS_UP0 || priority > CSR_QOS_UP7) {
554                unifi_trace(priv, UDBG5, "unifi_reque_ma_packet_request: Invalid priority:%x \n", priority);
555                return CSR_RESULT_FAILURE;
556            }
557        }
558        else {
559            priority = CSR_CONTENTION;
560        }
561
562        /* Frame Bulk data to requeue it back to HAL Queues */
563        bulkData.d[0].os_data_ptr = bulkDataDesc->os_data_ptr;
564        bulkData.d[0].data_length = bulkDataDesc->data_length;
565        bulkData.d[0].os_net_buf_ptr = bulkDataDesc->os_net_buf_ptr;
566        bulkData.d[0].net_buf_length = bulkDataDesc->net_buf_length;
567
568        bulkData.d[1].os_data_ptr = NULL;
569        bulkData.d[1].os_net_buf_ptr = NULL;
570        bulkData.d[1].data_length = bulkData.d[1].net_buf_length = 0;
571
572        /* Initialize signal to zero */
573        memset(&signal, 0, sizeof(CSR_SIGNAL));
574
575        /* Frame MA Packet Req */
576        unifi_frame_ma_packet_req(priv, priority, 0, host_tag,
577                              interfaceTag, CSR_NO_CONFIRM_REQUIRED,
578                              priv->netdev_client->sender_id,
579                              staRecord->peerMacAddress.a, &signal);
580
581        /* Find the Q-Priority */
582        priority_q = unifi_frame_priority_to_queue(priority);
583        list = &staRecord->dataPdu[priority_q];
584
585        /* Place the Packet on to HAL Queue */
586        status = enque_tx_data_pdu(priv, &bulkData, list, &signal, TRUE);
587
588        /* Update the Per-station queued packet counter */
589        if (!status) {
590            spin_lock_irqsave(&priv->staRecord_lock, lock_flags);
591            staRecord->noOfPktQueued++;
592            spin_unlock_irqrestore(&priv->staRecord_lock, lock_flags);
593        }
594    }
595    else {
596        /* Packet will not be re-queued for any of the other MA Packet Tx failure
597         * reasons so just return failure to clear the hip slot
598         */
599        return CSR_RESULT_FAILURE;
600    }
601
602    return status;
603}
604#endif
605
606static void is_all_ac_deliver_enabled_and_moredata(CsrWifiRouterCtrlStaInfo_t *staRecord, u8 *allDeliveryEnabled, u8 *dataAvailable)
607{
608    u8 i;
609    *allDeliveryEnabled = TRUE;
610    for (i = 0 ;i < MAX_ACCESS_CATOGORY; i++) {
611        if (!IS_DELIVERY_ENABLED(staRecord->powersaveMode[i])) {
612            /* One is is not Delivery Enabled */
613            *allDeliveryEnabled = FALSE;
614            break;
615        }
616    }
617    if (*allDeliveryEnabled) {
618        *dataAvailable = (!list_empty(&staRecord->dataPdu[0]) || !list_empty(&staRecord->dataPdu[1])
619                          ||!list_empty(&staRecord->dataPdu[2]) ||!list_empty(&staRecord->dataPdu[3])
620                          ||!list_empty(&staRecord->mgtFrames));
621    }
622}
623
624/*
625 * ---------------------------------------------------------------------------
626 * uf_handle_tim_cfm
627 *
628 *
629 * This function updates tim status in host depending confirm status from firmware
630 *
631 * Arguments:
632 * priv Pointer to device private context struct
633 * cfm CSR_MLME_SET_TIM_CONFIRM
634 * receiverProcessId SenderProcessID to fetch handle & timSet status
635 *
636 * ---------------------------------------------------------------------------
637 */
638void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, u16 receiverProcessId)
639{
640    u8 handle = CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId);
641    u8 timSetStatus = CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId);
642    u16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
643    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
644    CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
645    /* This variable holds what TIM value we wanted to set in firmware */
646    u16 timSetValue = 0;
647    /* Irrespective of interface the count maintained */
648    static u8 retryCount = 0;
649    unsigned long lock_flags;
650    unifi_trace(priv, UDBG3, "entering %s, handle = %x, timSetStatus = %x\n", __FUNCTION__, handle, timSetStatus);
651
652    if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
653        unifi_warning(priv, "bad interfaceTag = %x\n", interfaceTag);
654        return;
655    }
656
657    if ((handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) && (handle >= UNIFI_MAX_CONNECTIONS)) {
658        unifi_warning(priv, "bad station Handle = %x\n", handle);
659        return;
660    }
661
662    if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
663        spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
664        if ((staRecord = ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[handle]))) == NULL) {
665            spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
666            unifi_warning(priv, "uf_handle_tim_cfm: station record is NULL handle = %x\n", handle);
667            return;
668        }
669       spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
670    }
671    switch(timSetStatus)
672    {
673        case CSR_WIFI_TIM_SETTING:
674            timSetValue = CSR_WIFI_TIM_SET;
675            break;
676        case CSR_WIFI_TIM_RESETTING:
677            timSetValue = CSR_WIFI_TIM_RESET;
678            break;
679        default:
680            unifi_warning(priv, "timSet state is %x: Debug\n", timSetStatus);
681            return;
682    }
683
684    /* check TIM confirm for success/failures */
685    switch(cfm->ResultCode)
686    {
687        case CSR_RC_SUCCESS:
688            if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
689                /* Unicast frame & station record available */
690                if (timSetStatus == staRecord->timSet) {
691                    staRecord->timSet = timSetValue;
692                    /* fh_cmd_q can also be full at some point of time!,
693                     * resetting count as queue is cleaned by firmware at this point
694                     */
695                    retryCount = 0;
696                    unifi_trace(priv, UDBG2, "tim (%s) successfully in firmware\n", (timSetValue)?"SET":"RESET");
697                } else {
698                    unifi_trace(priv, UDBG3, "receiver processID = %x, success: request & confirm states are not matching in TIM cfm: Debug status = %x, staRecord->timSet = %x, handle = %x\n",
699                                 receiverProcessId, timSetStatus, staRecord->timSet, handle);
700                }
701
702                /* Reset TIM pending flag to send next TIM request */
703                staRecord->timRequestPendingFlag = FALSE;
704
705                /* Make sure that one more UpdateTim request is queued, if Queued its value
706                 * should be CSR_WIFI_TIM_SET or CSR_WIFI_TIM_RESET
707                 */
708                if (0xFF != staRecord->updateTimReqQueued)
709                {
710                    /* Process the UpdateTim Request which is queued while previous UpdateTim was in progress */
711                    if (staRecord->timSet != staRecord->updateTimReqQueued)
712                    {
713                       unifi_trace(priv, UDBG2, "uf_handle_tim_cfm : Processing Queued UpdateTimReq \n");
714
715                       update_tim(priv, staRecord->aid, staRecord->updateTimReqQueued, interfaceTag, handle);
716
717                       staRecord->updateTimReqQueued = 0xFF;
718                    }
719                }
720            } else {
721
722                interfacePriv->bcTimSet = timSetValue;
723                /* fh_cmd_q can also be full at some point of time!,
724                 * resetting count as queue is cleaned by firmware at this point
725                 */
726                retryCount = 0;
727                unifi_trace(priv, UDBG3, "tim (%s) successfully for broadcast frame in firmware\n", (timSetValue)?"SET":"RESET");
728
729                /* Reset DTIM pending flag to send next DTIM request */
730                interfacePriv->bcTimSetReqPendingFlag = FALSE;
731
732                /* Make sure that one more UpdateDTim request is queued, if Queued its value
733                 * should be CSR_WIFI_TIM_SET or CSR_WIFI_TIM_RESET
734                 */
735                if (0xFF != interfacePriv->bcTimSetReqQueued)
736                {
737                    /* Process the UpdateTim Request which is queued while previous UpdateTim was in progress */
738                    if (interfacePriv->bcTimSet != interfacePriv->bcTimSetReqQueued)
739                    {
740                        unifi_trace(priv, UDBG2, "uf_handle_tim_cfm : Processing Queued UpdateDTimReq \n");
741
742                        update_tim(priv, 0, interfacePriv->bcTimSetReqQueued, interfaceTag, 0xFFFFFFFF);
743
744                        interfacePriv->bcTimSetReqQueued = 0xFF;
745                    }
746                }
747
748            }
749            break;
750        case CSR_RC_INVALID_PARAMETERS:
751        case CSR_RC_INSUFFICIENT_RESOURCE:
752            /* check for max retry limit & send again
753             * MAX_RETRY_LIMIT is not maintained for each set of transactions..Its generic
754             * If failure crosses this Limit, we have to take a call to FIX
755             */
756            if (retryCount > UNIFI_MAX_RETRY_LIMIT) {
757                u8 moreData = FALSE;
758                retryCount = 0;
759                /* Because of continuos traffic in fh_cmd_q the tim set request is failing (exceeding retry limit)
760                 * but if we didn't synchronize our timSet varible state with firmware then it can cause below issues
761                 * cond 1. We want to SET tim in firmware if its fails & max retry limit reached
762                 * -> If host set's the timSet to 1, we wont try to send(as max retry reached) update tim but
763                 * firmware is not updated with queue(TIM) status so it wont set TIM in beacon finally host start piling
764                 * up data & wont try to set tim in firmware (This can cause worser performance)
765                 * cond 2. We want to reset tim in firmware it fails & reaches max retry limit
766                 * -> If host sets the timSet to Zero, it wont try to set a TIM request unless we wont have any packets
767                 * to be queued, so beacon unnecessarily advertizes the TIM
768                 */
769
770                if(staRecord) {
771                    if(!staRecord->wmmOrQosEnabled) {
772                        moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
773                                !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]) ||
774                                !list_empty(&staRecord->mgtFrames));
775                    } else {
776                        /* Peer is QSTA */
777                        u8 allDeliveryEnabled = 0, dataAvailable = 0;
778                        /* Check if all AC's are Delivery Enabled */
779                        is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
780                        /*check for more data in non-delivery enabled queues*/
781                        moreData = (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable));
782
783                    }
784                    /* To avoid cond 1 & 2, check internal Queues status, if we have more Data then set RESET the timSet(0),
785                     * so we are trying to be in sync with firmware & next packets before queuing atleast try to
786                     * set TIM in firmware otherwise it SET timSet(1)
787                     */
788                    if (moreData) {
789                        staRecord->timSet = CSR_WIFI_TIM_RESET;
790                    } else {
791                        staRecord->timSet = CSR_WIFI_TIM_SET;
792                    }
793                } else {
794                    /* Its a broadcast frames */
795                    moreData = (!list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) ||
796                               !list_empty(&interfacePriv->genericMulticastOrBroadCastFrames));
797                    if (moreData) {
798                        update_tim(priv, 0, CSR_WIFI_TIM_SET, interfaceTag, 0xFFFFFFFF);
799                    } else {
800                        update_tim(priv, 0, CSR_WIFI_TIM_RESET, interfaceTag, 0xFFFFFFFF);
801                    }
802                }
803
804                unifi_error(priv, "no of error's for TIM setting crossed the Limit: verify\n");
805                return;
806            }
807            retryCount++;
808
809            if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
810                if (timSetStatus == staRecord->timSet) {
811                    unifi_warning(priv, "tim request failed, retry for AID = %x\n", staRecord->aid);
812                    update_tim(priv, staRecord->aid, timSetValue, interfaceTag, handle);
813                } else {
814                    unifi_trace(priv, UDBG1, "failure: request & confirm states are not matching in TIM cfm: Debug status = %x, staRecord->timSet = %x\n",
815                                  timSetStatus, staRecord->timSet);
816                }
817            } else {
818                unifi_warning(priv, "tim request failed, retry for broadcast frames\n");
819                update_tim(priv, 0, timSetValue, interfaceTag, 0xFFFFFFFF);
820            }
821            break;
822        default:
823            unifi_warning(priv, "tim update request failed resultcode = %x\n", cfm->ResultCode);
824    }
825
826    unifi_trace(priv, UDBG2, "leaving %s\n", __FUNCTION__);
827}
828
829/*
830 * ---------------------------------------------------------------------------
831 * update_tim
832 *
833 *
834 * This function updates tim status in firmware for AID[1 to UNIFI_MAX_CONNECTIONS] or
835 * AID[0] for broadcast/multicast packets.
836 *
837 * NOTE: The LSB (least significant BYTE) of senderId while sending this MLME premitive
838 * has been modified(utilized) as below
839 *
840 * SenderID in signal's SignalPrimitiveHeader is 2 byte the lowe byte bitmap is below
841 *
842 * station handle(6 bits) timSet Status (2 bits)
843 * --------------------- ----------------------
844 * 0 0 0 0 0 0 | 0 0
845 *
846 * timSet Status can be one of below:
847 *
848 * CSR_WIFI_TIM_RESET
849 * CSR_WIFI_TIM_RESETTING
850 * CSR_WIFI_TIM_SET
851 * CSR_WIFI_TIM_SETTING
852 *
853 * Arguments:
854 * priv Pointer to device private context struct
855 * aid can be 1 t0 UNIFI_MAX_CONNECTIONS & 0 means multicast/broadcast
856 * setTim value SET(1) / RESET(0)
857 * interfaceTag the interfaceID on which activity going on
858 * handle from (0 <= handle < UNIFI_MAX_CONNECTIONS)
859 *
860 * ---------------------------------------------------------------------------
861 */
862void update_tim(unifi_priv_t * priv, u16 aid, u8 setTim, u16 interfaceTag, u32 handle)
863{
864    CSR_SIGNAL signal;
865    s32 r;
866    CSR_MLME_SET_TIM_REQUEST *req = &signal.u.MlmeSetTimRequest;
867    bulk_data_param_t *bulkdata = NULL;
868    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
869    u8 senderIdLsb = 0;
870    CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
871    u32 oldTimSetStatus = 0, timSetStatus = 0;
872
873    unifi_trace(priv, UDBG5, "entering the update_tim routine\n");
874
875
876    if (handle == 0xFFFFFFFF) {
877        handle &= CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE;
878        if (setTim == interfacePriv->bcTimSet)
879        {
880            unifi_trace(priv, UDBG3, "update_tim, Drop:Hdl=%x, timval=%d, globalTim=%d\n", handle, setTim, interfacePriv->bcTimSet);
881            return;
882        }
883    } else if ((handle != 0xFFFFFFFF) && (handle >= UNIFI_MAX_CONNECTIONS)) {
884        unifi_warning(priv, "bad station Handle = %x\n", handle);
885        return;
886    }
887
888    if (setTim) {
889        timSetStatus = CSR_WIFI_TIM_SETTING;
890    } else {
891        timSetStatus = CSR_WIFI_TIM_RESETTING;
892    }
893
894    if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
895        if ((staRecord = ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[handle]))) == NULL) {
896            unifi_warning(priv, "station record is NULL in update_tim: handle = %x :debug\n", handle);
897            return;
898        }
899        /* In case of signal sending failed, revert back to old state */
900        oldTimSetStatus = staRecord->timSet;
901        staRecord->timSet = timSetStatus;
902    }
903
904    /* pack senderID LSB */
905    senderIdLsb = CSR_WIFI_PACK_SENDER_ID_LSB_FOR_TIM_REQ(handle, timSetStatus);
906
907    /* initialize signal to zero */
908    memset(&signal, 0, sizeof(CSR_SIGNAL));
909
910    /* Frame the MLME-SET-TIM request */
911    signal.SignalPrimitiveHeader.SignalId = CSR_MLME_SET_TIM_REQUEST_ID;
912    signal.SignalPrimitiveHeader.ReceiverProcessId = 0;
913    CSR_COPY_UINT16_TO_LITTLE_ENDIAN(((priv->netdev_client->sender_id & 0xff00) | senderIdLsb),
914                   (u8*)&signal.SignalPrimitiveHeader.SenderProcessId);
915
916    /* set The virtual interfaceIdentifier, aid, tim value */
917    req->VirtualInterfaceIdentifier = uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag);
918    req->AssociationId = aid;
919    req->TimValue = setTim;
920
921
922    unifi_trace(priv, UDBG2, "update_tim:AID %x,senderIdLsb = 0x%x, handle = 0x%x, timSetStatus = %x, sender proceesID = %x \n",
923                aid,senderIdLsb, handle, timSetStatus, signal.SignalPrimitiveHeader.SenderProcessId);
924
925    /* Send the signal to UniFi */
926    r = ul_send_signal_unpacked(priv, &signal, bulkdata);
927    if (r) {
928        /* No need to free bulk data, as TIM request doesn't carries any data */
929        unifi_error(priv, "Error queueing CSR_MLME_SET_TIM_REQUEST signal\n");
930        if (staRecord) {
931            staRecord->timSet = oldTimSetStatus ;
932        }
933        else
934        {
935            /* MLME_SET_TIM.req sending failed here for AID0, so revert back our bcTimSet status */
936            interfacePriv->bcTimSet = !setTim;
937        }
938    }
939    else {
940        /* Update tim request pending flag and ensure no more TIM set requests are send
941           for the same station until TIM confirm is received */
942        if (staRecord) {
943            staRecord->timRequestPendingFlag = TRUE;
944        }
945        else
946        {
947            /* Update tim request (for AID 0) pending flag and ensure no more DTIM set requests are send
948             * for the same station until TIM confirm is received
949             */
950            interfacePriv->bcTimSetReqPendingFlag = TRUE;
951        }
952    }
953    unifi_trace(priv, UDBG5, "leaving the update_tim routine\n");
954}
955
956static
957void process_peer_active_transition(unifi_priv_t * priv,
958                                    CsrWifiRouterCtrlStaInfo_t *staRecord,
959                                    u16 interfaceTag)
960{
961    int r,i;
962    u8 spaceAvail[4] = {TRUE,TRUE,TRUE,TRUE};
963    tx_buffered_packets_t * buffered_pkt = NULL;
964    unsigned long lock_flags;
965    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
966
967    unifi_trace(priv, UDBG5, "entering process_peer_active_transition\n");
968
969    if(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
970        /* giving more priority to multicast packets so delaying unicast packets*/
971        unifi_trace(priv,UDBG2, "Multicast transmission is going on so resume unicast transmission after DTIM over\n");
972
973        /* As station is active now, even though AP is not able to send frames to it
974         * because of DTIM, it needs to reset the TIM here
975         */
976        if (!staRecord->timRequestPendingFlag){
977            if((staRecord->timSet == CSR_WIFI_TIM_SET) || (staRecord->timSet == CSR_WIFI_TIM_SETTING)){
978                update_tim(priv, staRecord->aid, 0, interfaceTag, staRecord->assignedHandle);
979            }
980        }
981        else
982        {
983            /* Cache the TimSet value so that it will processed immidiatly after
984             * completing the current setTim Request
985             */
986            staRecord->updateTimReqQueued = 0;
987            unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
988                        staRecord->aid);
989        }
990        return;
991    }
992    while((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->mgtFrames))) {
993        buffered_pkt->transmissionControl &=
994                     ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
995        if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,0,FALSE)) == -ENOSPC) {
996            unifi_trace(priv, UDBG2, "p_p_a_t:(ENOSPC) Mgt Frame queueing \n");
997            /* Enqueue at the head of the queue */
998            spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
999            list_add(&buffered_pkt->q, &staRecord->mgtFrames);
1000            spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
1001            priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
1002            spaceAvail[3] = FALSE;
1003            break;
1004        } else {
1005            if(r){
1006                unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
1007                /* the PDU failed where we can't do any thing so free the storage */
1008                unifi_net_data_free(priv, &buffered_pkt->bulkdata);
1009            }
1010            kfree(buffered_pkt);
1011        }
1012    }
1013    if (!staRecord->timRequestPendingFlag) {
1014        if (staRecord->txSuspend) {
1015            if(staRecord->timSet == CSR_WIFI_TIM_SET) {
1016                update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
1017            }
1018            return;
1019        }
1020    }
1021    else
1022    {
1023        /* Cache the TimSet value so that it will processed immidiatly after
1024         * completing the current setTim Request
1025         */
1026        staRecord->updateTimReqQueued = 0;
1027        unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
1028                    staRecord->aid);
1029    }
1030    for(i=3;i>=0;i--) {
1031        if(!spaceAvail[i])
1032            continue;
1033        unifi_trace(priv, UDBG6, "p_p_a_t:data pkt sending for AC %d \n",i);
1034        while((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[i]))) {
1035           buffered_pkt->transmissionControl &=
1036                      ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
1037           if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,0,FALSE)) == -ENOSPC) {
1038               /* Clear the trigger bit transmission control*/
1039               /* Enqueue at the head of the queue */
1040               spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
1041               list_add(&buffered_pkt->q, &staRecord->dataPdu[i]);
1042               spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
1043               priv->pausedStaHandle[i]=(u8)(staRecord->assignedHandle);
1044               break;
1045           } else {
1046              if(r){
1047                  unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
1048                  /* the PDU failed where we can't do any thing so free the storage */
1049                  unifi_net_data_free(priv, &buffered_pkt->bulkdata);
1050               }
1051              kfree(buffered_pkt);
1052           }
1053        }
1054    }
1055    if (!staRecord->timRequestPendingFlag){
1056        if((staRecord->timSet == CSR_WIFI_TIM_SET) || (staRecord->timSet == CSR_WIFI_TIM_SETTING)) {
1057            unifi_trace(priv, UDBG3, "p_p_a_t:resetting tim .....\n");
1058            update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
1059        }
1060    }
1061    else
1062    {
1063        /* Cache the TimSet value so that it will processed immidiatly after
1064         * completing the current setTim Request
1065         */
1066        staRecord->updateTimReqQueued = 0;
1067        unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
1068                    staRecord->aid);
1069    }
1070    unifi_trace(priv, UDBG5, "leaving process_peer_active_transition\n");
1071}
1072
1073
1074
1075void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,u16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm)
1076{
1077    netInterface_priv_t *interfacePriv;
1078    u8 i;
1079    CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
1080    interfacePriv = priv->interfacePriv[interfaceTag];
1081
1082
1083    if(pkt_cfm->HostTag == interfacePriv->multicastPduHostTag) {
1084         unifi_trace(priv,UDBG2,"CFM for marked Multicast Tag = %x\n",interfacePriv->multicastPduHostTag);
1085         interfacePriv->multicastPduHostTag = 0xffffffff;
1086         resume_suspended_uapsd(priv,interfaceTag);
1087         resume_unicast_buffered_frames(priv,interfaceTag);
1088         if(list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) &&
1089              list_empty(&interfacePriv->genericMulticastOrBroadCastFrames)) {
1090            unifi_trace(priv,UDBG1,"Resetting multicastTIM");
1091            if (!interfacePriv->bcTimSetReqPendingFlag)
1092            {
1093                update_tim(priv,0,CSR_WIFI_TIM_RESET,interfaceTag, 0xFFFFFFFF);
1094            }
1095            else
1096            {
1097                /* Cache the DTimSet value so that it will processed immidiatly after
1098                 * completing the current setDTim Request
1099                 */
1100                 interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_RESET;
1101                 unifi_trace(priv, UDBG2, "uf_process_ma_pkt_cfm_for_ap : One more UpdateDTim Request(%d) Queued \n",
1102                             interfacePriv->bcTimSetReqQueued);
1103            }
1104
1105        }
1106        return;
1107    }
1108
1109    /* Check if it is a Confirm for null data frame used
1110     * for probing station activity
1111     */
1112    for(i =0; i < UNIFI_MAX_CONNECTIONS; i++) {
1113        staRecord = (CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[i]);
1114        if (staRecord && (staRecord->nullDataHostTag == pkt_cfm->HostTag)) {
1115
1116            unifi_trace(priv, UDBG1, "CFM for Inactive probe Null frame (tag = %x, status = %d)\n",
1117                                    pkt_cfm->HostTag,
1118                                    pkt_cfm->TransmissionStatus
1119                                    );
1120            staRecord->nullDataHostTag = INVALID_HOST_TAG;
1121
1122            if(pkt_cfm->TransmissionStatus == CSR_TX_RETRY_LIMIT){
1123                CsrTime now;
1124                CsrTime inactive_time;
1125
1126                unifi_trace(priv, UDBG1, "Nulldata to probe STA ALIVE Failed with retry limit\n");
1127                /* Recheck if there is some activity after null data is sent.
1128                *
1129                * If still there is no activity then send a disconnected indication
1130                * to SME to delete the station record.
1131                */
1132                if (staRecord->activity_flag){
1133                    return;
1134                }
1135                now = CsrTimeGet(NULL);
1136
1137                if (staRecord->lastActivity > now)
1138                {
1139                    /* simple timer wrap (for 1 wrap) */
1140                    inactive_time = CsrTimeAdd((CsrTime)CsrTimeSub(CSR_SCHED_TIME_MAX, staRecord->lastActivity),
1141                                               now);
1142                }
1143                else
1144                {
1145                    inactive_time = (CsrTime)CsrTimeSub(now, staRecord->lastActivity);
1146                }
1147
1148                if (inactive_time >= STA_INACTIVE_TIMEOUT_VAL)
1149                {
1150                    struct list_head send_cfm_list;
1151                    u8 j;
1152
1153                    /* The SME/NME may be waiting for confirmation for requested frames to this station.
1154                     * Though this is --VERY UNLIKELY-- in case of station in active mode. But still as a
1155                     * a defensive check, it loops through buffered frames for this station and if confirmation
1156                     * is requested, send auto confirmation with failure status. Also flush the frames so
1157                     * that these are not processed again in PEER_DEL_REQ handler.
1158                     */
1159                    INIT_LIST_HEAD(&send_cfm_list);
1160
1161                    uf_prepare_send_cfm_list_for_queued_pkts(priv,
1162                                                             &send_cfm_list,
1163                                                             &(staRecord->mgtFrames));
1164
1165                    uf_flush_list(priv, &(staRecord->mgtFrames));
1166
1167                    for(j = 0; j < MAX_ACCESS_CATOGORY; j++){
1168                        uf_prepare_send_cfm_list_for_queued_pkts(priv,
1169                                                                 &send_cfm_list,
1170                                                                 &(staRecord->dataPdu[j]));
1171
1172                        uf_flush_list(priv,&(staRecord->dataPdu[j]));
1173                    }
1174
1175                    send_auto_ma_packet_confirm(priv, staRecord->interfacePriv, &send_cfm_list);
1176
1177
1178
1179                    unifi_warning(priv, "uf_process_ma_pkt_cfm_for_ap: Router Disconnected IND Peer (%x-%x-%x-%x-%x-%x)\n",
1180                                             staRecord->peerMacAddress.a[0],
1181                                             staRecord->peerMacAddress.a[1],
1182                                             staRecord->peerMacAddress.a[2],
1183                                             staRecord->peerMacAddress.a[3],
1184                                             staRecord->peerMacAddress.a[4],
1185                                             staRecord->peerMacAddress.a[5]);
1186
1187                    CsrWifiRouterCtrlConnectedIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,
1188                                                      0,
1189                                                      staRecord->interfacePriv->InterfaceTag,
1190                                                      staRecord->peerMacAddress,
1191                                                      CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED);
1192                }
1193
1194            }
1195            else if (pkt_cfm->TransmissionStatus == CSR_TX_SUCCESSFUL)
1196            {
1197                 staRecord->activity_flag = TRUE;
1198            }
1199        }
1200    }
1201}
1202
1203#endif
1204u16 uf_get_vif_identifier (CsrWifiRouterCtrlMode mode, u16 tag)
1205{
1206    switch(mode)
1207    {
1208        case CSR_WIFI_ROUTER_CTRL_MODE_STA:
1209        case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
1210            return (0x02<<8|tag);
1211
1212        case CSR_WIFI_ROUTER_CTRL_MODE_AP:
1213        case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
1214            return (0x03<<8|tag);
1215
1216        case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
1217            return (0x01<<8|tag);
1218
1219        case CSR_WIFI_ROUTER_CTRL_MODE_MONITOR:
1220            return (0x04<<8|tag);
1221        case CSR_WIFI_ROUTER_CTRL_MODE_AMP:
1222            return (0x05<<8|tag);
1223        default:
1224            return tag;
1225    }
1226}
1227
1228#ifdef CSR_SUPPORT_SME
1229
1230/*
1231 * ---------------------------------------------------------------------------
1232 * update_macheader
1233 *
1234 *
1235 * These functions updates mac header for intra BSS packet
1236 * routing.
1237 * NOTE: This function always has to be called in rx context which
1238 * is in bh thread context since GFP_KERNEL is used. In soft IRQ/ Interrupt
1239 * context shouldn't be used
1240 *
1241 * Arguments:
1242 * priv Pointer to device private context struct
1243 * skb Socket buffer containing data packet to transmit
1244 * newSkb Socket buffer containing data packet + Mac header if no sufficient headroom in skb
1245 * priority to append QOS control header in Mac header
1246 * bulkdata if newSkb allocated then bulkdata updated to send to unifi
1247 * interfaceTag the interfaceID on which activity going on
1248 * macHeaderLengthInBytes no. of bytes of mac header in received frame
1249 * qosDestination used to append Qos control field
1250 *
1251 * Returns:
1252 * Zero on success or -1 on error.
1253 * ---------------------------------------------------------------------------
1254 */
1255
1256static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
1257                            struct sk_buff *newSkb, CSR_PRIORITY *priority,
1258                            bulk_data_param_t *bulkdata, u16 interfaceTag,
1259                            u8 macHeaderLengthInBytes,
1260                            u8 qosDestination)
1261{
1262
1263    u16 *fc = NULL;
1264    u8 direction = 0, toDs, fromDs;
1265    u8 *bufPtr = NULL;
1266    u8 sa[ETH_ALEN], da[ETH_ALEN];
1267    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
1268    int headroom;
1269    u8 macHeaderBuf[IEEE802_11_DATA_FRAME_MAC_HEADER_SIZE] = {0};
1270
1271    unifi_trace(priv, UDBG5, "entering the update_macheader function\n");
1272
1273    /* temporary buffer for the Mac header storage */
1274    memcpy(macHeaderBuf, skb->data, macHeaderLengthInBytes);
1275
1276    /* remove the Macheader from the skb */
1277    skb_pull(skb, macHeaderLengthInBytes);
1278
1279    /* get the skb headroom for skb_push check */
1280    headroom = skb_headroom(skb);
1281
1282    /* pointer to frame control field */
1283    fc = (u16*) macHeaderBuf;
1284
1285    toDs = (*fc & cpu_to_le16(IEEE802_11_FC_TO_DS_MASK))?1 : 0;
1286    fromDs = (*fc & cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK))? 1: 0;
1287    unifi_trace(priv, UDBG5, "In update_macheader function, fromDs = %x, toDs = %x\n", fromDs, toDs);
1288    direction = ((fromDs | (toDs << 1)) & 0x3);
1289
1290    /* Address1 or 3 from the macheader */
1291    memcpy(da, macHeaderBuf+4+toDs*12, ETH_ALEN);
1292    /* Address2, 3 or 4 from the mac header */
1293    memcpy(sa, macHeaderBuf+10+fromDs*(6+toDs*8), ETH_ALEN);
1294
1295    unifi_trace(priv, UDBG3, "update_macheader:direction = %x\n", direction);
1296    /* update the toDs, fromDs & address fields in Mac header */
1297    switch(direction)
1298    {
1299        case 2:
1300            /* toDs = 1 & fromDs = 0 , toAp when frames received from peer
1301             * while sending this packet to Destination the Mac header changed
1302             * as fromDs = 1 & toDs = 0, fromAp
1303             */
1304            *fc &= cpu_to_le16(~IEEE802_11_FC_TO_DS_MASK);
1305            *fc |= cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK);
1306            /* Address1: MAC address of the actual destination (4 = 2+2) */
1307            memcpy(macHeaderBuf + 4, da, ETH_ALEN);
1308            /* Address2: The MAC address of the AP (10 = 2+2+6) */
1309            memcpy(macHeaderBuf + 10, &interfacePriv->bssid, ETH_ALEN);
1310            /* Address3: MAC address of the actual source from mac header (16 = 2+2+6+6) */
1311            memcpy(macHeaderBuf + 16, sa, ETH_ALEN);
1312            break;
1313        case 3:
1314            unifi_trace(priv, UDBG3, "when both the toDs & fromDS set, NOT SUPPORTED\n");
1315            break;
1316        default:
1317            unifi_trace(priv, UDBG3, "problem in decoding packet in update_macheader \n");
1318            return -1;
1319    }
1320
1321    /* frameType is Data always, Validation is done before calling this function */
1322
1323    /* check for the souce station type */
1324    switch(le16_to_cpu(*fc) & IEEE80211_FC_SUBTYPE_MASK)
1325    {
1326        case IEEE802_11_FC_TYPE_QOS_DATA & IEEE80211_FC_SUBTYPE_MASK:
1327            /* No need to modify the qos control field */
1328            if (!qosDestination) {
1329
1330                /* If source Sta is QOS enabled & if this bit set, then HTC is supported by
1331                 * peer station & htc field present in macHeader
1332                 */
1333                if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
1334                    /* HT control field present in Mac header
1335                     * 6 = sizeof(qosControl) + sizeof(htc)
1336                     */
1337                    macHeaderLengthInBytes -= 6;
1338                } else {
1339                    macHeaderLengthInBytes -= 2;
1340                }
1341                /* Destination STA is non qos so change subtype to DATA */
1342                *fc &= cpu_to_le16(~IEEE80211_FC_SUBTYPE_MASK);
1343                *fc |= cpu_to_le16(IEEE802_11_FC_TYPE_DATA);
1344                /* remove the qos control field & HTC(if present). new macHeaderLengthInBytes is less than old
1345                 * macHeaderLengthInBytes so no need to verify skb headroom
1346                 */
1347                if (headroom < macHeaderLengthInBytes) {
1348                    unifi_trace(priv, UDBG1, " sufficient headroom not there to push updated mac header \n");
1349                    return -1;
1350                }
1351                bufPtr = (u8 *) skb_push(skb, macHeaderLengthInBytes);
1352
1353                /* update bulk data os_data_ptr */
1354                bulkdata->d[0].os_data_ptr = skb->data;
1355                bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
1356                bulkdata->d[0].data_length = skb->len;
1357
1358            } else {
1359                /* pointing to QOS control field */
1360                u8 qc;
1361                if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
1362                    qc = *((u8*)(macHeaderBuf + (macHeaderLengthInBytes - 4 - 2)));
1363                } else {
1364                    qc = *((u8*)(macHeaderBuf + (macHeaderLengthInBytes - 2)));
1365                }
1366
1367                if ((qc & IEEE802_11_QC_TID_MASK) > 7) {
1368                    *priority = 7;
1369                } else {
1370                    *priority = qc & IEEE802_11_QC_TID_MASK;
1371                }
1372
1373                unifi_trace(priv, UDBG1, "Incoming packet priority from QSTA is %x\n", *priority);
1374
1375                if (headroom < macHeaderLengthInBytes) {
1376                    unifi_trace(priv, UDBG3, " sufficient headroom not there to push updated mac header \n");
1377                    return -1;
1378                }
1379                bufPtr = (u8 *) skb_push(skb, macHeaderLengthInBytes);
1380            }
1381            break;
1382        default:
1383            {
1384                bulk_data_param_t data_ptrs;
1385                CsrResult csrResult;
1386                unifi_trace(priv, UDBG5, "normal Data packet, NO QOS \n");
1387
1388                if (qosDestination) {
1389                    u8 qc = 0;
1390                    unifi_trace(priv, UDBG3, "destination is QOS station \n");
1391
1392                    /* Set Ma-Packet.req UP to UP0 */
1393                    *priority = CSR_QOS_UP0;
1394
1395                    /* prepare the qos control field */
1396                    qc |= CSR_QOS_UP0;
1397                    /* no Amsdu is in ap buffer so eosp is left 0 */
1398                    if (da[0] & 0x1) {
1399                        /* multicast/broadcast frames, no acknowledgement needed */
1400                        qc |= 1 << 5;
1401                    }
1402
1403                    /* update new Mac header Length with 2 = sizeof(qos control) */
1404                    macHeaderLengthInBytes += 2;
1405
1406                    /* received DATA frame but destiantion is QOS station so update subtype to QOS*/
1407                    *fc &= cpu_to_le16(~IEEE80211_FC_SUBTYPE_MASK);
1408                    *fc |= cpu_to_le16(IEEE802_11_FC_TYPE_QOS_DATA);
1409
1410                    /* appendQosControlOffset = macHeaderLengthInBytes - 2, since source sta is not QOS */
1411                    macHeaderBuf[macHeaderLengthInBytes - 2] = qc;
1412                    /* txopLimit is 0 */
1413                    macHeaderBuf[macHeaderLengthInBytes - 1] = 0;
1414                    if (headroom < macHeaderLengthInBytes) {
1415                        csrResult = unifi_net_data_malloc(priv, &data_ptrs.d[0], skb->len + macHeaderLengthInBytes);
1416
1417                        if (csrResult != CSR_RESULT_SUCCESS) {
1418                            unifi_error(priv, " failed to allocate request_data. in update_macheader func\n");
1419                            return -1;
1420                        }
1421                        newSkb = (struct sk_buff *)(data_ptrs.d[0].os_net_buf_ptr);
1422                        newSkb->len = skb->len + macHeaderLengthInBytes;
1423
1424                        memcpy((void*)data_ptrs.d[0].os_data_ptr + macHeaderLengthInBytes,
1425                                skb->data, skb->len);
1426
1427                        bulkdata->d[0].os_data_ptr = newSkb->data;
1428                        bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
1429                        bulkdata->d[0].data_length = newSkb->len;
1430
1431                        bufPtr = (u8*)data_ptrs.d[0].os_data_ptr;
1432
1433                        /* The old skb will not be used again */
1434                        kfree_skb(skb);
1435                    } else {
1436                        /* skb headroom is sufficient to append Macheader */
1437                        bufPtr = (u8*)skb_push(skb, macHeaderLengthInBytes);
1438                        bulkdata->d[0].os_data_ptr = skb->data;
1439                        bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
1440                        bulkdata->d[0].data_length = skb->len;
1441                    }
1442                } else {
1443                    unifi_trace(priv, UDBG3, "destination is not a QSTA\n");
1444                    if (headroom < macHeaderLengthInBytes) {
1445                        csrResult = unifi_net_data_malloc(priv, &data_ptrs.d[0], skb->len + macHeaderLengthInBytes);
1446
1447                        if (csrResult != CSR_RESULT_SUCCESS) {
1448                            unifi_error(priv, " failed to allocate request_data. in update_macheader func\n");
1449                            return -1;
1450                        }
1451                        newSkb = (struct sk_buff *)(data_ptrs.d[0].os_net_buf_ptr);
1452                        newSkb->len = skb->len + macHeaderLengthInBytes;
1453
1454                        memcpy((void*)data_ptrs.d[0].os_data_ptr + macHeaderLengthInBytes,
1455                                skb->data, skb->len);
1456
1457                        bulkdata->d[0].os_data_ptr = newSkb->data;
1458                        bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
1459                        bulkdata->d[0].data_length = newSkb->len;
1460
1461                        bufPtr = (u8*)data_ptrs.d[0].os_data_ptr;
1462
1463                        /* The old skb will not be used again */
1464                        kfree_skb(skb);
1465                    } else {
1466                        /* skb headroom is sufficient to append Macheader */
1467                        bufPtr = (u8*)skb_push(skb, macHeaderLengthInBytes);
1468                        bulkdata->d[0].os_data_ptr = skb->data;
1469                        bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
1470                        bulkdata->d[0].data_length = skb->len;
1471                    }
1472                }
1473            }
1474    }
1475
1476    /* prepare the complete skb, by pushing the MAC header to the begining of the skb->data */
1477    unifi_trace(priv, UDBG5, "updated Mac Header: %d \n",macHeaderLengthInBytes);
1478    memcpy(bufPtr, macHeaderBuf, macHeaderLengthInBytes);
1479
1480    unifi_trace(priv, UDBG5, "leaving the update_macheader function\n");
1481    return 0;
1482}
1483/*
1484 * ---------------------------------------------------------------------------
1485 * uf_ap_process_data_pdu
1486 *
1487 *
1488 * Takes care of intra BSS admission control & routing packets within BSS
1489 *
1490 * Arguments:
1491 * priv Pointer to device private context struct
1492 * skb Socket buffer containing data packet to transmit
1493 * ehdr ethernet header to fetch priority of packet
1494 * srcStaInfo source stations record for connection verification
1495 * packed_signal
1496 * signal_len
1497 * signal MA-PACKET.indication signal
1498 * bulkdata if newSkb allocated then bulkdata updated to send to unifi
1499 * macHeaderLengthInBytes no. of bytes of mac header in received frame
1500 *
1501 * Returns:
1502 * Zero on success(ap processing complete) or -1 if packet also have to be sent to NETDEV.
1503 * ---------------------------------------------------------------------------
1504 */
1505int
1506uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
1507                       struct ethhdr *ehdr, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
1508                       const CSR_SIGNAL *signal,
1509                       bulk_data_param_t *bulkdata,
1510                       u8 macHeaderLengthInBytes)
1511{
1512    const CSR_MA_PACKET_INDICATION *ind = &(signal->u.MaPacketIndication);
1513    u16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0x00ff);
1514    struct sk_buff *newSkb = NULL;
1515    /* pointer to skb or private skb created using skb_copy() */
1516    struct sk_buff *skbPtr = skb;
1517    u8 sendToNetdev = FALSE;
1518    u8 qosDestination = FALSE;
1519    CSR_PRIORITY priority = CSR_CONTENTION;
1520    CsrWifiRouterCtrlStaInfo_t *dstStaInfo = NULL;
1521    netInterface_priv_t *interfacePriv;
1522
1523    unifi_trace(priv, UDBG5, "entering uf_ap_process_data_pdu %d\n",macHeaderLengthInBytes);
1524    /* InterfaceTag validation from MA_PACKET.indication */
1525    if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
1526        unifi_trace(priv, UDBG1, "Interface Tag is Invalid in uf_ap_process_data_pdu\n");
1527        unifi_net_data_free(priv, &bulkdata->d[0]);
1528        return 0;
1529    }
1530    interfacePriv = priv->interfacePriv[interfaceTag];
1531
1532    if((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) &&
1533       (interfacePriv->intraBssEnabled == FALSE)) {
1534        unifi_trace(priv, UDBG2, "uf_ap_process_data_pdu:P2P GO intrabssEnabled?= %d\n", interfacePriv->intraBssEnabled);
1535
1536        /*In P2P GO case, if intraBSS distribution Disabled then don't do IntraBSS routing */
1537        /* If destination in our BSS then drop otherwise give packet to netdev */
1538        dstStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, ehdr->h_dest, interfaceTag);
1539        if (dstStaInfo) {
1540            unifi_net_data_free(priv, &bulkdata->d[0]);
1541            return 0;
1542        }
1543        /* May be associated P2PCLI trying to send the packets on backbone (Netdev) */
1544        return -1;
1545    }
1546
1547    if(!memcmp(ehdr->h_dest, interfacePriv->bssid.a, ETH_ALEN)) {
1548        /* This packet will be given to the TCP/IP stack since this packet is for us(AP)
1549         * No routing needed */
1550        unifi_trace(priv, UDBG4, "destination address is csr_ap\n");
1551        return -1;
1552    }
1553
1554    /* fetch the destination record from staion record database */
1555    dstStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, ehdr->h_dest, interfaceTag);
1556
1557    /* AP mode processing, & if packet is unicast */
1558    if(!dstStaInfo) {
1559        if (!(ehdr->h_dest[0] & 0x1)) {
1560            /* destination not in station record & its a unicast packet, so pass the packet to network stack */
1561            unifi_trace(priv, UDBG3, "unicast frame & destination record not exist, send to netdev proto = %x\n", htons(skb->protocol));
1562            return -1;
1563        } else {
1564            /* packet is multicast/broadcast */
1565            /* copy the skb to skbPtr, send skb to netdev & skbPtr to multicast/broad cast list */
1566            unifi_trace(priv, UDBG5, "skb_copy, in uf_ap_process_data_pdu, protocol = %x\n", htons(skb->protocol));
1567            skbPtr = skb_copy(skb, GFP_KERNEL);
1568            if(skbPtr == NULL) {
1569                /* We don't have memory to don't send the frame in BSS*/
1570                unifi_notice(priv, "broacast/multicast frame can't be sent in BSS No memeory: proto = %x\n", htons(skb->protocol));
1571                return -1;
1572            }
1573            sendToNetdev = TRUE;
1574        }
1575    } else {
1576
1577        /* validate the Peer & Destination Station record */
1578        if (uf_process_station_records_for_sending_data(priv, interfaceTag, srcStaInfo, dstStaInfo)) {
1579            unifi_notice(priv, "uf_ap_process_data_pdu: station record validation failed \n");
1580            interfacePriv->stats.rx_errors++;
1581            unifi_net_data_free(priv, &bulkdata->d[0]);
1582            return 0;
1583        }
1584    }
1585
1586    /* BroadCast packet received and it's been sent as non QOS packets.
1587     * Since WMM spec not mandates broadcast/multicast to be sent as QOS data only,
1588     * if all Peers are QSTA
1589     */
1590    if(sendToNetdev) {
1591       /* BroadCast packet and it's been sent as non QOS packets */
1592        qosDestination = FALSE;
1593    } else if(dstStaInfo && (dstStaInfo->wmmOrQosEnabled == TRUE)) {
1594          qosDestination = TRUE;
1595    }
1596
1597    unifi_trace(priv, UDBG3, "uf_ap_process_data_pdu QoS destination = %s\n", (qosDestination)? "TRUE": "FALSE");
1598
1599    /* packet is allowed to send to unifi, update the Mac header */
1600    if (update_macheader(priv, skbPtr, newSkb, &priority, bulkdata, interfaceTag, macHeaderLengthInBytes, qosDestination)) {
1601        interfacePriv->stats.rx_errors++;
1602        unifi_notice(priv, "(Packet Drop) failed to update the Mac header in uf_ap_process_data_pdu\n");
1603        if (sendToNetdev) {
1604            /* Free's the skb_copy(skbPtr) data since packet processing failed */
1605            bulkdata->d[0].os_data_ptr = skbPtr->data;
1606            bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skbPtr;
1607            bulkdata->d[0].data_length = skbPtr->len;
1608            unifi_net_data_free(priv, &bulkdata->d[0]);
1609        }
1610        return -1;
1611    }
1612
1613    unifi_trace(priv, UDBG3, "Mac Header updated...calling uf_process_ma_packet_req \n");
1614
1615    /* Packet is ready to send to unifi ,transmissionControl = 0x0004, confirmation is not needed for data packets */
1616    if (uf_process_ma_packet_req(priv, ehdr->h_dest, 0xffffffff, interfaceTag, CSR_NO_CONFIRM_REQUIRED, (CSR_RATE)0,priority, priv->netdev_client->sender_id, bulkdata)) {
1617        if (sendToNetdev) {
1618            unifi_trace(priv, UDBG1, "In uf_ap_process_data_pdu, (Packet Drop) uf_process_ma_packet_req failed. freeing skb_copy data (original data sent to Netdev)\n");
1619            /* Free's the skb_copy(skbPtr) data since packet processing failed */
1620            bulkdata->d[0].os_data_ptr = skbPtr->data;
1621            bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skbPtr;
1622            bulkdata->d[0].data_length = skbPtr->len;
1623            unifi_net_data_free(priv, &bulkdata->d[0]);
1624        } else {
1625            /* This free's the skb data */
1626            unifi_trace(priv, UDBG1, "In uf_ap_process_data_pdu, (Packet Drop). Unicast data so freeing original skb \n");
1627            unifi_net_data_free(priv, &bulkdata->d[0]);
1628        }
1629    }
1630    unifi_trace(priv, UDBG5, "leaving uf_ap_process_data_pdu\n");
1631
1632    if (sendToNetdev) {
1633        /* The packet is multicast/broadcast, so after AP processing packet has to
1634         * be sent to netdev, if peer port state is open
1635        */
1636        unifi_trace(priv, UDBG4, "Packet will be routed to NetDev\n");
1637        return -1;
1638    }
1639    /* Ap handled the packet & its a unicast packet, no need to send to netdev */
1640    return 0;
1641}
1642
1643#endif
1644
1645CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
1646                                   u8 *peerMacAddress,
1647                                   CSR_CLIENT_TAG hostTag,
1648                                   u16 interfaceTag,
1649                                   CSR_TRANSMISSION_CONTROL transmissionControl,
1650                                   CSR_RATE TransmitRate,
1651                                   CSR_PRIORITY priority,
1652                                   CSR_PROCESS_ID leSenderProcessId,
1653                                   bulk_data_param_t *bulkdata)
1654{
1655    CsrResult status = CSR_RESULT_SUCCESS;
1656    CSR_SIGNAL signal;
1657    int result;
1658#ifdef CSR_SUPPORT_SME
1659   CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
1660    const u8 *macHdrLocation = bulkdata->d[0].os_data_ptr;
1661    CsrWifiPacketType pktType;
1662    int frameType = 0;
1663    u8 queuePacketDozing = FALSE;
1664    u32 priority_q;
1665    u16 frmCtrl;
1666    struct list_head * list = NULL; /* List to which buffered PDUs are to be enqueued*/
1667    u8 setBcTim=FALSE;
1668    netInterface_priv_t *interfacePriv;
1669    u8 requeueOnSamePos = FALSE;
1670    u32 handle = 0xFFFFFFFF;
1671    unsigned long lock_flags;
1672
1673    unifi_trace(priv, UDBG5,
1674        "entering uf_process_ma_packet_req, peer: %pMF\n",
1675        peerMacAddress);
1676
1677    if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
1678        unifi_error(priv, "interfaceTag >= CSR_WIFI_NUM_INTERFACES, interfacetag = %d\n", interfaceTag);
1679        return CSR_RESULT_FAILURE;
1680    }
1681    interfacePriv = priv->interfacePriv[interfaceTag];
1682
1683
1684    /* fetch the station record for corresponding peer mac address */
1685    if ((staRecord = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, peerMacAddress, interfaceTag))) {
1686        handle = staRecord->assignedHandle;
1687    }
1688
1689    /* Frame ma-packet.req, this is saved/transmitted depend on queue state */
1690    unifi_frame_ma_packet_req(priv, priority, TransmitRate, hostTag,
1691                              interfaceTag, transmissionControl, leSenderProcessId,
1692                              peerMacAddress, &signal);
1693
1694   /* Since it's common path between STA & AP mode, in case of STA packet
1695     * need not to be queued but in AP case we have to queue PDU's in
1696     * different scenarios
1697     */
1698    switch(interfacePriv->interfaceMode)
1699    {
1700        case CSR_WIFI_ROUTER_CTRL_MODE_AP:
1701        case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
1702            /* For this mode processing done below */
1703            break;
1704        default:
1705            /* In case of STA/IBSS/P2PCLI/AMP, no checks needed send the packet down & return */
1706            unifi_trace(priv, UDBG5, "In %s, interface mode is %x \n", __FUNCTION__, interfacePriv->interfaceMode);
1707            if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_NONE) {
1708                unifi_warning(priv, "In %s, interface mode NONE \n", __FUNCTION__);
1709            }
1710            if ((result = ul_send_signal_unpacked(priv, &signal, bulkdata))) {
1711                status = CSR_RESULT_FAILURE;
1712            }
1713            return status;
1714    }
1715
1716    /* -----Only AP/P2pGO mode handling falls below----- */
1717
1718    /* convert priority to queue */
1719    priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
1720
1721    /* check the powersave status of the peer */
1722    if (staRecord && (staRecord->currentPeerState ==
1723                     CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)) {
1724        /* Peer is dozing & packet have to be delivered, so buffer the packet &
1725         * update the TIM
1726         */
1727        queuePacketDozing = TRUE;
1728    }
1729
1730    /* find the type of frame unicast or mulicast/broadcast */
1731    if (*peerMacAddress & 0x1) {
1732        /* Multicast/broadCast data are always triggered by vif_availability.ind
1733         * at the DTIM
1734         */
1735        pktType = CSR_WIFI_MULTICAST_PDU;
1736    } else {
1737        pktType = CSR_WIFI_UNICAST_PDU;
1738    }
1739
1740    /* Fetch the frame control field from mac header & check for frame type */
1741    frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation);
1742
1743    /* Processing done according to Frame/Packet type */
1744    frameType = ((frmCtrl & 0x000c) >> FRAME_CONTROL_TYPE_FIELD_OFFSET);
1745    switch(frameType)
1746    {
1747        case IEEE802_11_FRAMETYPE_MANAGEMENT:
1748
1749            switch(pktType)
1750            {
1751                case CSR_WIFI_UNICAST_PDU:
1752                    unifi_trace(priv, UDBG5, "management unicast PDU in uf_process_ma_packet_req \n");
1753                    /* push the packet in to the queue with appropriate mgt list */
1754                    if (!staRecord) {
1755                        /* push the packet to the unifi if list is empty (if packet lost how to re-enque) */
1756                        if (list_empty(&interfacePriv->genericMgtFrames)) {
1757#ifdef CSR_SUPPORT_SME
1758                            if(!(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
1759#endif
1760
1761                            unifi_trace(priv, UDBG3, "genericMgtFrames list is empty uf_process_ma_packet_req \n");
1762                            result = ul_send_signal_unpacked(priv, &signal, bulkdata);
1763                            /* reque only on ENOSPC */
1764                            if(result == -ENOSPC) {
1765                                /* requeue the failed packet to genericMgtFrame with same position */
1766                                unifi_trace(priv, UDBG1, "(ENOSPC) Sending genericMgtFrames Failed so buffering\n");
1767                                list = &interfacePriv->genericMgtFrames;
1768                                requeueOnSamePos = TRUE;
1769                            }
1770#ifdef CSR_SUPPORT_SME
1771                            }else{
1772                                list = &interfacePriv->genericMgtFrames;
1773                                unifi_trace(priv, UDBG3, "genericMgtFrames queue empty and dtim started\n hosttag is 0x%x,\n",signal.u.MaPacketRequest.HostTag);
1774                                update_eosp_to_head_of_broadcast_list_head(priv,interfaceTag);
1775                           }
1776#endif
1777                        } else {
1778                            /* Queue the packet to genericMgtFrame of unifi_priv_t data structure */
1779                            list = &interfacePriv->genericMgtFrames;
1780                            unifi_trace(priv, UDBG2, "genericMgtFrames queue not empty\n");
1781                        }
1782                    } else {
1783                        /* check peer power state */
1784                        if (queuePacketDozing || !list_empty(&staRecord->mgtFrames) || IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
1785                            /* peer is in dozing mode, so queue packet in mgt frame list of station record */
1786                           /*if multicast traffic is going on, buffer the unicast packets*/
1787                            list = &staRecord->mgtFrames;
1788
1789                            unifi_trace(priv, UDBG1, "staRecord->MgtFrames list empty? = %s, handle = %d, queuePacketDozing = %d\n",
1790                                        (list_empty(&staRecord->mgtFrames))? "YES": "NO", staRecord->assignedHandle, queuePacketDozing);
1791                            if(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)){
1792                                update_eosp_to_head_of_broadcast_list_head(priv,interfaceTag);
1793                            }
1794
1795                        } else {
1796                            unifi_trace(priv, UDBG5, "staRecord->mgtFrames list is empty uf_process_ma_packet_req \n");
1797                            result = ul_send_signal_unpacked(priv, &signal, bulkdata);
1798                            if(result == -ENOSPC) {
1799                                /* requeue the failed packet to staRecord->mgtFrames with same position */
1800                                list = &staRecord->mgtFrames;
1801                                requeueOnSamePos = TRUE;
1802                                unifi_trace(priv, UDBG1, "(ENOSPC) Sending MgtFrames Failed handle = %d so buffering\n",staRecord->assignedHandle);
1803                                priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
1804                            } else if (result) {
1805                                status = CSR_RESULT_FAILURE;
1806                            }
1807                        }
1808                    }
1809                    break;
1810                case CSR_WIFI_MULTICAST_PDU:
1811                    unifi_trace(priv, UDBG5, "management multicast/broadcast PDU in uf_process_ma_packet_req 'QUEUE it' \n");
1812                    /* Queue the packet to genericMulticastOrBroadCastMgtFrames of unifi_priv_t data structure
1813                     * will be sent when we receive VIF AVAILABILITY from firmware as part of DTIM
1814                     */
1815
1816                    list = &interfacePriv->genericMulticastOrBroadCastMgtFrames;
1817                    if((interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_IBSS) &&
1818                            (list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames))) {
1819                        setBcTim=TRUE;
1820                    }
1821                    break;
1822                default:
1823                    unifi_error(priv, "condition never meets: packet type unrecognized\n");
1824            }
1825            break;
1826        case IEEE802_11_FRAMETYPE_DATA:
1827            switch(pktType)
1828            {
1829                case CSR_WIFI_UNICAST_PDU:
1830                    unifi_trace(priv, UDBG5, "data unicast PDU in uf_process_ma_packet_req \n");
1831                    /* check peer power state, list status & peer port status */
1832                    if(!staRecord) {
1833                        unifi_error(priv, "In %s unicast but staRecord = NULL\n", __FUNCTION__);
1834                        return CSR_RESULT_FAILURE;
1835                    } else if (queuePacketDozing || isRouterBufferEnabled(priv,priority_q)|| !list_empty(&staRecord->dataPdu[priority_q]) || IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
1836                        /* peer is in dozing mode, so queue packet in mgt frame list of station record */
1837                        /* if multicast traffic is going on, buffet the unicast packets */
1838                        unifi_trace(priv, UDBG2, "Enqueued to staRecord->dataPdu[%d] queuePacketDozing=%d,\
1839                                Buffering enabled = %d \n", priority_q,queuePacketDozing,isRouterBufferEnabled(priv,priority_q));
1840                        list = &staRecord->dataPdu[priority_q];
1841                    } else {
1842                        unifi_trace(priv, UDBG5, "staRecord->dataPdu[%d] list is empty uf_process_ma_packet_req \n", priority_q);
1843                        /* Pdu allowed to send to unifi */
1844                        result = ul_send_signal_unpacked(priv, &signal, bulkdata);
1845                        if(result == -ENOSPC) {
1846                            /* requeue the failed packet to staRecord->dataPdu[priority_q] with same position */
1847                            unifi_trace(priv, UDBG1, "(ENOSPC) Sending Unicast DataPDU to queue %d Failed so buffering\n",priority_q);
1848                            requeueOnSamePos = TRUE;
1849                            list = &staRecord->dataPdu[priority_q];
1850                            priv->pausedStaHandle[priority_q]=(u8)(staRecord->assignedHandle);
1851                            if(!isRouterBufferEnabled(priv,priority_q)) {
1852                                unifi_error(priv,"Buffering Not enabled for queue %d \n",priority_q);
1853                            }
1854                        } else if (result) {
1855                            status = CSR_RESULT_FAILURE;
1856                        }
1857                    }
1858                    break;
1859                case CSR_WIFI_MULTICAST_PDU:
1860                    unifi_trace(priv, UDBG5, "data multicast/broadcast PDU in uf_process_ma_packet_req \n");
1861                    /* Queue the packet to genericMulticastOrBroadCastFrames list of unifi_priv_t data structure
1862                     * will be sent when we receive VIF AVAILABILITY from firmware as part of DTIM
1863                     */
1864                    list = &interfacePriv->genericMulticastOrBroadCastFrames;
1865                    if(list_empty(&interfacePriv->genericMulticastOrBroadCastFrames)) {
1866                        setBcTim = TRUE;
1867                    }
1868                    break;
1869                default:
1870                    unifi_error(priv, "condition never meets: packet type un recognized\n");
1871            }
1872            break;
1873        default:
1874            unifi_error(priv, "unrecognized frame type\n");
1875    }
1876    if(list) {
1877        status = enque_tx_data_pdu(priv, bulkdata,list, &signal,requeueOnSamePos);
1878        /* Record no. of packet queued for each peer */
1879        if (staRecord && (pktType == CSR_WIFI_UNICAST_PDU) && (!status)) {
1880            spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
1881            staRecord->noOfPktQueued++;
1882            spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
1883        }
1884        else if ((pktType == CSR_WIFI_MULTICAST_PDU) && (!status))
1885        {
1886            /* If broadcast Tim is set && queuing is successfull, then only update TIM */
1887            spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
1888            interfacePriv->noOfbroadcastPktQueued++;
1889            spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
1890        }
1891    }
1892    /* If broadcast Tim is set && queuing is successfull, then only update TIM */
1893    if(setBcTim && !status) {
1894        unifi_trace(priv, UDBG3, "tim set due to broadcast pkt\n");
1895        if (!interfacePriv->bcTimSetReqPendingFlag)
1896        {
1897            update_tim(priv,0,CSR_WIFI_TIM_SET,interfaceTag, handle);
1898        }
1899        else
1900        {
1901            /* Cache the TimSet value so that it will processed immidiatly after
1902            * completing the current setTim Request
1903            */
1904            interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_SET;
1905            unifi_trace(priv, UDBG2, "uf_process_ma_packet_req : One more UpdateDTim Request(:%d) Queued \n",
1906                        interfacePriv->bcTimSetReqQueued);
1907        }
1908    } else if(staRecord && staRecord->currentPeerState ==
1909                            CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE) {
1910        if(staRecord->timSet == CSR_WIFI_TIM_RESET || staRecord->timSet == CSR_WIFI_TIM_RESETTING) {
1911            if(!staRecord->wmmOrQosEnabled) {
1912                if(!list_empty(&staRecord->mgtFrames) ||
1913                   !list_empty(&staRecord->dataPdu[3]) ||
1914                   !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION])) {
1915                    unifi_trace(priv, UDBG3, "tim set due to unicast pkt & peer in powersave\n");
1916                    if (!staRecord->timRequestPendingFlag){
1917                        update_tim(priv,staRecord->aid,1,interfaceTag, handle);
1918                    }
1919                    else
1920                    {
1921                        /* Cache the TimSet value so that it will processed immidiatly after
1922                         * completing the current setTim Request
1923                         */
1924                        staRecord->updateTimReqQueued = 1;
1925                        unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
1926                                    staRecord->aid);
1927                    }
1928                }
1929            } else {
1930                /* Check for non delivery enable(i.e trigger enable), all delivery enable & legacy AC for TIM update in firmware */
1931                u8 allDeliveryEnabled = 0, dataAvailable = 0;
1932                /* Check if all AC's are Delivery Enabled */
1933                is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
1934                if (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable)
1935                    || (!list_empty(&staRecord->mgtFrames))) {
1936                    if (!staRecord->timRequestPendingFlag) {
1937                        update_tim(priv,staRecord->aid,1,interfaceTag, handle);
1938                    }
1939                    else
1940                    {
1941                        /* Cache the TimSet value so that it will processed immidiatly after
1942                         * completing the current setTim Request
1943                         */
1944                        staRecord->updateTimReqQueued = 1;
1945                        unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
1946                                    staRecord->aid);
1947                    }
1948                }
1949            }
1950        }
1951    }
1952
1953    if((list) && (pktType == CSR_WIFI_UNICAST_PDU && !queuePacketDozing) && !(isRouterBufferEnabled(priv,priority_q)) && !(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
1954        unifi_trace(priv, UDBG2, "buffering cleared for queue = %d So resending buffered frames\n",priority_q);
1955        uf_send_buffered_frames(priv, priority_q);
1956    }
1957    unifi_trace(priv, UDBG5, "leaving uf_process_ma_packet_req \n");
1958    return status;
1959#else
1960#ifdef CSR_NATIVE_LINUX
1961    if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
1962        unifi_error(priv, "interfaceTag >= CSR_WIFI_NUM_INTERFACES, interfacetag = %d\n", interfaceTag);
1963        return CSR_RESULT_FAILURE;
1964    }
1965    /* Frame ma-packet.req, this is saved/transmitted depend on queue state */
1966    unifi_frame_ma_packet_req(priv, priority, TransmitRate, hostTag, interfaceTag,
1967            transmissionControl, leSenderProcessId,
1968            peerMacAddress, &signal);
1969    result = ul_send_signal_unpacked(priv, &signal, bulkdata);
1970    if (result) {
1971        return CSR_RESULT_FAILURE;
1972    }
1973#endif
1974    return status;
1975#endif
1976}
1977
1978#ifdef CSR_SUPPORT_SME
1979s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, u16 interfaceTag, const u8 *daddr)
1980{
1981    s8 protection = 0;
1982    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
1983
1984    switch(interfacePriv->interfaceMode)
1985    {
1986        case CSR_WIFI_ROUTER_CTRL_MODE_STA:
1987        case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
1988        case CSR_WIFI_ROUTER_CTRL_MODE_AMP:
1989        case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
1990            protection = interfacePriv->protect;
1991            break;
1992        case CSR_WIFI_ROUTER_CTRL_MODE_AP:
1993        case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
1994            {
1995                CsrWifiRouterCtrlStaInfo_t *dstStaInfo = NULL;
1996                if (daddr[0] & 0x1) {
1997                    unifi_trace(priv, UDBG3, "broadcast/multicast packet in send_ma_pkt_request\n");
1998                    /* In this mode, the protect member of priv structure has an information of how
1999                     * AP/P2PGO has started, & the member updated in set mode request for AP/P2PGO
2000                     */
2001                    protection = interfacePriv->protect;
2002                } else {
2003                    /* fetch the destination record from staion record database */
2004                    dstStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, daddr, interfaceTag);
2005                    if (!dstStaInfo) {
2006                        unifi_trace(priv, UDBG3, "peer not found in station record in send_ma_pkt_request\n");
2007                        return -1;
2008                    }
2009                    protection = dstStaInfo->protection;
2010                }
2011            }
2012            break;
2013        default:
2014            unifi_trace(priv, UDBG2, "mode unknown in send_ma_pkt_request\n");
2015    }
2016    return protection;
2017}
2018#endif
2019#ifdef CSR_SUPPORT_SME
2020u8 send_multicast_frames(unifi_priv_t *priv, u16 interfaceTag)
2021{
2022    int r;
2023    tx_buffered_packets_t * buffered_pkt = NULL;
2024    u8 moreData = FALSE;
2025    u8 pduSent =0;
2026    unsigned long lock_flags;
2027    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
2028    u32 hostTag = 0xffffffff;
2029
2030    func_enter();
2031    if(!isRouterBufferEnabled(priv,UNIFI_TRAFFIC_Q_VO)) {
2032        while((interfacePriv->dtimActive)&& (buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMulticastOrBroadCastMgtFrames))) {
2033            buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK);
2034            moreData = (buffered_pkt->transmissionControl & TRANSMISSION_CONTROL_EOSP_MASK)?FALSE:TRUE;
2035
2036
2037            unifi_trace(priv,UDBG2,"DTIM Occurred for interface:sending Mgt packet %d\n",interfaceTag);
2038
2039            if((r=frame_and_send_queued_pdu(priv,buffered_pkt,NULL,moreData,FALSE)) == -ENOSPC) {
2040               unifi_trace(priv,UDBG1,"frame_and_send_queued_pdu failed with ENOSPC for host tag = %x\n", buffered_pkt->hostTag);
2041               /* Enqueue at the head of the queue */
2042               spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
2043               list_add(&buffered_pkt->q, &interfacePriv->genericMulticastOrBroadCastMgtFrames);
2044               spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
2045               break;
2046            } else {
2047                unifi_trace(priv,UDBG1,"send_multicast_frames: Send genericMulticastOrBroadCastMgtFrames (%x, %x)\n",
2048                                        buffered_pkt->hostTag,
2049                                        r);
2050                if(r) {
2051                   unifi_net_data_free(priv, &buffered_pkt->bulkdata);
2052                }
2053                if(!moreData) {
2054
2055                    interfacePriv->dtimActive = FALSE;
2056                    if(!r) {
2057                        hostTag = buffered_pkt->hostTag;
2058                        pduSent++;
2059                    } else {
2060                        send_vif_availibility_rsp(priv,uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag),CSR_RC_UNSPECIFIED_FAILURE);
2061                    }
2062                }
2063                /* Buffered frame sent successfully */
2064                spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2065                interfacePriv->noOfbroadcastPktQueued--;
2066                spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2067                kfree(buffered_pkt);
2068           }
2069
2070        }
2071    }
2072    if(!isRouterBufferEnabled(priv,UNIFI_TRAFFIC_Q_CONTENTION)) {
2073        while((interfacePriv->dtimActive)&& (buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMulticastOrBroadCastFrames))) {
2074            buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
2075            moreData = (buffered_pkt->transmissionControl & TRANSMISSION_CONTROL_EOSP_MASK)?FALSE:TRUE;
2076
2077
2078            if((r=frame_and_send_queued_pdu(priv,buffered_pkt,NULL,moreData,FALSE)) == -ENOSPC) {
2079                /* Clear the trigger bit transmission control*/
2080                buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK);
2081                /* Enqueue at the head of the queue */
2082                spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
2083                list_add(&buffered_pkt->q, &interfacePriv->genericMulticastOrBroadCastFrames);
2084                spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
2085                break;
2086            } else {
2087                if(r) {
2088                    unifi_trace(priv,UDBG1,"send_multicast_frames: Send genericMulticastOrBroadCastFrame failed (%x, %x)\n",
2089                                            buffered_pkt->hostTag,
2090                                            r);
2091                    unifi_net_data_free(priv, &buffered_pkt->bulkdata);
2092                }
2093                if(!moreData) {
2094                    interfacePriv->dtimActive = FALSE;
2095                    if(!r) {
2096                        pduSent ++;
2097                        hostTag = buffered_pkt->hostTag;
2098                    } else {
2099                        send_vif_availibility_rsp(priv,uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag),CSR_RC_UNSPECIFIED_FAILURE);
2100                    }
2101                }
2102                /* Buffered frame sent successfully */
2103                spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2104                interfacePriv->noOfbroadcastPktQueued--;
2105                spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2106                kfree(buffered_pkt);
2107            }
2108        }
2109    }
2110    if((interfacePriv->dtimActive == FALSE)) {
2111        /* Record the host Tag*/
2112        unifi_trace(priv,UDBG2,"send_multicast_frames: Recorded hostTag of EOSP packet: = 0x%x\n",hostTag);
2113        interfacePriv->multicastPduHostTag = hostTag;
2114    }
2115    return pduSent;
2116}
2117#endif
2118void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata,
2119                                        u32 siglen)
2120{
2121#ifdef CSR_SUPPORT_SME
2122    CSR_SIGNAL signal;
2123    CSR_MA_VIF_AVAILABILITY_INDICATION *ind;
2124    int r;
2125    u16 interfaceTag;
2126    u8 pduSent =0;
2127    CSR_RESULT_CODE resultCode = CSR_RC_SUCCESS;
2128    netInterface_priv_t *interfacePriv;
2129
2130    func_enter();
2131    unifi_trace(priv, UDBG3,
2132            "uf_process_ma_vif_availibility_ind: Process signal 0x%.4X\n",
2133            *((u16*)sigdata));
2134
2135    r = read_unpack_signal(sigdata, &signal);
2136    if (r) {
2137        unifi_error(priv,
2138                    "uf_process_ma_vif_availibility_ind: Received unknown signal 0x%.4X.\n",
2139                    CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata));
2140        func_exit();
2141        return;
2142    }
2143    ind = &signal.u.MaVifAvailabilityIndication;
2144    interfaceTag=ind->VirtualInterfaceIdentifier & 0xff;
2145
2146    if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
2147        unifi_error(priv, "in vif_availability_ind interfaceTag is wrong\n");
2148        return;
2149    }
2150
2151    interfacePriv = priv->interfacePriv[interfaceTag];
2152
2153    if(ind->Multicast) {
2154        if(list_empty(&interfacePriv->genericMulticastOrBroadCastFrames) &&
2155            list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames)) {
2156            /* This condition can occur because of a potential race where the
2157               TIM is not yet reset as host is waiting for confirm but it is sent
2158               by firmware and DTIM occurs*/
2159            unifi_notice(priv,"ma_vif_availibility_ind recevied for multicast but queues are empty%d\n",interfaceTag);
2160            send_vif_availibility_rsp(priv,ind->VirtualInterfaceIdentifier,CSR_RC_NO_BUFFERED_BROADCAST_MULTICAST_FRAMES);
2161            interfacePriv->dtimActive = FALSE;
2162            if(interfacePriv->multicastPduHostTag == 0xffffffff) {
2163                unifi_notice(priv,"ma_vif_availibility_ind recevied for multicast but queues are empty%d\n",interfaceTag);
2164                /* This may be an extra request in very rare race conditions but it is fine as it would atleast remove the potential lock up */
2165                if (!interfacePriv->bcTimSetReqPendingFlag)
2166                {
2167                    update_tim(priv,0,CSR_WIFI_TIM_RESET,interfaceTag, 0xFFFFFFFF);
2168                }
2169                else
2170                {
2171                    /* Cache the TimSet value so that it will processed immidiatly after
2172                     * completing the current setTim Request
2173                     */
2174                    interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_RESET;
2175                    unifi_trace(priv, UDBG2, "uf_process_ma_vif_availibility_ind : One more UpdateDTim Request(%d) Queued \n",
2176                                interfacePriv->bcTimSetReqQueued);
2177                }
2178            }
2179            return;
2180        }
2181        if(interfacePriv->dtimActive) {
2182            unifi_trace(priv,UDBG2,"DTIM Occurred for already active DTIM interface %d\n",interfaceTag);
2183            return;
2184        } else {
2185            unifi_trace(priv,UDBG2,"DTIM Occurred for interface %d\n",interfaceTag);
2186            if(list_empty(&interfacePriv->genericMulticastOrBroadCastFrames)) {
2187                set_eosp_transmit_ctrl(priv,&interfacePriv->genericMulticastOrBroadCastMgtFrames);
2188            } else {
2189                set_eosp_transmit_ctrl(priv,&interfacePriv->genericMulticastOrBroadCastFrames);
2190            }
2191        }
2192        interfacePriv->dtimActive = TRUE;
2193        pduSent = send_multicast_frames(priv,interfaceTag);
2194    }
2195    else {
2196        unifi_error(priv,"Interface switching is not supported %d\n",interfaceTag);
2197        resultCode = CSR_RC_NOT_SUPPORTED;
2198        send_vif_availibility_rsp(priv,ind->VirtualInterfaceIdentifier,CSR_RC_NOT_SUPPORTED);
2199    }
2200#endif
2201}
2202#ifdef CSR_SUPPORT_SME
2203
2204#define GET_ACTIVE_INTERFACE_TAG(priv) 0
2205
2206static u8 uf_is_more_data_for_delivery_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t *staRecord)
2207{
2208    s8 i;
2209
2210    for(i=UNIFI_TRAFFIC_Q_VO; i >= UNIFI_TRAFFIC_Q_BK; i--)
2211    {
2212        if(((staRecord->powersaveMode[i]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)
2213             ||(staRecord->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED))
2214             &&(!list_empty(&staRecord->dataPdu[i]))) {
2215            unifi_trace(priv,UDBG2,"uf_is_more_data_for_delivery_ac: Data Available AC = %d\n", i);
2216            return TRUE;
2217        }
2218    }
2219
2220    unifi_trace(priv,UDBG2,"uf_is_more_data_for_delivery_ac: Data NOT Available \n");
2221    return FALSE;
2222}
2223
2224static u8 uf_is_more_data_for_usp_delivery(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t *staRecord, unifi_TrafficQueue queue)
2225{
2226    s8 i;
2227
2228    for(i = queue; i >= UNIFI_TRAFFIC_Q_BK; i--)
2229    {
2230        if(((staRecord->powersaveMode[i]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)
2231             ||(staRecord->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED))
2232             &&(!list_empty(&staRecord->dataPdu[i]))) {
2233            unifi_trace(priv,UDBG2,"uf_is_more_data_for_usp_delivery: Data Available AC = %d\n", i);
2234            return TRUE;
2235        }
2236    }
2237
2238    unifi_trace(priv,UDBG2,"uf_is_more_data_for_usp_delivery: Data NOT Available \n");
2239    return FALSE;
2240}
2241
2242/*
2243 * ---------------------------------------------------------------------------
2244 * uf_send_buffered_data_from_delivery_ac
2245 *
2246 * This function takes care of
2247 * -> Parsing the delivery enabled queue & sending frame down to HIP
2248 * -> Setting EOSP=1 when USP to be terminated
2249 * -> Depending on MAX SP length services the USP
2250 *
2251 * NOTE:This function always called from uf_handle_uspframes_delivery(), Dont
2252 * call this function from any other location in code
2253 *
2254 * Arguments:
2255 * priv Pointer to device private context struct
2256 * vif interface specific HIP vif instance
2257 * staInfo peer for which UAPSD to be scheduled
2258 * queue AC from which Data to be sent in USP
2259 * txList access category for processing list
2260 * ---------------------------------------------------------------------------
2261 */
2262void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv,
2263                                            CsrWifiRouterCtrlStaInfo_t * staInfo,
2264                                            u8 queue,
2265                                            struct list_head *txList)
2266{
2267
2268    u16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
2269    tx_buffered_packets_t * buffered_pkt = NULL;
2270    unsigned long lock_flags;
2271    u8 eosp=FALSE;
2272    s8 r =0;
2273    u8 moreData = FALSE;
2274    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
2275
2276    unifi_trace(priv, UDBG2, "++uf_send_buffered_data_from_delivery_ac, active=%x\n", staInfo->uapsdActive);
2277
2278    if (queue > UNIFI_TRAFFIC_Q_VO)
2279    {
2280        return;
2281    }
2282    while((buffered_pkt=dequeue_tx_data_pdu(priv, txList))) {
2283        if((IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
2284            unifi_trace(priv, UDBG2, "uf_send_buffered_data_from_delivery_ac: DTIM Active, suspend UAPSD, staId: 0x%x\n",
2285                        staInfo->aid);
2286
2287            /* Once resume called, the U-APSD delivery operation will resume */
2288            spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2289            staInfo->uspSuspend = TRUE;
2290            spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2291            /* re-queueing the packet as DTIM started */
2292            spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
2293            list_add(&buffered_pkt->q,txList);
2294            spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
2295            break;
2296        }
2297
2298        buffered_pkt->transmissionControl &=
2299                 ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
2300
2301
2302        if((staInfo->wmmOrQosEnabled == TRUE)&&(staInfo->uapsdActive == TRUE)) {
2303
2304             buffered_pkt->transmissionControl = TRANSMISSION_CONTROL_TRIGGER_MASK;
2305
2306             /* Check All delivery enables Ac for more data, because caller of this
2307              * function not aware about last packet
2308              * (First check in moreData fetching helps in draining out Mgt frames Q)
2309              */
2310              moreData = (!list_empty(txList) || uf_is_more_data_for_usp_delivery(priv, staInfo, queue));
2311
2312              if(staInfo->noOfSpFramesSent == (staInfo->maxSpLength - 1)) {
2313                  moreData = FALSE;
2314              }
2315
2316              if(moreData == FALSE) {
2317                  eosp = TRUE;
2318                  buffered_pkt->transmissionControl =
2319                      (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
2320              }
2321        } else {
2322            /* Non QoS and non U-APSD */
2323            unifi_warning(priv, "uf_send_buffered_data_from_delivery_ac: non U-APSD !!! \n");
2324        }
2325
2326        unifi_trace(priv,UDBG2,"uf_send_buffered_data_from_delivery_ac : MoreData:%d, EOSP:%d\n",moreData,eosp);
2327
2328        if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,moreData,eosp)) == -ENOSPC) {
2329
2330            unifi_trace(priv, UDBG2, "uf_send_buffered_data_from_delivery_ac: UASPD suspended, ENOSPC in hipQ=%x\n", queue);
2331
2332            /* Once resume called, the U-APSD delivery operation will resume */
2333            spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2334            staInfo->uspSuspend = TRUE;
2335            spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2336
2337            spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
2338            list_add(&buffered_pkt->q,txList);
2339            spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
2340            priv->pausedStaHandle[queue]=(u8)(staInfo->assignedHandle);
2341            break;
2342        } else {
2343            if(r){
2344                /* the PDU failed where we can't do any thing so free the storage */
2345                unifi_net_data_free(priv, &buffered_pkt->bulkdata);
2346            }
2347            kfree(buffered_pkt);
2348            spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2349            staInfo->noOfSpFramesSent++;
2350            if((!moreData) || (staInfo->noOfSpFramesSent == staInfo->maxSpLength)) {
2351                unifi_trace(priv, UDBG2, "uf_send_buffered_data_from_delivery_ac: Terminating USP\n");
2352                staInfo->uapsdActive = FALSE;
2353                staInfo->uspSuspend = FALSE;
2354                staInfo->noOfSpFramesSent = 0;
2355                spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2356                break;
2357            }
2358            spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2359        }
2360    }
2361    unifi_trace(priv, UDBG2, "--uf_send_buffered_data_from_delivery_ac, active=%x\n", staInfo->uapsdActive);
2362}
2363
2364void uf_send_buffered_data_from_ac(unifi_priv_t *priv,
2365                                   CsrWifiRouterCtrlStaInfo_t * staInfo,
2366                                   u8 queue,
2367                                   struct list_head *txList)
2368{
2369    tx_buffered_packets_t * buffered_pkt = NULL;
2370    unsigned long lock_flags;
2371    u8 eosp=FALSE;
2372    u8 moreData = FALSE;
2373    s8 r =0;
2374
2375    func_enter();
2376
2377    unifi_trace(priv,UDBG2,"uf_send_buffered_data_from_ac :\n");
2378
2379    while(!isRouterBufferEnabled(priv,queue) &&
2380                    ((buffered_pkt=dequeue_tx_data_pdu(priv, txList))!=NULL)){
2381
2382        buffered_pkt->transmissionControl &=
2383                 ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
2384
2385        unifi_trace(priv,UDBG3,"uf_send_buffered_data_from_ac : MoreData:%d, EOSP:%d\n",moreData,eosp);
2386
2387        if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,moreData,eosp)) == -ENOSPC) {
2388           /* Enqueue at the head of the queue */
2389           spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
2390           list_add(&buffered_pkt->q,txList);
2391           spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
2392           if(staInfo != NULL){
2393              priv->pausedStaHandle[queue]=(u8)(staInfo->assignedHandle);
2394           }
2395           unifi_trace(priv,UDBG3," uf_send_buffered_data_from_ac: PDU sending failed .. no space for queue %d \n",queue);
2396           } else {
2397            if(r){
2398                /* the PDU failed where we can't do any thing so free the storage */
2399                unifi_net_data_free(priv, &buffered_pkt->bulkdata);
2400            }
2401            kfree(buffered_pkt);
2402      }
2403  }
2404
2405  func_exit();
2406
2407}
2408
2409void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue q)
2410{
2411    u16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
2412    u32 startIndex=0,endIndex=0;
2413    CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
2414    u8 queue;
2415    u8 moreData = FALSE;
2416
2417    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
2418
2419    if(!((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP) ||
2420        (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO)))
2421        return;
2422    func_enter();
2423
2424    queue = (q<=3)?q:0;
2425
2426    if(interfacePriv->dtimActive) {
2427        /* this function updates dtimActive*/
2428        send_multicast_frames(priv,interfaceTag);
2429        if(!interfacePriv->dtimActive) {
2430            moreData = (!list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) ||
2431             !list_empty(&interfacePriv->genericMulticastOrBroadCastFrames));
2432            if(!moreData) {
2433                if (!interfacePriv->bcTimSetReqPendingFlag)
2434                {
2435                    update_tim(priv,0,CSR_WIFI_TIM_RESET,interfaceTag, 0XFFFFFFFF);
2436                }
2437                else
2438                {
2439                    /* Cache the TimSet value so that it will processed immidiatly after
2440                     * completing the current setTim Request
2441                     */
2442                    interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_RESET;
2443                    unifi_trace(priv, UDBG2, "uf_send_buffered_frames : One more UpdateDTim Request(%d) Queued \n",
2444                                interfacePriv->bcTimSetReqQueued);
2445                }
2446            }
2447        } else {
2448            moreData = (!list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) ||
2449                        !list_empty(&interfacePriv->genericMulticastOrBroadCastFrames));
2450           if(!moreData) {
2451               /* This should never happen but if it happens, we need a way out */
2452               unifi_error(priv,"ERROR: No More Data but DTIM is active sending Response\n");
2453               send_vif_availibility_rsp(priv,uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag),CSR_RC_NO_BUFFERED_BROADCAST_MULTICAST_FRAMES);
2454               interfacePriv->dtimActive = FALSE;
2455           }
2456        }
2457        func_exit();
2458        return;
2459    }
2460    if(priv->pausedStaHandle[queue] > 7) {
2461        priv->pausedStaHandle[queue] = 0;
2462    }
2463
2464    if(queue == UNIFI_TRAFFIC_Q_VO) {
2465
2466
2467        unifi_trace(priv,UDBG2,"uf_send_buffered_frames : trying mgt from queue=%d\n",queue);
2468        for(startIndex= 0; startIndex < UNIFI_MAX_CONNECTIONS;startIndex++) {
2469            staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv,startIndex,interfaceTag);
2470            if(!staInfo ) {
2471                continue;
2472            } else if((staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)
2473                       &&(staInfo->uapsdActive == FALSE) ) {
2474                continue;
2475            }
2476
2477            if((staInfo != NULL)&&(staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)
2478                               &&(staInfo->uapsdActive == FALSE)){
2479                            /*Non-UAPSD case push the management frames out*/
2480               if(!list_empty(&staInfo->mgtFrames)){
2481                    uf_send_buffered_data_from_ac(priv,staInfo, UNIFI_TRAFFIC_Q_VO, &staInfo->mgtFrames);
2482                }
2483            }
2484
2485            if(isRouterBufferEnabled(priv,queue)) {
2486                unifi_notice(priv,"uf_send_buffered_frames : No space Left for queue = %d\n",queue);
2487                break;
2488            }
2489        }
2490        /*push generic management frames out*/
2491        if(!list_empty(&interfacePriv->genericMgtFrames)) {
2492            unifi_trace(priv,UDBG2,"uf_send_buffered_frames : trying generic mgt from queue=%d\n",queue);
2493            uf_send_buffered_data_from_ac(priv,staInfo, UNIFI_TRAFFIC_Q_VO, &interfacePriv->genericMgtFrames);
2494        }
2495    }
2496
2497
2498    unifi_trace(priv,UDBG2,"uf_send_buffered_frames : Resume called for Queue=%d\n",queue);
2499    unifi_trace(priv,UDBG2,"uf_send_buffered_frames : start=%d end=%d\n",startIndex,endIndex);
2500
2501    startIndex = priv->pausedStaHandle[queue];
2502    endIndex = (startIndex + UNIFI_MAX_CONNECTIONS -1) % UNIFI_MAX_CONNECTIONS;
2503
2504    while(startIndex != endIndex) {
2505        staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv,startIndex,interfaceTag);
2506        if(!staInfo) {
2507            startIndex ++;
2508            if(startIndex >= UNIFI_MAX_CONNECTIONS) {
2509                startIndex = 0;
2510            }
2511            continue;
2512        } else if((staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)
2513                   &&(staInfo->uapsdActive == FALSE)) {
2514            startIndex ++;
2515            if(startIndex >= UNIFI_MAX_CONNECTIONS) {
2516                startIndex = 0;
2517            }
2518            continue;
2519        }
2520        /* Peer is active or U-APSD is active so send PDUs to the peer */
2521        unifi_trace(priv,UDBG2,"uf_send_buffered_frames : trying data from queue=%d\n",queue);
2522
2523
2524        if((staInfo != NULL)&&(staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)
2525                           &&(staInfo->uapsdActive == FALSE)) {
2526           if(!list_empty(&staInfo->dataPdu[queue])) {
2527
2528               /*Non-UAPSD case push the AC frames out*/
2529               uf_send_buffered_data_from_ac(priv, staInfo, queue, (&staInfo->dataPdu[queue]));
2530           }
2531        }
2532        startIndex ++;
2533        if(startIndex >= UNIFI_MAX_CONNECTIONS) {
2534           startIndex = 0;
2535        }
2536    }
2537    if(isRouterBufferEnabled(priv,queue)) {
2538        priv->pausedStaHandle[queue] = endIndex;
2539    } else {
2540        priv->pausedStaHandle[queue] = 0;
2541    }
2542
2543    /* U-APSD might have stopped because of ENOSPC in lib_hip (pause activity).
2544     * So restart it if U-APSD was active with any of the station
2545     */
2546    unifi_trace(priv, UDBG4, "csrWifiHipSendBufferedFrames: UAPSD Resume Q=%x\n", queue);
2547    resume_suspended_uapsd(priv, interfaceTag);
2548    func_exit();
2549}
2550
2551
2552u8 uf_is_more_data_for_non_delivery_ac(CsrWifiRouterCtrlStaInfo_t *staRecord)
2553{
2554    u8 i;
2555
2556    for(i=0;i<=3;i++)
2557    {
2558        if(((staRecord->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_ONLY_ENABLED)
2559                ||(staRecord->powersaveMode[i]==CSR_WIFI_AC_LEGACY_POWER_SAVE))
2560                &&(!list_empty(&staRecord->dataPdu[i]))){
2561
2562         return TRUE;
2563        }
2564    }
2565
2566    if(((staRecord->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_TRIGGER_ONLY_ENABLED)
2567            ||(staRecord->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_LEGACY_POWER_SAVE))
2568            &&(!list_empty(&staRecord->mgtFrames))){
2569
2570     return TRUE;
2571    }
2572
2573
2574
2575    return FALSE;
2576}
2577
2578
2579int uf_process_station_records_for_sending_data(unifi_priv_t *priv,u16 interfaceTag,
2580                                                 CsrWifiRouterCtrlStaInfo_t *srcStaInfo,
2581                                                 CsrWifiRouterCtrlStaInfo_t *dstStaInfo)
2582{
2583    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
2584
2585    unifi_trace(priv, UDBG5, "entering uf_process_station_records_for_sending_data\n");
2586
2587    if (srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED) {
2588        unifi_error(priv, "Peer State not connected AID = %x, handle = %x, control port state = %x\n",
2589                    srcStaInfo->aid, srcStaInfo->assignedHandle, srcStaInfo->peerControlledPort->port_action);
2590        return -1;
2591    }
2592    switch (interfacePriv->interfaceMode)
2593    {
2594        case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
2595        case CSR_WIFI_ROUTER_CTRL_MODE_AP:
2596            unifi_trace(priv, UDBG5, "mode is AP/P2PGO\n");
2597            break;
2598        default:
2599            unifi_warning(priv, "mode is nor AP neither P2PGO, packet cant be xmit\n");
2600            return -1;
2601    }
2602
2603    switch(dstStaInfo->peerControlledPort->port_action)
2604    {
2605        case CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD:
2606        case CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_BLOCK:
2607            unifi_trace(priv, UDBG5, "destination port is closed/blocked, discarding the packet\n");
2608            return -1;
2609        default:
2610            unifi_trace(priv, UDBG5, "destination port state is open\n");
2611    }
2612
2613    /* port state is open, destination station record is valid, Power save state is
2614     * validated in uf_process_ma_packet_req function
2615     */
2616    unifi_trace(priv, UDBG5, "leaving uf_process_station_records_for_sending_data\n");
2617    return 0;
2618}
2619
2620
2621/*
2622 * ---------------------------------------------------------------------------
2623 * uf_handle_uspframes_delivery
2624 *
2625 * This function takes care of handling USP session for peer, when
2626 * -> trigger frame from peer
2627 * -> suspended USP to be processed (resumed)
2628 *
2629 * NOTE: uf_send_buffered_data_from_delivery_ac() always called from this function, Dont
2630 * make a direct call to uf_send_buffered_data_from_delivery_ac() from any other part of
2631 * code
2632 *
2633 * Arguments:
2634 * priv Pointer to device private context struct
2635 * staInfo peer for which UAPSD to be scheduled
2636 * interfaceTag virtual interface tag
2637 * ---------------------------------------------------------------------------
2638 */
2639static void uf_handle_uspframes_delivery(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t *staInfo, u16 interfaceTag)
2640{
2641
2642    s8 i;
2643    u8 allDeliveryEnabled = 0, dataAvailable = 0;
2644    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
2645    unsigned long lock_flags;
2646
2647    unifi_trace(priv, UDBG2, " ++ uf_handle_uspframes_delivery, uapsd active=%x, suspended?=%x\n",
2648                staInfo->uapsdActive, staInfo->uspSuspend);
2649
2650    /* Check for Buffered frames according to priority order & deliver it
2651     * 1. AC_VO delivery enable & Mgt frames available
2652     * 2. Process remaining Ac's from order AC_VO to AC_BK
2653     */
2654
2655    /* USP initiated by WMMPS enabled peer & SET the status flag to TRUE */
2656    if (!staInfo->uspSuspend && staInfo->uapsdActive)
2657    {
2658        unifi_notice(priv, "uf_handle_uspframes_delivery: U-APSD already active! STA=%x:%x:%x:%x:%x:%x\n",
2659                staInfo->peerMacAddress.a[0], staInfo->peerMacAddress.a[1],
2660                staInfo->peerMacAddress.a[2], staInfo->peerMacAddress.a[3],
2661                staInfo->peerMacAddress.a[4], staInfo->peerMacAddress.a[5]);
2662        return;
2663    }
2664
2665    spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2666    staInfo->uapsdActive = TRUE;
2667    staInfo->uspSuspend = FALSE;
2668    spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2669
2670    if(((staInfo->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED)||
2671        (staInfo->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE))
2672        && (!list_empty(&staInfo->mgtFrames))) {
2673
2674         /* Management queue has data && UNIFI_TRAFFIC_Q_VO is delivery enable */
2675        unifi_trace(priv, UDBG4, "uf_handle_uspframes_delivery: Sending buffered management frames\n");
2676        uf_send_buffered_data_from_delivery_ac(priv, staInfo, UNIFI_TRAFFIC_Q_VO, &staInfo->mgtFrames);
2677    }
2678
2679    if (!uf_is_more_data_for_delivery_ac(priv, staInfo)) {
2680        /* All delivery enable AC's are empty, so QNULL to be sent to terminate the USP
2681         * NOTE: If we have sent Mgt frame also, we must send QNULL followed to terminate USP
2682         */
2683        if (!staInfo->uspSuspend) {
2684            spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2685            staInfo->uapsdActive = FALSE;
2686            spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2687
2688            unifi_trace(priv, UDBG2, "uf_handle_uspframes_delivery: sending QNull for trigger\n");
2689            uf_send_qos_null(priv, interfaceTag, staInfo->peerMacAddress.a, (CSR_PRIORITY) staInfo->triggerFramePriority, staInfo);
2690            staInfo->triggerFramePriority = CSR_QOS_UP0;
2691        } else {
2692            unifi_trace(priv, UDBG2, "uf_handle_uspframes_delivery: MgtQ xfer suspended\n");
2693        }
2694    } else {
2695        for(i = UNIFI_TRAFFIC_Q_VO; i >= UNIFI_TRAFFIC_Q_BK; i--) {
2696            if(((staInfo->powersaveMode[i]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)
2697                ||(staInfo->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED))
2698                && (!list_empty(&staInfo->dataPdu[i]))) {
2699                /* Deliver Data according to AC priority (from VO to BK) as part of USP */
2700                unifi_trace(priv, UDBG4, "uf_handle_uspframes_delivery: Buffered data frames from Queue (%d) for USP\n", i);
2701                uf_send_buffered_data_from_delivery_ac(priv, staInfo, i, &staInfo->dataPdu[i]);
2702            }
2703
2704            if ((!staInfo->uapsdActive) ||
2705                    (staInfo->uspSuspend && IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
2706                /* If DTIM active found on one AC, No need to parse the remaining AC's
2707                 * as USP suspended. Break out of loop
2708                 */
2709                unifi_trace(priv, UDBG2, "uf_handle_uspframes_delivery: suspend=%x, DTIM=%x, USP terminated=%s\n",
2710                           staInfo->uspSuspend, IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag),
2711                           staInfo->uapsdActive?"NO":"YES");
2712                break;
2713            }
2714        }
2715    }
2716
2717    /* Depending on the USP status, update the TIM accordingly for delivery enabled AC only
2718     * (since we are not manipulating any Non-delivery list(AC))
2719     */
2720    is_all_ac_deliver_enabled_and_moredata(staInfo, &allDeliveryEnabled, &dataAvailable);
2721    if ((allDeliveryEnabled && !dataAvailable)) {
2722        if ((staInfo->timSet != CSR_WIFI_TIM_RESET) || (staInfo->timSet != CSR_WIFI_TIM_RESETTING)) {
2723            staInfo->updateTimReqQueued = (u8) CSR_WIFI_TIM_RESET;
2724            unifi_trace(priv, UDBG4, " --uf_handle_uspframes_delivery, UAPSD timset\n");
2725            if (!staInfo->timRequestPendingFlag) {
2726                update_tim(priv, staInfo->aid, 0, interfaceTag, staInfo->assignedHandle);
2727            }
2728        }
2729    }
2730    unifi_trace(priv, UDBG2, " --uf_handle_uspframes_delivery, uapsd active=%x, suspend?=%x\n",
2731                staInfo->uapsdActive, staInfo->uspSuspend);
2732}
2733
2734void uf_process_wmm_deliver_ac_uapsd(unifi_priv_t * priv,
2735                                     CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
2736                                     u16 qosControl,
2737                                     u16 interfaceTag)
2738{
2739    CSR_PRIORITY priority;
2740    unifi_TrafficQueue priority_q;
2741    unsigned long lock_flags;
2742
2743    unifi_trace(priv, UDBG2, "++uf_process_wmm_deliver_ac_uapsd: uapsdactive?=%x\n", srcStaInfo->uapsdActive);
2744    /* If recceived Frames trigger Frame and Devlivery enabled AC has data
2745     * then transmit from High priorty delivery enabled AC
2746     */
2747    priority = (CSR_PRIORITY)(qosControl & IEEE802_11_QC_TID_MASK);
2748    priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
2749
2750    if((srcStaInfo->powersaveMode[priority_q]==CSR_WIFI_AC_TRIGGER_ONLY_ENABLED)
2751        ||(srcStaInfo->powersaveMode[priority_q]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED)) {
2752        spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2753        srcStaInfo->triggerFramePriority = priority;
2754        spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2755        unifi_trace(priv, UDBG2, "uf_process_wmm_deliver_ac_uapsd: trigger frame, Begin U-APSD, triggerQ=%x\n", priority_q);
2756        uf_handle_uspframes_delivery(priv, srcStaInfo, interfaceTag);
2757    }
2758    unifi_trace(priv, UDBG2, "--uf_process_wmm_deliver_ac_uapsd: uapsdactive?=%x\n", srcStaInfo->uapsdActive);
2759}
2760
2761
2762void uf_send_qos_null(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
2763{
2764    bulk_data_param_t bulkdata;
2765    CsrResult csrResult;
2766    struct sk_buff *skb, *newSkb = NULL;
2767    CsrWifiMacAddress peerAddress;
2768    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
2769    CSR_TRANSMISSION_CONTROL transmissionControl = (TRANSMISSION_CONTROL_EOSP_MASK | TRANSMISSION_CONTROL_TRIGGER_MASK);
2770    int r;
2771    CSR_SIGNAL signal;
2772    u32 priority_q;
2773    CSR_RATE transmitRate = 0;
2774
2775
2776    func_enter();
2777    /* Send a Null Frame to Peer,
2778     * 32= size of mac header */
2779    csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], MAC_HEADER_SIZE + QOS_CONTROL_HEADER_SIZE);
2780
2781    if (csrResult != CSR_RESULT_SUCCESS) {
2782        unifi_error(priv, " failed to allocate request_data. in uf_send_qos_null func\n");
2783        return ;
2784    }
2785    skb = (struct sk_buff *)(bulkdata.d[0].os_net_buf_ptr);
2786    skb->len = 0;
2787    bulkdata.d[0].os_data_ptr = skb->data;
2788    bulkdata.d[0].os_net_buf_ptr = (unsigned char*)skb;
2789    bulkdata.d[0].net_buf_length = bulkdata.d[0].data_length = skb->len;
2790    bulkdata.d[1].os_data_ptr = NULL;
2791    bulkdata.d[1].os_net_buf_ptr = NULL;
2792    bulkdata.d[1].net_buf_length = bulkdata.d[1].data_length = 0;
2793
2794    /* For null frames protection bit should not be set in MAC header, so passing value 0 below for protection field */
2795
2796    if (prepare_and_add_macheader(priv, skb, newSkb, priority, &bulkdata, interfaceTag, da, interfacePriv->bssid.a, 0)) {
2797        unifi_error(priv, "failed to create MAC header\n");
2798        unifi_net_data_free(priv, &bulkdata.d[0]);
2799        return;
2800    }
2801    memcpy(peerAddress.a, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
2802    /* convert priority to queue */
2803    priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
2804
2805    /* Frame ma-packet.req, this is saved/transmitted depend on queue state
2806     * send the null frame at data rate of 1 Mb/s for AP or 6 Mb/s for P2PGO
2807     */
2808    switch (interfacePriv->interfaceMode)
2809    {
2810        case CSR_WIFI_ROUTER_CTRL_MODE_AP:
2811            transmitRate = 2;
2812            break;
2813        case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
2814            transmitRate = 12;
2815            break;
2816        default:
2817            transmitRate = 0;
2818    }
2819    unifi_frame_ma_packet_req(priv, priority, transmitRate, 0xffffffff, interfaceTag,
2820                              transmissionControl, priv->netdev_client->sender_id,
2821                              peerAddress.a, &signal);
2822
2823    r = ul_send_signal_unpacked(priv, &signal, &bulkdata);
2824    if(r) {
2825        unifi_error(priv, "failed to send QOS data null packet result: %d\n",r);
2826        unifi_net_data_free(priv, &bulkdata.d[0]);
2827    }
2828
2829    func_exit();
2830    return;
2831
2832}
2833void uf_send_nulldata(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
2834{
2835    bulk_data_param_t bulkdata;
2836    CsrResult csrResult;
2837    struct sk_buff *skb, *newSkb = NULL;
2838    CsrWifiMacAddress peerAddress;
2839    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
2840    CSR_TRANSMISSION_CONTROL transmissionControl = 0;
2841    int r;
2842    CSR_SIGNAL signal;
2843    u32 priority_q;
2844    CSR_RATE transmitRate = 0;
2845    CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
2846    unsigned long lock_flags;
2847
2848    func_enter();
2849    /* Send a Null Frame to Peer, size = 24 for MAC header */
2850    csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], MAC_HEADER_SIZE);
2851
2852    if (csrResult != CSR_RESULT_SUCCESS) {
2853        unifi_error(priv, "uf_send_nulldata: Failed to allocate memory for NULL frame\n");
2854        return ;
2855    }
2856    skb = (struct sk_buff *)(bulkdata.d[0].os_net_buf_ptr);
2857    skb->len = 0;
2858    bulkdata.d[0].os_data_ptr = skb->data;
2859    bulkdata.d[0].os_net_buf_ptr = (unsigned char*)skb;
2860    bulkdata.d[0].net_buf_length = bulkdata.d[0].data_length = skb->len;
2861    bulkdata.d[1].os_data_ptr = NULL;
2862    bulkdata.d[1].os_net_buf_ptr = NULL;
2863    bulkdata.d[1].net_buf_length = bulkdata.d[1].data_length = 0;
2864
2865    /* For null frames protection bit should not be set in MAC header, so passing value 0 below for protection field */
2866    if (prepare_and_add_macheader(priv, skb, newSkb, priority, &bulkdata, interfaceTag, da, interfacePriv->bssid.a, 0)) {
2867        unifi_error(priv, "uf_send_nulldata: Failed to create MAC header\n");
2868        unifi_net_data_free(priv, &bulkdata.d[0]);
2869        return;
2870    }
2871    memcpy(peerAddress.a, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
2872    /* convert priority to queue */
2873    priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
2874    transmissionControl &= ~(CSR_NO_CONFIRM_REQUIRED);
2875
2876    /* Frame ma-packet.req, this is saved/transmitted depend on queue state
2877     * send the null frame at data rate of 1 Mb/s for AP or 6 Mb/s for P2PGO
2878     */
2879    switch (interfacePriv->interfaceMode)
2880    {
2881        case CSR_WIFI_ROUTER_CTRL_MODE_AP:
2882            transmitRate = 2;
2883            break;
2884        case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
2885            transmitRate = 12;
2886            break;
2887        default:
2888            transmitRate = 0;
2889    }
2890    unifi_frame_ma_packet_req(priv, priority, transmitRate, INVALID_HOST_TAG, interfaceTag,
2891                              transmissionControl, priv->netdev_client->sender_id,
2892                              peerAddress.a, &signal);
2893
2894    /* Save host tag to check the status on reception of MA packet confirm */
2895    srcStaInfo->nullDataHostTag = req->HostTag;
2896    unifi_trace(priv, UDBG1, "uf_send_nulldata: STA AID = %d hostTag = %x\n", srcStaInfo->aid, req->HostTag);
2897
2898    r = ul_send_signal_unpacked(priv, &signal, &bulkdata);
2899
2900    if(r == -ENOSPC) {
2901        unifi_trace(priv, UDBG1, "uf_send_nulldata: ENOSPC Requeue the Null frame\n");
2902        enque_tx_data_pdu(priv, &bulkdata, &srcStaInfo->dataPdu[priority_q], &signal, 1);
2903        spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2904        srcStaInfo->noOfPktQueued++;
2905        spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2906
2907
2908    }
2909    if(r && r != -ENOSPC){
2910        unifi_error(priv, "uf_send_nulldata: Failed to send Null frame Error = %d\n",r);
2911        unifi_net_data_free(priv, &bulkdata.d[0]);
2912        srcStaInfo->nullDataHostTag = INVALID_HOST_TAG;
2913    }
2914
2915    func_exit();
2916    return;
2917}
2918
2919u8 uf_check_broadcast_bssid(unifi_priv_t *priv, const bulk_data_param_t *bulkdata)
2920{
2921    u8 *bssid = NULL;
2922    static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
2923    u8 toDs, fromDs;
2924
2925    toDs = (((bulkdata->d[0].os_data_ptr)[1]) & 0x01) ? 1 : 0;
2926    fromDs =(((bulkdata->d[0].os_data_ptr)[1]) & 0x02) ? 1 : 0;
2927
2928     if (toDs && fromDs)
2929    {
2930        unifi_trace(priv, UDBG6, "Address 4 present, Don't try to find BSSID\n");
2931        bssid = NULL;
2932    }
2933    else if((toDs == 0) && (fromDs ==0))
2934    {
2935        /* BSSID is Address 3 */
2936        bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4 + (2 * ETH_ALEN));
2937    }
2938    else if(toDs)
2939    {
2940        /* BSSID is Address 1 */
2941        bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4);
2942    }
2943    else if(fromDs)
2944    {
2945        /* BSSID is Address 2 */
2946        bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4 + ETH_ALEN);
2947    }
2948
2949    if (memcmp(broadcast_address.a, bssid, ETH_ALEN)== 0)
2950    {
2951        return TRUE;
2952    }
2953    else
2954    {
2955        return FALSE;
2956    }
2957}
2958
2959
2960u8 uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
2961                                u8 pmBit,u16 interfaceTag)
2962{
2963    u8 moreData = FALSE;
2964    u8 powerSaveChanged = FALSE;
2965    unsigned long lock_flags;
2966
2967    unifi_trace(priv, UDBG3, "entering uf_process_pm_bit_for_peer\n");
2968    if (pmBit) {
2969        priv->allPeerDozing |= (0x01 << (srcStaInfo->assignedHandle));
2970    } else {
2971        priv->allPeerDozing &= ~(0x01 << (srcStaInfo->assignedHandle));
2972    }
2973    if(pmBit) {
2974        if(srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE) {
2975
2976            /* disable the preemption */
2977            spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2978            srcStaInfo->currentPeerState =CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE;
2979            powerSaveChanged = TRUE;
2980            /* enable the preemption */
2981            spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2982        } else {
2983            return powerSaveChanged;
2984        }
2985    } else {
2986        if(srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE) {
2987            /* disable the preemption */
2988            spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
2989            srcStaInfo->currentPeerState = CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE;
2990            powerSaveChanged = TRUE;
2991            /* enable the preemption */
2992            spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
2993        }else {
2994            return powerSaveChanged;
2995        }
2996    }
2997
2998
2999    if(srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE) {
3000        unifi_trace(priv,UDBG3, "Peer with AID = %d is active now\n",srcStaInfo->aid);
3001        process_peer_active_transition(priv,srcStaInfo,interfaceTag);
3002    } else {
3003        unifi_trace(priv,UDBG3, "Peer with AID = %d is in PS Now\n",srcStaInfo->aid);
3004        /* Set TIM if needed */
3005        if(!srcStaInfo->wmmOrQosEnabled) {
3006            moreData = (!list_empty(&srcStaInfo->mgtFrames) ||
3007                        !list_empty(&srcStaInfo->dataPdu[UNIFI_TRAFFIC_Q_VO])||
3008                        !list_empty(&srcStaInfo->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]));
3009            if(moreData && (srcStaInfo->timSet == CSR_WIFI_TIM_RESET)) {
3010                unifi_trace(priv, UDBG3, "This condition should not occur\n");
3011                if (!srcStaInfo->timRequestPendingFlag){
3012                    update_tim(priv,srcStaInfo->aid,1,interfaceTag, srcStaInfo->assignedHandle);
3013                }
3014                else
3015                {
3016                    /* Cache the TimSet value so that it will processed immidiatly after
3017                     * completing the current setTim Request
3018                     */
3019                    srcStaInfo->updateTimReqQueued = 1;
3020                    unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", srcStaInfo->updateTimReqQueued,
3021                                srcStaInfo->aid);
3022                }
3023
3024            }
3025        } else {
3026            u8 allDeliveryEnabled = 0, dataAvailable = 0;
3027            unifi_trace(priv, UDBG5, "Qos in AP Mode\n");
3028            /* Check if all AC's are Delivery Enabled */
3029            is_all_ac_deliver_enabled_and_moredata(srcStaInfo, &allDeliveryEnabled, &dataAvailable);
3030            /*check for more data in non-delivery enabled queues*/
3031            moreData = (uf_is_more_data_for_non_delivery_ac(srcStaInfo) || (allDeliveryEnabled && dataAvailable));
3032
3033            if(moreData && (srcStaInfo->timSet == CSR_WIFI_TIM_RESET)) {
3034                if (!srcStaInfo->timRequestPendingFlag){
3035                    update_tim(priv,srcStaInfo->aid,1,interfaceTag, srcStaInfo->assignedHandle);
3036                }
3037                else
3038                {
3039                    /* Cache the TimSet value so that it will processed immidiatly after
3040                     * completing the current setTim Request
3041                     */
3042                    srcStaInfo->updateTimReqQueued = 1;
3043                    unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", srcStaInfo->updateTimReqQueued,
3044                                srcStaInfo->aid);
3045                }
3046            }
3047        }
3048    }
3049    unifi_trace(priv, UDBG3, "leaving uf_process_pm_bit_for_peer\n");
3050    return powerSaveChanged;
3051}
3052
3053
3054
3055void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,u16 interfaceTag)
3056{
3057    CsrWifiRouterCtrlStaInfo_t *staRecord =
3058    CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, sa, interfaceTag);
3059    tx_buffered_packets_t * buffered_pkt = NULL;
3060    CsrWifiMacAddress peerMacAddress;
3061    unsigned long lock_flags;
3062    s8 r =0;
3063    u8 moreData = FALSE;
3064    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
3065
3066    unifi_trace(priv, UDBG3, "entering uf_process_ps_poll\n");
3067    if(!staRecord) {
3068        memcpy(peerMacAddress.a,sa,ETH_ALEN);
3069        unifi_trace(priv, UDBG3, "In uf_process_ps_poll, sta record not found:unexpected frame addr = %x:%x:%x:%x:%x:%x\n",
3070                sa[0], sa[1],sa[2], sa[3], sa[4],sa[5]);
3071        CsrWifiRouterCtrlUnexpectedFrameIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,interfaceTag,peerMacAddress);
3072        return;
3073    }
3074
3075    uf_process_pm_bit_for_peer(priv,staRecord,pmBit,interfaceTag);
3076
3077    /* Update station last activity time */
3078    staRecord->activity_flag = TRUE;
3079
3080    /* This should not change the PM bit as PS-POLL has PM bit always set */
3081    if(!pmBit) {
3082        unifi_notice (priv," PM bit reset in PS-POLL\n");
3083        return;
3084    }
3085
3086    if(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
3087        /* giving more priority to multicast packets so dropping ps-poll*/
3088        unifi_notice (priv," multicast transmission is going on so don't take action on PS-POLL\n");
3089        return;
3090    }
3091
3092    if(!staRecord->wmmOrQosEnabled) {
3093        if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->mgtFrames))) {
3094            buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
3095            moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
3096                        !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]) ||
3097                        !list_empty(&staRecord->mgtFrames));
3098
3099            buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
3100            if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
3101                /* Clear the trigger bit transmission control*/
3102                buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
3103                /* Enqueue at the head of the queue */
3104                spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3105                list_add(&buffered_pkt->q, &staRecord->mgtFrames);
3106                spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3107                unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
3108                priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
3109            } else {
3110                if(r){
3111                    unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
3112                    /* the PDU failed where we can't do any thing so free the storage */
3113                    unifi_net_data_free(priv, &buffered_pkt->bulkdata);
3114                }
3115                kfree(buffered_pkt);
3116            }
3117        } else if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]))) {
3118            buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
3119            moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
3120                        !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]));
3121
3122            buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
3123            if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
3124                /* Clear the trigger bit transmission control*/
3125                buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
3126                /* Enqueue at the head of the queue */
3127                spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3128                list_add(&buffered_pkt->q, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]);
3129                spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3130                priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
3131                unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
3132            } else {
3133                if(r){
3134                    unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
3135                    /* the PDU failed where we can't do any thing so free the storage */
3136                    unifi_net_data_free(priv, &buffered_pkt->bulkdata);
3137                }
3138                kfree(buffered_pkt);
3139            }
3140        } else if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]))) {
3141            buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
3142            moreData = !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]);
3143
3144            buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
3145            if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
3146                /* Clear the trigger bit transmission control*/
3147                buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
3148                /* Enqueue at the head of the queue */
3149                spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3150                list_add(&buffered_pkt->q, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]);
3151                spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3152                priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
3153                unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
3154            } else {
3155                if(r){
3156                    unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
3157                    /* the PDU failed where we can't do any thing so free the storage */
3158                    unifi_net_data_free(priv, &buffered_pkt->bulkdata);
3159                }
3160                kfree(buffered_pkt);
3161            }
3162        } else {
3163         /* Actually since we have sent an ACK, there
3164         * there is no need to send a NULL frame*/
3165        }
3166        moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]) ||
3167           !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
3168            !list_empty(&staRecord->mgtFrames));
3169        if(!moreData && (staRecord->timSet == CSR_WIFI_TIM_SET)) {
3170            unifi_trace(priv, UDBG3, "more data = NULL, set tim to 0 in uf_process_ps_poll\n");
3171            if (!staRecord->timRequestPendingFlag){
3172                update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
3173            }
3174            else
3175            {
3176                /* Cache the TimSet value so that it will processed immidiatly after
3177                 * completing the current setTim Request
3178                 */
3179                staRecord->updateTimReqQueued = 0;
3180                unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
3181                            staRecord->aid);
3182            }
3183        }
3184    } else {
3185
3186        u8 allDeliveryEnabled = 0, dataAvailable = 0;
3187        unifi_trace(priv, UDBG3,"Qos Support station.Processing PS-Poll\n");
3188
3189        /*Send Data From Management Frames*/
3190        /* Priority orders for delivering the buffered packets are
3191         * 1. Deliver the Management frames if there
3192         * 2. Other access catagory frames which are non deliver enable including UNIFI_TRAFFIC_Q_VO
3193         * priority is from VO->BK
3194         */
3195
3196        /* Check if all AC's are Delivery Enabled */
3197        is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
3198
3199        if (allDeliveryEnabled) {
3200            unifi_trace(priv, UDBG3, "uf_process_ps_poll: All ACs are delivery enable so Sending QOS Null in response of Ps-poll\n");
3201            uf_send_qos_null(priv,interfaceTag,sa,CSR_QOS_UP0,staRecord);
3202            return;
3203        }
3204
3205        if (!list_empty(&staRecord->mgtFrames)) {
3206             if ((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->mgtFrames))) {
3207                    /* We dont have packets in non delivery enabled UNIFI_TRAFFIC_Q_VO, So we are looking in management
3208                     * queue of the station record
3209                     */
3210                    moreData = uf_is_more_data_for_non_delivery_ac(staRecord);
3211                    buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
3212
3213                    /* Last parameter is EOSP & its false always for PS-POLL processing */
3214                    if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
3215                        /* Clear the trigger bit transmission control*/
3216                        buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
3217                        /* Enqueue at the head of the queue */
3218                        spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3219                        list_add(&buffered_pkt->q, &staRecord->mgtFrames);
3220                        spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3221                        priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
3222                        unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
3223                    } else {
3224                        if(r){
3225                            unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
3226                            /* the PDU failed where we can't do any thing so free the storage */
3227                            unifi_net_data_free(priv, &buffered_pkt->bulkdata);
3228                        }
3229                        kfree(buffered_pkt);
3230                    }
3231                } else {
3232                    unifi_error(priv, "uf_process_ps_poll: Mgt frame list empty!! \n");
3233                }
3234
3235        } else {
3236            s8 i;
3237            /* We dont have buffered packet in mangement frame queue (1 failed), So proceed with condition 2
3238             * UNIFI_TRAFFIC_Q_VO -> VI -> BE -> BK
3239             */
3240            for(i= 3; i>=0; i--) {
3241                if (!IS_DELIVERY_ENABLED(staRecord->powersaveMode[i])) {
3242                    /* Send One packet, if queue is NULL then continue */
3243                    if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[i]))) {
3244                        moreData = uf_is_more_data_for_non_delivery_ac(staRecord);
3245
3246                        buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
3247
3248                        /* Last parameter is EOSP & its false always for PS-POLL processing */
3249                        if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
3250                            /* Clear the trigger bit transmission control*/
3251                            buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
3252                            /* Enqueue at the head of the queue */
3253                            spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3254                            list_add(&buffered_pkt->q, &staRecord->dataPdu[i]);
3255                            spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3256                            priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
3257                            unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
3258                        } else {
3259                            if(r) {
3260                                unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
3261                                /* the PDU failed where we can't do any thing so free the storage */
3262                                unifi_net_data_free(priv, &buffered_pkt->bulkdata);
3263                            }
3264                            kfree(buffered_pkt);
3265                        }
3266                        break;
3267                    }
3268                }
3269            }
3270        }
3271        /* Check if all AC's are Delivery Enabled */
3272        is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
3273        /*check for more data in non-delivery enabled queues*/
3274        moreData = (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable));
3275        if(!moreData && (staRecord->timSet == CSR_WIFI_TIM_SET)) {
3276            unifi_trace(priv, UDBG3, "more data = NULL, set tim to 0 in uf_process_ps_poll\n");
3277            if (!staRecord->timRequestPendingFlag){
3278                update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
3279            }
3280            else
3281            {
3282                /* Cache the TimSet value so that it will processed immidiatly after
3283                 * completing the current setTim Request
3284                 */
3285                staRecord->updateTimReqQueued = 0;
3286                unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
3287                            staRecord->aid);
3288            }
3289
3290        }
3291    }
3292
3293        unifi_trace(priv, UDBG3, "leaving uf_process_ps_poll\n");
3294}
3295
3296
3297
3298void add_to_send_cfm_list(unifi_priv_t * priv,
3299                          tx_buffered_packets_t *tx_q_item,
3300                          struct list_head *frames_need_cfm_list)
3301{
3302    tx_buffered_packets_t *send_cfm_list_item = NULL;
3303
3304    send_cfm_list_item = (tx_buffered_packets_t *) kmalloc(sizeof(tx_buffered_packets_t), GFP_ATOMIC);
3305
3306    if(send_cfm_list_item == NULL){
3307        unifi_warning(priv, "%s: Failed to allocate memory for new list item \n");
3308        return;
3309    }
3310
3311    INIT_LIST_HEAD(&send_cfm_list_item->q);
3312
3313    send_cfm_list_item->hostTag = tx_q_item->hostTag;
3314    send_cfm_list_item->interfaceTag = tx_q_item->interfaceTag;
3315    send_cfm_list_item->transmissionControl = tx_q_item->transmissionControl;
3316    send_cfm_list_item->leSenderProcessId = tx_q_item->leSenderProcessId;
3317    send_cfm_list_item->rate = tx_q_item->rate;
3318    memcpy(send_cfm_list_item->peerMacAddress.a, tx_q_item->peerMacAddress.a, ETH_ALEN);
3319    send_cfm_list_item->priority = tx_q_item->priority;
3320
3321    list_add_tail(&send_cfm_list_item->q, frames_need_cfm_list);
3322}
3323
3324void uf_prepare_send_cfm_list_for_queued_pkts(unifi_priv_t * priv,
3325                                                 struct list_head *frames_need_cfm_list,
3326                                                 struct list_head * list)
3327{
3328    tx_buffered_packets_t *tx_q_item = NULL;
3329    struct list_head *listHead;
3330    struct list_head *placeHolder;
3331    unsigned long lock_flags;
3332
3333    func_enter();
3334
3335    spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3336
3337    /* Search through the list and if confirmation required for any frames,
3338    add it to the send_cfm list */
3339    list_for_each_safe(listHead, placeHolder, list) {
3340        tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
3341
3342        if(!tx_q_item) {
3343            unifi_error(priv, "Entry should exist, otherwise it is a (BUG)\n");
3344            continue;
3345        }
3346
3347        /* check if confirmation is requested and if the sender ID
3348        is not netdevice client then save the entry in the list for need cfms */
3349        if (!(tx_q_item->transmissionControl & CSR_NO_CONFIRM_REQUIRED) &&
3350            (tx_q_item->leSenderProcessId != priv->netdev_client->sender_id)){
3351             unifi_trace(priv, UDBG1, "%s: SenderProcessID=%x host tag=%x transmission control=%x\n",
3352                __FUNCTION__,
3353                tx_q_item->leSenderProcessId,
3354                tx_q_item->hostTag,
3355                tx_q_item->transmissionControl);
3356
3357             add_to_send_cfm_list(priv, tx_q_item, frames_need_cfm_list);
3358        }
3359    }
3360
3361    spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3362
3363    func_exit();
3364}
3365
3366
3367
3368void uf_flush_list(unifi_priv_t * priv, struct list_head * list)
3369{
3370    tx_buffered_packets_t *tx_q_item;
3371    struct list_head *listHead;
3372    struct list_head *placeHolder;
3373    unsigned long lock_flags;
3374
3375    unifi_trace(priv, UDBG5, "entering the uf_flush_list \n");
3376
3377    spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3378    /* go through list, delete & free memory */
3379    list_for_each_safe(listHead, placeHolder, list) {
3380        tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
3381
3382        if(!tx_q_item) {
3383            unifi_error(priv, "entry should exists, otherwise crashes (bug)\n");
3384        }
3385        unifi_trace(priv, UDBG5,
3386                "proccess_tx: in uf_flush_list peerMacAddress=%02X%02X%02X%02X%02X%02X senderProcessId=%x\n",
3387                tx_q_item->peerMacAddress.a[0], tx_q_item->peerMacAddress.a[1],
3388                tx_q_item->peerMacAddress.a[2], tx_q_item->peerMacAddress.a[3],
3389                tx_q_item->peerMacAddress.a[4], tx_q_item->peerMacAddress.a[5],
3390                tx_q_item->leSenderProcessId);
3391
3392        list_del(listHead);
3393        /* free the allocated memory */
3394        unifi_net_data_free(priv, &tx_q_item->bulkdata);
3395        kfree(tx_q_item);
3396        tx_q_item = NULL;
3397        if (!priv->noOfPktQueuedInDriver) {
3398            unifi_error(priv, "packets queued in driver 0 still decrementing in %s\n", __FUNCTION__);
3399        } else {
3400            priv->noOfPktQueuedInDriver--;
3401        }
3402    }
3403    spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3404}
3405
3406tx_buffered_packets_t *dequeue_tx_data_pdu(unifi_priv_t *priv, struct list_head *txList)
3407{
3408    /* dequeue the tx data packets from the appropriate queue */
3409    tx_buffered_packets_t *tx_q_item = NULL;
3410    struct list_head *listHead;
3411    struct list_head *placeHolder;
3412    unsigned long lock_flags;
3413
3414    unifi_trace(priv, UDBG5, "entering dequeue_tx_data_pdu\n");
3415    /* check for list empty */
3416    if (list_empty(txList)) {
3417        unifi_trace(priv, UDBG5, "In dequeue_tx_data_pdu, the list is empty\n");
3418        return NULL;
3419    }
3420
3421    /* Verification, if packet count is negetive */
3422    if (priv->noOfPktQueuedInDriver == 0xFFFF) {
3423        unifi_warning(priv, "no packet available in queue: debug");
3424        return NULL;
3425    }
3426
3427    /* return first node after header, & delete from the list && atleast one item exist */
3428    spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3429    list_for_each_safe(listHead, placeHolder, txList) {
3430        tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
3431        list_del(listHead);
3432        break;
3433    }
3434    spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3435
3436    if (tx_q_item) {
3437        unifi_trace(priv, UDBG5,
3438                "proccess_tx: In dequeue_tx_data_pdu peerMacAddress=%02X%02X%02X%02X%02X%02X senderProcessId=%x\n",
3439                tx_q_item->peerMacAddress.a[0], tx_q_item->peerMacAddress.a[1],
3440                tx_q_item->peerMacAddress.a[2], tx_q_item->peerMacAddress.a[3],
3441                tx_q_item->peerMacAddress.a[4], tx_q_item->peerMacAddress.a[5],
3442                tx_q_item->leSenderProcessId);
3443    }
3444
3445    unifi_trace(priv, UDBG5, "leaving dequeue_tx_data_pdu\n");
3446    return tx_q_item;
3447}
3448/* generic function to get the station record handler */
3449CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(unifi_priv_t *priv,
3450        const u8 *peerMacAddress,
3451        u16 interfaceTag)
3452{
3453    u8 i;
3454    netInterface_priv_t *interfacePriv;
3455    unsigned long lock_flags;
3456
3457    if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
3458        unifi_error(priv, "interfaceTag is not proper, interfaceTag = %d\n", interfaceTag);
3459        return NULL;
3460    }
3461
3462    interfacePriv = priv->interfacePriv[interfaceTag];
3463
3464    /* disable the preemption untill station record is fetched */
3465    spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
3466
3467    for (i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
3468        if (interfacePriv->staInfo[i]!= NULL) {
3469            if (!memcmp(((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[i]))->peerMacAddress.a, peerMacAddress, ETH_ALEN)) {
3470                /* enable the preemption as station record is fetched */
3471                spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
3472                unifi_trace(priv, UDBG5, "peer entry found in station record\n");
3473                return ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[i]));
3474            }
3475        }
3476    }
3477    /* enable the preemption as station record is fetched */
3478    spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
3479    unifi_trace(priv, UDBG5, "peer entry not found in station record\n");
3480    return NULL;
3481}
3482/* generic function to get the station record handler from the handle */
3483CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_priv_t *priv,
3484                                                                 u32 handle,
3485                                                                 u16 interfaceTag)
3486{
3487    netInterface_priv_t *interfacePriv;
3488
3489    if ((handle >= UNIFI_MAX_CONNECTIONS) || (interfaceTag >= CSR_WIFI_NUM_INTERFACES)) {
3490        unifi_error(priv, "handle/interfaceTag is not proper, handle = %d, interfaceTag = %d\n", handle, interfaceTag);
3491        return NULL;
3492    }
3493    interfacePriv = priv->interfacePriv[interfaceTag];
3494    return ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[handle]));
3495}
3496
3497/* Function to do inactivity */
3498void uf_check_inactivity(unifi_priv_t *priv, u16 interfaceTag, CsrTime currentTime)
3499{
3500    u32 i;
3501    CsrWifiRouterCtrlStaInfo_t *staInfo;
3502    CsrTime elapsedTime; /* Time in microseconds */
3503    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
3504    CsrWifiMacAddress peerMacAddress;
3505    unsigned long lock_flags;
3506
3507    if (interfacePriv == NULL) {
3508        unifi_trace(priv, UDBG3, "uf_check_inactivity: Interface priv is NULL \n");
3509        return;
3510    }
3511
3512    spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
3513    /* Go through the list of stations to check for inactivity */
3514    for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
3515        staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv, i, interfaceTag);
3516        if(!staInfo ) {
3517            continue;
3518        }
3519
3520        unifi_trace(priv, UDBG3, "Running Inactivity handler Time %xus station's last activity %xus\n",
3521                currentTime, staInfo->lastActivity);
3522
3523
3524        elapsedTime = (currentTime >= staInfo->lastActivity)?
3525                (currentTime - staInfo->lastActivity):
3526                (~((u32)0) - staInfo->lastActivity + currentTime);
3527        spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
3528
3529        if (elapsedTime > MAX_INACTIVITY_INTERVAL) {
3530            memcpy((u8*)&peerMacAddress, (u8*)&staInfo->peerMacAddress, sizeof(CsrWifiMacAddress));
3531
3532            /* Indicate inactivity for the station */
3533            unifi_trace(priv, UDBG3, "Station %x:%x:%x:%x:%x:%x inactive since %xus\n sending Inactive Ind\n",
3534                        peerMacAddress.a[0], peerMacAddress.a[1],
3535                        peerMacAddress.a[2], peerMacAddress.a[3],
3536                        peerMacAddress.a[4], peerMacAddress.a[5],
3537                        elapsedTime);
3538
3539            CsrWifiRouterCtrlStaInactiveIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, peerMacAddress);
3540        }
3541    }
3542
3543    interfacePriv->last_inactivity_check = currentTime;
3544}
3545
3546/* Function to update activity of a station */
3547void uf_update_sta_activity(unifi_priv_t *priv, u16 interfaceTag, const u8 *peerMacAddress)
3548{
3549    CsrTime elapsedTime, currentTime; /* Time in microseconds */
3550    CsrTime timeHi; /* Not used - Time in microseconds */
3551    CsrWifiRouterCtrlStaInfo_t *staInfo;
3552    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
3553    unsigned long lock_flags;
3554
3555    if (interfacePriv == NULL) {
3556        unifi_trace(priv, UDBG3, "uf_check_inactivity: Interface priv is NULL \n");
3557        return;
3558    }
3559
3560    currentTime = CsrTimeGet(&timeHi);
3561
3562
3563    staInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, peerMacAddress, interfaceTag);
3564
3565    if (staInfo == NULL) {
3566        unifi_trace(priv, UDBG4, "Sta does not exist yet");
3567        return;
3568    }
3569
3570    spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
3571    /* Update activity */
3572    staInfo->lastActivity = currentTime;
3573
3574    /* See if inactivity handler needs to be run
3575     * Here it is theoretically possible that the counter may have wrapped around. But
3576     * since we just want to know when to run the inactivity handler it does not really matter.
3577     * Especially since this is data path it makes sense in keeping it simple and avoiding
3578     * 64 bit handling */
3579    elapsedTime = (currentTime >= interfacePriv->last_inactivity_check)?
3580                    (currentTime - interfacePriv->last_inactivity_check):
3581                    (~((u32)0) - interfacePriv->last_inactivity_check + currentTime);
3582
3583    spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
3584
3585    /* Check if it is time to run the inactivity handler */
3586    if (elapsedTime > INACTIVITY_CHECK_INTERVAL) {
3587        uf_check_inactivity(priv, interfaceTag, currentTime);
3588    }
3589}
3590void resume_unicast_buffered_frames(unifi_priv_t *priv, u16 interfaceTag)
3591{
3592
3593   netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
3594   u8 i;
3595   int j;
3596   tx_buffered_packets_t * buffered_pkt = NULL;
3597   u8 hipslotFree[4] = {TRUE,TRUE,TRUE,TRUE};
3598   int r;
3599   unsigned long lock_flags;
3600
3601   func_enter();
3602   while(!isRouterBufferEnabled(priv,3) &&
3603                            ((buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMgtFrames))!=NULL)) {
3604        buffered_pkt->transmissionControl &=
3605                     ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
3606        if((r=frame_and_send_queued_pdu(priv,buffered_pkt,NULL,0,FALSE)) == -ENOSPC) {
3607            /* Enqueue at the head of the queue */
3608            spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3609            list_add(&buffered_pkt->q, &interfacePriv->genericMgtFrames);
3610            spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3611            hipslotFree[3]=FALSE;
3612            break;
3613        }else {
3614            if(r){
3615                unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
3616                /* the PDU failed where we can't do any thing so free the storage */
3617                unifi_net_data_free(priv, &buffered_pkt->bulkdata);
3618            }
3619            kfree(buffered_pkt);
3620        }
3621   }
3622   for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
3623        CsrWifiRouterCtrlStaInfo_t *staInfo = interfacePriv->staInfo[i];
3624        if(!hipslotFree[0] && !hipslotFree[1] && !hipslotFree[2] && !hipslotFree[3]) {
3625            unifi_trace(priv, UDBG3, "(ENOSPC) in resume_unicast_buffered_frames:: hip slots are full \n");
3626            break;
3627        }
3628        if (staInfo && (staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)) {
3629          while((( TRUE == hipslotFree[3] ) && (buffered_pkt=dequeue_tx_data_pdu(priv, &staInfo->mgtFrames)))) {
3630              buffered_pkt->transmissionControl &=
3631                           ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
3632              if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,0,FALSE)) == -ENOSPC) {
3633                  unifi_trace(priv, UDBG3, "(ENOSPC) in resume_unicast_buffered_frames:: hip slots are full for voice queue\n");
3634                  /* Enqueue at the head of the queue */
3635                  spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3636                  list_add(&buffered_pkt->q, &staInfo->mgtFrames);
3637                  spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3638                  priv->pausedStaHandle[3]=(u8)(staInfo->assignedHandle);
3639                  hipslotFree[3] = FALSE;
3640                  break;
3641              } else {
3642                  if(r){
3643                      unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
3644                      /* the PDU failed where we can't do any thing so free the storage */
3645                      unifi_net_data_free(priv, &buffered_pkt->bulkdata);
3646                  }
3647                  kfree(buffered_pkt);
3648              }
3649          }
3650
3651          for(j=3;j>=0;j--) {
3652              if(!hipslotFree[j])
3653                  continue;
3654
3655              while((buffered_pkt=dequeue_tx_data_pdu(priv, &staInfo->dataPdu[j]))) {
3656                 buffered_pkt->transmissionControl &=
3657                            ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
3658                 if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,0,FALSE)) == -ENOSPC) {
3659                     /* Enqueue at the head of the queue */
3660                     spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3661                     list_add(&buffered_pkt->q, &staInfo->dataPdu[j]);
3662                     spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3663                     priv->pausedStaHandle[j]=(u8)(staInfo->assignedHandle);
3664                     hipslotFree[j]=FALSE;
3665                     break;
3666                 } else {
3667                    if(r){
3668                        unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
3669                        /* the PDU failed where we can't do any thing so free the storage */
3670                        unifi_net_data_free(priv, &buffered_pkt->bulkdata);
3671                     }
3672                    kfree(buffered_pkt);
3673                 }
3674              }
3675          }
3676       }
3677    }
3678    func_exit();
3679}
3680void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,u16 interfaceTag)
3681{
3682
3683    netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
3684    unsigned long lock_flags;
3685    struct list_head *listHead;
3686    struct list_head *placeHolder;
3687    tx_buffered_packets_t *tx_q_item;
3688
3689    func_enter();
3690    if (interfacePriv->noOfbroadcastPktQueued) {
3691
3692        /* Update the EOSP to the HEAD of b/c list
3693         * beacuse we have received any mgmt packet so it should not hold for long time
3694         * peer may time out.
3695         */
3696        spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
3697        list_for_each_safe(listHead, placeHolder, &interfacePriv->genericMulticastOrBroadCastFrames) {
3698            tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
3699            tx_q_item->transmissionControl |= TRANSMISSION_CONTROL_EOSP_MASK;
3700            tx_q_item->transmissionControl = (tx_q_item->transmissionControl & ~(CSR_NO_CONFIRM_REQUIRED));
3701            unifi_trace(priv, UDBG1,"updating eosp for list Head hostTag:= 0x%x ",tx_q_item->hostTag);
3702            break;
3703        }
3704        spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
3705    }
3706    func_exit();
3707}
3708
3709/*
3710 * ---------------------------------------------------------------------------
3711 * resume_suspended_uapsd
3712 *
3713 * This function takes care processing packets of Unscheduled Service Period,
3714 * which been suspended earlier due to DTIM/HIP ENOSPC scenarios
3715 *
3716 * Arguments:
3717 * priv Pointer to device private context struct
3718 * interfaceTag For which resume should happen
3719 * ---------------------------------------------------------------------------
3720 */
3721void resume_suspended_uapsd(unifi_priv_t* priv,u16 interfaceTag)
3722{
3723
3724   u8 startIndex;
3725   CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
3726    unsigned long lock_flags;
3727
3728    unifi_trace(priv, UDBG2, "++resume_suspended_uapsd: \n");
3729    for(startIndex= 0; startIndex < UNIFI_MAX_CONNECTIONS;startIndex++) {
3730        staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv,startIndex,interfaceTag);
3731
3732        if(!staInfo || !staInfo->wmmOrQosEnabled) {
3733            continue;
3734        } else if((staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)
3735                   &&staInfo->uapsdActive && staInfo->uspSuspend) {
3736            /* U-APSD Still active & previously suspended either ENOSPC of FH queues OR
3737             * due to DTIM activity
3738             */
3739            uf_handle_uspframes_delivery(priv, staInfo, interfaceTag);
3740        } else {
3741            unifi_trace(priv, UDBG2, "resume_suspended_uapsd: PS state=%x, uapsdActive?=%x, suspend?=%x\n",
3742                        staInfo->currentPeerState, staInfo->uapsdActive, staInfo->uspSuspend);
3743            if (staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)
3744            {
3745                spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
3746                staInfo->uapsdActive = FALSE;
3747                staInfo->uspSuspend = FALSE;
3748                spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
3749            }
3750        }
3751    }
3752    unifi_trace(priv, UDBG2, "--resume_suspended_uapsd:\n");
3753}
3754
3755#endif
3756

Archive Download this file



interactive