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