3756 lines
165 KiB
C
3756 lines
165 KiB
C
/*
|
|
* ---------------------------------------------------------------------------
|
|
* FILE: unifi_pdu_processing.c
|
|
*
|
|
* PURPOSE:
|
|
* This file provides the PDU handling functionality before it gets sent to unfi and after
|
|
* receiving a PDU from unifi
|
|
*
|
|
* Copyright (C) 2010 by Cambridge Silicon Radio Ltd.
|
|
*
|
|
* Refer to LICENSE.txt included with this source code for details on
|
|
* the license terms.
|
|
*
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include "csr_wifi_hip_unifi.h"
|
|
#include "csr_wifi_hip_conversions.h"
|
|
#include "csr_time.h"
|
|
#include "unifi_priv.h"
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,13)
|
|
#include <net/iw_handler.h>
|
|
#endif
|
|
#include <net/pkt_sched.h>
|
|
|
|
#ifdef CSR_SUPPORT_SME
|
|
static void _update_buffered_pkt_params_after_alignment(unifi_priv_t *priv, bulk_data_param_t *bulkdata,
|
|
tx_buffered_packets_t* buffered_pkt)
|
|
{
|
|
struct sk_buff *skb ;
|
|
u32 align_offset;
|
|
|
|
if (priv == NULL || bulkdata == NULL || buffered_pkt == NULL){
|
|
return;
|
|
}
|
|
|
|
skb = (struct sk_buff*)bulkdata->d[0].os_net_buf_ptr;
|
|
align_offset = (u32)(long)(bulkdata->d[0].os_data_ptr) & (CSR_WIFI_ALIGN_BYTES-1);
|
|
if(align_offset){
|
|
skb_pull(skb,align_offset);
|
|
}
|
|
|
|
buffered_pkt->bulkdata.os_data_ptr = bulkdata->d[0].os_data_ptr;
|
|
buffered_pkt->bulkdata.data_length = bulkdata->d[0].data_length;
|
|
buffered_pkt->bulkdata.os_net_buf_ptr = bulkdata->d[0].os_net_buf_ptr;
|
|
buffered_pkt->bulkdata.net_buf_length = bulkdata->d[0].net_buf_length;
|
|
}
|
|
#endif
|
|
|
|
void
|
|
unifi_frame_ma_packet_req(unifi_priv_t *priv, CSR_PRIORITY priority,
|
|
CSR_RATE TransmitRate, CSR_CLIENT_TAG hostTag,
|
|
u16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
|
|
CSR_PROCESS_ID leSenderProcessId, u8 *peerMacAddress,
|
|
CSR_SIGNAL *signal)
|
|
{
|
|
|
|
CSR_MA_PACKET_REQUEST *req = &signal->u.MaPacketRequest;
|
|
netInterface_priv_t *interfacePriv;
|
|
u8 ba_session_idx = 0;
|
|
ba_session_tx_struct *ba_session = NULL;
|
|
u8 *ba_addr = NULL;
|
|
|
|
interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
unifi_trace(priv, UDBG5,
|
|
"In unifi_frame_ma_packet_req, Frame for Peer: %pMF\n",
|
|
peerMacAddress);
|
|
signal->SignalPrimitiveHeader.SignalId = CSR_MA_PACKET_REQUEST_ID;
|
|
signal->SignalPrimitiveHeader.ReceiverProcessId = 0;
|
|
signal->SignalPrimitiveHeader.SenderProcessId = leSenderProcessId;
|
|
|
|
/* Fill the MA-PACKET.req */
|
|
req->Priority = priority;
|
|
unifi_trace(priv, UDBG3, "Tx Frame with Priority: 0x%x\n", req->Priority);
|
|
|
|
/* A value of 0 is used for auto selection of rates. But for P2P GO case
|
|
* for action frames the rate is governed by SME. Hence instead of 0,
|
|
* the rate is filled in with the value passed here
|
|
*/
|
|
req->TransmitRate = TransmitRate;
|
|
|
|
/* packets from netdev then no confirm required but packets from
|
|
* Nme/Sme eapol data frames requires the confirmation
|
|
*/
|
|
req->TransmissionControl = transmissionControl;
|
|
req->VirtualInterfaceIdentifier =
|
|
uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag);
|
|
memcpy(req->Ra.x, peerMacAddress, ETH_ALEN);
|
|
|
|
if (hostTag == 0xffffffff) {
|
|
req->HostTag = interfacePriv->tag++;
|
|
req->HostTag |= 0x40000000;
|
|
unifi_trace(priv, UDBG3, "new host tag assigned = 0x%x\n", req->HostTag);
|
|
interfacePriv->tag &= 0x0fffffff;
|
|
} else {
|
|
req->HostTag = hostTag;
|
|
unifi_trace(priv, UDBG3, "host tag got from SME = 0x%x\n", req->HostTag);
|
|
}
|
|
/* check if BA session exists for the peer MAC address on same tID */
|
|
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
|
|
interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO){
|
|
ba_addr = peerMacAddress;
|
|
}else{
|
|
ba_addr = interfacePriv->bssid.a;
|
|
}
|
|
for (ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_TX; ba_session_idx++){
|
|
ba_session = interfacePriv->ba_session_tx[ba_session_idx];
|
|
if (ba_session){
|
|
if ((!memcmp(ba_session->macAddress.a, ba_addr, ETH_ALEN)) && (ba_session->tID == priority)){
|
|
req->TransmissionControl |= CSR_ALLOW_BA;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
unifi_trace(priv, UDBG5, "leaving unifi_frame_ma_packet_req\n");
|
|
}
|
|
|
|
#ifdef CSR_SUPPORT_SME
|
|
|
|
#define TRANSMISSION_CONTROL_TRIGGER_MASK 0x0001
|
|
#define TRANSMISSION_CONTROL_EOSP_MASK 0x0002
|
|
|
|
static
|
|
int frame_and_send_queued_pdu(unifi_priv_t* priv,tx_buffered_packets_t* buffered_pkt,
|
|
CsrWifiRouterCtrlStaInfo_t *staRecord,u8 moreData , u8 eosp)
|
|
{
|
|
|
|
CSR_SIGNAL signal;
|
|
bulk_data_param_t bulkdata;
|
|
int result;
|
|
u8 toDs, fromDs, macHeaderLengthInBytes = MAC_HEADER_SIZE;
|
|
u8 *qc;
|
|
u16 *fc = (u16*)(buffered_pkt->bulkdata.os_data_ptr);
|
|
unsigned long lock_flags;
|
|
unifi_trace(priv, UDBG3, "frame_and_send_queued_pdu with moreData: %d , EOSP: %d\n",moreData,eosp);
|
|
unifi_frame_ma_packet_req(priv, buffered_pkt->priority, buffered_pkt->rate, buffered_pkt->hostTag,
|
|
buffered_pkt->interfaceTag, buffered_pkt->transmissionControl,
|
|
buffered_pkt->leSenderProcessId, buffered_pkt->peerMacAddress.a, &signal);
|
|
bulkdata.d[0].os_data_ptr = buffered_pkt->bulkdata.os_data_ptr;
|
|
bulkdata.d[0].data_length = buffered_pkt->bulkdata.data_length;
|
|
bulkdata.d[0].os_net_buf_ptr = buffered_pkt->bulkdata.os_net_buf_ptr;
|
|
bulkdata.d[0].net_buf_length = buffered_pkt->bulkdata.net_buf_length;
|
|
bulkdata.d[1].os_data_ptr = NULL;
|
|
bulkdata.d[1].data_length = 0;
|
|
bulkdata.d[1].os_net_buf_ptr =0;
|
|
bulkdata.d[1].net_buf_length =0;
|
|
|
|
if(moreData) {
|
|
*fc |= cpu_to_le16(IEEE802_11_FC_MOREDATA_MASK);
|
|
} else {
|
|
*fc &= cpu_to_le16(~IEEE802_11_FC_MOREDATA_MASK);
|
|
}
|
|
|
|
if((staRecord != NULL)&& (staRecord->wmmOrQosEnabled == TRUE))
|
|
{
|
|
unifi_trace(priv, UDBG3, "frame_and_send_queued_pdu WMM Enabled: %d \n",staRecord->wmmOrQosEnabled);
|
|
|
|
toDs = (*fc & cpu_to_le16(IEEE802_11_FC_TO_DS_MASK))?1 : 0;
|
|
fromDs = (*fc & cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK))? 1: 0;
|
|
|
|
switch(le16_to_cpu(*fc) & IEEE80211_FC_SUBTYPE_MASK)
|
|
{
|
|
case IEEE802_11_FC_TYPE_QOS_DATA & IEEE80211_FC_SUBTYPE_MASK:
|
|
case IEEE802_11_FC_TYPE_QOS_NULL & IEEE80211_FC_SUBTYPE_MASK:
|
|
/* If both are set then the Address4 exists (only for AP) */
|
|
if (fromDs && toDs) {
|
|
/* 6 is the size of Address4 field */
|
|
macHeaderLengthInBytes += (QOS_CONTROL_HEADER_SIZE + 6);
|
|
} else {
|
|
macHeaderLengthInBytes += QOS_CONTROL_HEADER_SIZE;
|
|
}
|
|
|
|
/* If order bit set then HT control field is the part of MAC header */
|
|
if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
|
|
macHeaderLengthInBytes += HT_CONTROL_HEADER_SIZE;
|
|
qc = (u8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-6));
|
|
} else {
|
|
qc = (u8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-2));
|
|
}
|
|
*qc = eosp ? *qc | (1 << 4) : *qc & (~(1 << 4));
|
|
break;
|
|
default:
|
|
if (fromDs && toDs)
|
|
macHeaderLengthInBytes += 6;
|
|
}
|
|
|
|
}
|
|
result = ul_send_signal_unpacked(priv, &signal, &bulkdata);
|
|
if(result){
|
|
_update_buffered_pkt_params_after_alignment(priv, &bulkdata,buffered_pkt);
|
|
}
|
|
|
|
/* Decrement the packet counts queued in driver */
|
|
if (result != -ENOSPC) {
|
|
/* protect entire counter updation by disabling preemption */
|
|
if (!priv->noOfPktQueuedInDriver) {
|
|
unifi_error(priv, "packets queued in driver 0 still decrementing\n");
|
|
} else {
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
priv->noOfPktQueuedInDriver--;
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
}
|
|
/* Sta Record is available for all unicast (except genericMgt Frames) & in other case its NULL */
|
|
if (staRecord) {
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
if (!staRecord->noOfPktQueued) {
|
|
unifi_error(priv, "packets queued in driver per station is 0 still decrementing\n");
|
|
} else {
|
|
staRecord->noOfPktQueued--;
|
|
}
|
|
/* if the STA alive probe frame has failed then reset the saved host tag */
|
|
if (result){
|
|
if (staRecord->nullDataHostTag == buffered_pkt->hostTag){
|
|
staRecord->nullDataHostTag = INVALID_HOST_TAG;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
}
|
|
|
|
}
|
|
return result;
|
|
}
|
|
#ifdef CSR_SUPPORT_SME
|
|
static
|
|
void set_eosp_transmit_ctrl(unifi_priv_t *priv, struct list_head *txList)
|
|
{
|
|
/* dequeue the tx data packets from the appropriate queue */
|
|
tx_buffered_packets_t *tx_q_item = NULL;
|
|
struct list_head *listHead;
|
|
struct list_head *placeHolder;
|
|
unsigned long lock_flags;
|
|
|
|
|
|
unifi_trace(priv, UDBG5, "entering set_eosp_transmit_ctrl\n");
|
|
/* check for list empty */
|
|
if (list_empty(txList)) {
|
|
unifi_warning(priv, "In set_eosp_transmit_ctrl, the list is empty\n");
|
|
return;
|
|
}
|
|
|
|
/* return the last node , and modify it. */
|
|
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_for_each_prev_safe(listHead, placeHolder, txList) {
|
|
tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
|
|
tx_q_item->transmissionControl |= TRANSMISSION_CONTROL_EOSP_MASK;
|
|
tx_q_item->transmissionControl = (tx_q_item->transmissionControl & ~(CSR_NO_CONFIRM_REQUIRED));
|
|
unifi_trace(priv, UDBG1,
|
|
"set_eosp_transmit_ctrl Transmission Control = 0x%x hostTag = 0x%x \n",tx_q_item->transmissionControl,tx_q_item->hostTag);
|
|
unifi_trace(priv,UDBG3,"in set_eosp_transmit_ctrl no.of buffered frames %d\n",priv->noOfPktQueuedInDriver);
|
|
break;
|
|
}
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
unifi_trace(priv, UDBG1,"List Empty %d\n",list_empty(txList));
|
|
unifi_trace(priv, UDBG5, "leaving set_eosp_transmit_ctrl\n");
|
|
return;
|
|
}
|
|
|
|
static
|
|
void send_vif_availibility_rsp(unifi_priv_t *priv,CSR_VIF_IDENTIFIER vif,CSR_RESULT_CODE resultCode)
|
|
{
|
|
CSR_SIGNAL signal;
|
|
CSR_MA_VIF_AVAILABILITY_RESPONSE *rsp;
|
|
bulk_data_param_t *bulkdata = NULL;
|
|
int r;
|
|
|
|
unifi_trace(priv, UDBG3, "send_vif_availibility_rsp : invoked with resultCode = %d \n", resultCode);
|
|
|
|
memset(&signal,0,sizeof(CSR_SIGNAL));
|
|
rsp = &signal.u.MaVifAvailabilityResponse;
|
|
rsp->VirtualInterfaceIdentifier = vif;
|
|
rsp->ResultCode = resultCode;
|
|
signal.SignalPrimitiveHeader.SignalId = CSR_MA_VIF_AVAILABILITY_RESPONSE_ID;
|
|
signal.SignalPrimitiveHeader.ReceiverProcessId = 0;
|
|
signal.SignalPrimitiveHeader.SenderProcessId = priv->netdev_client->sender_id;
|
|
|
|
/* Send the signal to UniFi */
|
|
r = ul_send_signal_unpacked(priv, &signal, bulkdata);
|
|
if(r) {
|
|
unifi_error(priv,"Availibility response sending failed %x status %d\n",vif,r);
|
|
}
|
|
else {
|
|
unifi_trace(priv, UDBG3, "send_vif_availibility_rsp : status = %d \n", r);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static
|
|
void verify_and_accomodate_tx_packet(unifi_priv_t *priv)
|
|
{
|
|
tx_buffered_packets_t *tx_q_item;
|
|
unsigned long lock_flags;
|
|
struct list_head *listHead, *list;
|
|
struct list_head *placeHolder;
|
|
u8 i, j,eospFramedeleted=0;
|
|
u8 thresholdExcedeDueToBroadcast = TRUE;
|
|
/* it will be made it interface Specific in the future when multi interfaces are supported ,
|
|
right now interface 0 is considered */
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[0];
|
|
CsrWifiRouterCtrlStaInfo_t *staInfo = NULL;
|
|
|
|
unifi_trace(priv, UDBG3, "entering verify_and_accomodate_tx_packet\n");
|
|
|
|
for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
|
|
staInfo = interfacePriv->staInfo[i];
|
|
if (staInfo && (staInfo->noOfPktQueued >= CSR_WIFI_DRIVER_MAX_PKT_QUEUING_THRESHOLD_PER_PEER)) {
|
|
/* remove the first(oldest) packet from the all the access catogory, since data
|
|
* packets for station record crossed the threshold limit (64 for AP supporting
|
|
* 8 peers)
|
|
*/
|
|
unifi_trace(priv,UDBG3,"number of station pkts queued= %d for sta id = %d\n", staInfo->noOfPktQueued, staInfo->aid);
|
|
for(j = 0; j < MAX_ACCESS_CATOGORY; j++) {
|
|
list = &staInfo->dataPdu[j];
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_for_each_safe(listHead, placeHolder, list) {
|
|
tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
|
|
list_del(listHead);
|
|
thresholdExcedeDueToBroadcast = FALSE;
|
|
unifi_net_data_free(priv, &tx_q_item->bulkdata);
|
|
kfree(tx_q_item);
|
|
tx_q_item = NULL;
|
|
if (!priv->noOfPktQueuedInDriver) {
|
|
unifi_error(priv, "packets queued in driver 0 still decrementing in %s\n", __FUNCTION__);
|
|
} else {
|
|
/* protection provided by spinlock */
|
|
priv->noOfPktQueuedInDriver--;
|
|
|
|
}
|
|
/* Sta Record is available for all unicast (except genericMgt Frames) & in other case its NULL */
|
|
if (!staInfo->noOfPktQueued) {
|
|
unifi_error(priv, "packets queued in driver per station is 0 still decrementing in %s\n", __FUNCTION__);
|
|
} else {
|
|
spin_lock(&priv->staRecord_lock);
|
|
staInfo->noOfPktQueued--;
|
|
spin_unlock(&priv->staRecord_lock);
|
|
}
|
|
break;
|
|
}
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
}
|
|
}
|
|
}
|
|
if (thresholdExcedeDueToBroadcast && interfacePriv->noOfbroadcastPktQueued > CSR_WIFI_DRIVER_MINIMUM_BROADCAST_PKT_THRESHOLD ) {
|
|
/* Remove the packets from genericMulticastOrBroadCastFrames queue
|
|
* (the max packets in driver is reached due to broadcast/multicast frames)
|
|
*/
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_for_each_safe(listHead, placeHolder, &interfacePriv->genericMulticastOrBroadCastFrames) {
|
|
tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
|
|
if(eospFramedeleted){
|
|
tx_q_item->transmissionControl |= TRANSMISSION_CONTROL_EOSP_MASK;
|
|
tx_q_item->transmissionControl = (tx_q_item->transmissionControl & ~(CSR_NO_CONFIRM_REQUIRED));
|
|
unifi_trace(priv, UDBG1,"updating eosp for next packet hostTag:= 0x%x ",tx_q_item->hostTag);
|
|
eospFramedeleted =0;
|
|
break;
|
|
}
|
|
|
|
if(tx_q_item->transmissionControl & TRANSMISSION_CONTROL_EOSP_MASK ){
|
|
eospFramedeleted = 1;
|
|
}
|
|
unifi_trace(priv,UDBG1, "freeing of multicast packets ToC = 0x%x hostTag = 0x%x \n",tx_q_item->transmissionControl,tx_q_item->hostTag);
|
|
list_del(listHead);
|
|
unifi_net_data_free(priv, &tx_q_item->bulkdata);
|
|
kfree(tx_q_item);
|
|
priv->noOfPktQueuedInDriver--;
|
|
spin_lock(&priv->staRecord_lock);
|
|
interfacePriv->noOfbroadcastPktQueued--;
|
|
spin_unlock(&priv->staRecord_lock);
|
|
if(!eospFramedeleted){
|
|
break;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
}
|
|
unifi_trace(priv, UDBG3, "leaving verify_and_accomodate_tx_packet\n");
|
|
}
|
|
|
|
static
|
|
CsrResult enque_tx_data_pdu(unifi_priv_t *priv, bulk_data_param_t *bulkdata,
|
|
struct list_head *list, CSR_SIGNAL *signal,
|
|
u8 requeueOnSamePos)
|
|
{
|
|
|
|
/* queue the tx data packets on to appropriate queue */
|
|
CSR_MA_PACKET_REQUEST *req = &signal->u.MaPacketRequest;
|
|
tx_buffered_packets_t *tx_q_item;
|
|
unsigned long lock_flags;
|
|
|
|
unifi_trace(priv, UDBG5, "entering enque_tx_data_pdu\n");
|
|
if(!list) {
|
|
unifi_error(priv,"List is not specified\n");
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
|
|
/* Removes aged packets & adds the incoming packet */
|
|
if (priv->noOfPktQueuedInDriver >= CSR_WIFI_DRIVER_SUPPORT_FOR_MAX_PKT_QUEUEING) {
|
|
unifi_trace(priv,UDBG3,"number of pkts queued= %d \n", priv->noOfPktQueuedInDriver);
|
|
verify_and_accomodate_tx_packet(priv);
|
|
}
|
|
|
|
|
|
|
|
tx_q_item = (tx_buffered_packets_t *)kmalloc(sizeof(tx_buffered_packets_t), GFP_ATOMIC);
|
|
if (tx_q_item == NULL) {
|
|
unifi_error(priv,
|
|
"Failed to allocate %d bytes for tx packet record\n",
|
|
sizeof(tx_buffered_packets_t));
|
|
func_exit();
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
|
|
/* disable the preemption */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
INIT_LIST_HEAD(&tx_q_item->q);
|
|
/* fill the tx_q structure members */
|
|
tx_q_item->bulkdata.os_data_ptr = bulkdata->d[0].os_data_ptr;
|
|
tx_q_item->bulkdata.data_length = bulkdata->d[0].data_length;
|
|
tx_q_item->bulkdata.os_net_buf_ptr = bulkdata->d[0].os_net_buf_ptr;
|
|
tx_q_item->bulkdata.net_buf_length = bulkdata->d[0].net_buf_length;
|
|
tx_q_item->interfaceTag = req->VirtualInterfaceIdentifier & 0xff;
|
|
tx_q_item->hostTag = req->HostTag;
|
|
tx_q_item->leSenderProcessId = signal->SignalPrimitiveHeader.SenderProcessId;
|
|
tx_q_item->transmissionControl = req->TransmissionControl;
|
|
tx_q_item->priority = req->Priority;
|
|
tx_q_item->rate = req->TransmitRate;
|
|
memcpy(tx_q_item->peerMacAddress.a, req->Ra.x, ETH_ALEN);
|
|
|
|
|
|
|
|
if (requeueOnSamePos) {
|
|
list_add(&tx_q_item->q, list);
|
|
} else {
|
|
list_add_tail(&tx_q_item->q, list);
|
|
}
|
|
|
|
/* Count of packet queued in driver */
|
|
priv->noOfPktQueuedInDriver++;
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
unifi_trace(priv, UDBG5, "leaving enque_tx_data_pdu\n");
|
|
return CSR_RESULT_SUCCESS;
|
|
}
|
|
|
|
#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
|
|
CsrResult unifi_reque_ma_packet_request (void *ospriv, u32 host_tag,
|
|
u16 txStatus, bulk_data_desc_t *bulkDataDesc)
|
|
{
|
|
CsrResult status = CSR_RESULT_SUCCESS;
|
|
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
|
|
netInterface_priv_t *interfacePriv;
|
|
struct list_head *list = NULL;
|
|
CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
|
|
bulk_data_param_t bulkData;
|
|
CSR_SIGNAL signal;
|
|
CSR_PRIORITY priority = 0;
|
|
u16 interfaceTag = 0;
|
|
unifi_TrafficQueue priority_q;
|
|
u16 frameControl = 0, frameType = 0;
|
|
unsigned long lock_flags;
|
|
|
|
interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
/* If the current mode is not AP or P2PGO then just return failure
|
|
* to clear the hip slot
|
|
*/
|
|
if(!((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP) ||
|
|
(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO))) {
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
|
|
unifi_trace(priv, UDBG6, "unifi_reque_ma_packet_request: host_tag = 0x%x\n", host_tag);
|
|
|
|
staRecord = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,
|
|
(((u8 *) bulkDataDesc->os_data_ptr) + 4),
|
|
interfaceTag);
|
|
if (NULL == staRecord) {
|
|
unifi_trace(priv, UDBG5, "unifi_reque_ma_packet_request: Invalid STA record \n");
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
|
|
/* Update TIM if MA-PACKET.cfm fails with status as Tx-retry-limit or No-BSS and then just return failure
|
|
* to clear the hip slot associated with the Packet
|
|
*/
|
|
if (CSR_TX_RETRY_LIMIT == txStatus || CSR_TX_NO_BSS == txStatus) {
|
|
if (staRecord->timSet == CSR_WIFI_TIM_RESET || staRecord->timSet == CSR_WIFI_TIM_RESETTING)
|
|
{
|
|
unifi_trace(priv, UDBG2, "unifi_reque_ma_packet_request: CFM failed with Retry Limit or No BSS-->update TIM\n");
|
|
if (!staRecord->timRequestPendingFlag) {
|
|
update_tim(priv, staRecord->aid, 1, interfaceTag, staRecord->assignedHandle);
|
|
}
|
|
else {
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
staRecord->updateTimReqQueued = 1;
|
|
unifi_trace(priv, UDBG6, "unifi_reque_ma_packet_request: One more UpdateTim Request(:%d)Queued for AID %x\n",
|
|
staRecord->updateTimReqQueued, staRecord->aid);
|
|
}
|
|
}
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
else if ((CSR_TX_LIFETIME == txStatus) || (CSR_TX_BLOCK_ACK_TIMEOUT == txStatus) ||
|
|
(CSR_TX_FAIL_TRANSMISSION_VIF_INTERRUPTED == txStatus) ||
|
|
(CSR_TX_REJECTED_PEER_STATION_SLEEPING == txStatus) ||
|
|
(CSR_TX_REJECTED_DTIM_STARTED == txStatus)) {
|
|
/* Extract the Frame control and the frame type */
|
|
frameControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(bulkDataDesc->os_data_ptr);
|
|
frameType = ((frameControl & IEEE80211_FC_TYPE_MASK) >> FRAME_CONTROL_TYPE_FIELD_OFFSET);
|
|
|
|
/* Mgmt frames will not be re-queued for Tx
|
|
* so just return failure to clear the hip slot
|
|
*/
|
|
if (IEEE802_11_FRAMETYPE_MANAGEMENT == frameType) {
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
else if (IEEE802_11_FRAMETYPE_DATA == frameType) {
|
|
/* QOS NULL and DATA NULL frames will not be re-queued for Tx
|
|
* so just return failure to clear the hip slot
|
|
*/
|
|
if ((((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> FRAME_CONTROL_SUBTYPE_FIELD_OFFSET) == QOS_DATA_NULL) ||
|
|
(((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> FRAME_CONTROL_SUBTYPE_FIELD_OFFSET)== DATA_NULL )) {
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
}
|
|
|
|
/* Extract the Packet priority */
|
|
if (TRUE == staRecord->wmmOrQosEnabled) {
|
|
u16 qosControl = 0;
|
|
u8 dataFrameType = 0;
|
|
|
|
dataFrameType =((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> 4);
|
|
|
|
if (dataFrameType == QOS_DATA) {
|
|
/* QoS control field is offset from frame control by 2 (frame control)
|
|
* + 2 (duration/ID) + 2 (sequence control) + 3*ETH_ALEN or 4*ETH_ALEN
|
|
*/
|
|
if((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK)) {
|
|
qosControl= CSR_GET_UINT16_FROM_LITTLE_ENDIAN(bulkDataDesc->os_data_ptr + 30);
|
|
}
|
|
else {
|
|
qosControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(bulkDataDesc->os_data_ptr + 24);
|
|
}
|
|
}
|
|
|
|
priority = (CSR_PRIORITY)(qosControl & IEEE802_11_QC_TID_MASK);
|
|
|
|
if (priority < CSR_QOS_UP0 || priority > CSR_QOS_UP7) {
|
|
unifi_trace(priv, UDBG5, "unifi_reque_ma_packet_request: Invalid priority:%x \n", priority);
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
}
|
|
else {
|
|
priority = CSR_CONTENTION;
|
|
}
|
|
|
|
/* Frame Bulk data to requeue it back to HAL Queues */
|
|
bulkData.d[0].os_data_ptr = bulkDataDesc->os_data_ptr;
|
|
bulkData.d[0].data_length = bulkDataDesc->data_length;
|
|
bulkData.d[0].os_net_buf_ptr = bulkDataDesc->os_net_buf_ptr;
|
|
bulkData.d[0].net_buf_length = bulkDataDesc->net_buf_length;
|
|
|
|
bulkData.d[1].os_data_ptr = NULL;
|
|
bulkData.d[1].os_net_buf_ptr = NULL;
|
|
bulkData.d[1].data_length = bulkData.d[1].net_buf_length = 0;
|
|
|
|
/* Initialize signal to zero */
|
|
memset(&signal, 0, sizeof(CSR_SIGNAL));
|
|
|
|
/* Frame MA Packet Req */
|
|
unifi_frame_ma_packet_req(priv, priority, 0, host_tag,
|
|
interfaceTag, CSR_NO_CONFIRM_REQUIRED,
|
|
priv->netdev_client->sender_id,
|
|
staRecord->peerMacAddress.a, &signal);
|
|
|
|
/* Find the Q-Priority */
|
|
priority_q = unifi_frame_priority_to_queue(priority);
|
|
list = &staRecord->dataPdu[priority_q];
|
|
|
|
/* Place the Packet on to HAL Queue */
|
|
status = enque_tx_data_pdu(priv, &bulkData, list, &signal, TRUE);
|
|
|
|
/* Update the Per-station queued packet counter */
|
|
if (!status) {
|
|
spin_lock_irqsave(&priv->staRecord_lock, lock_flags);
|
|
staRecord->noOfPktQueued++;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock, lock_flags);
|
|
}
|
|
}
|
|
else {
|
|
/* Packet will not be re-queued for any of the other MA Packet Tx failure
|
|
* reasons so just return failure to clear the hip slot
|
|
*/
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
#endif
|
|
|
|
static void is_all_ac_deliver_enabled_and_moredata(CsrWifiRouterCtrlStaInfo_t *staRecord, u8 *allDeliveryEnabled, u8 *dataAvailable)
|
|
{
|
|
u8 i;
|
|
*allDeliveryEnabled = TRUE;
|
|
for (i = 0 ;i < MAX_ACCESS_CATOGORY; i++) {
|
|
if (!IS_DELIVERY_ENABLED(staRecord->powersaveMode[i])) {
|
|
/* One is is not Delivery Enabled */
|
|
*allDeliveryEnabled = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
if (*allDeliveryEnabled) {
|
|
*dataAvailable = (!list_empty(&staRecord->dataPdu[0]) || !list_empty(&staRecord->dataPdu[1])
|
|
||!list_empty(&staRecord->dataPdu[2]) ||!list_empty(&staRecord->dataPdu[3])
|
|
||!list_empty(&staRecord->mgtFrames));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* uf_handle_tim_cfm
|
|
*
|
|
*
|
|
* This function updates tim status in host depending confirm status from firmware
|
|
*
|
|
* Arguments:
|
|
* priv Pointer to device private context struct
|
|
* cfm CSR_MLME_SET_TIM_CONFIRM
|
|
* receiverProcessId SenderProcessID to fetch handle & timSet status
|
|
*
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, u16 receiverProcessId)
|
|
{
|
|
u8 handle = CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId);
|
|
u8 timSetStatus = CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId);
|
|
u16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
|
|
/* This variable holds what TIM value we wanted to set in firmware */
|
|
u16 timSetValue = 0;
|
|
/* Irrespective of interface the count maintained */
|
|
static u8 retryCount = 0;
|
|
unsigned long lock_flags;
|
|
unifi_trace(priv, UDBG3, "entering %s, handle = %x, timSetStatus = %x\n", __FUNCTION__, handle, timSetStatus);
|
|
|
|
if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
|
|
unifi_warning(priv, "bad interfaceTag = %x\n", interfaceTag);
|
|
return;
|
|
}
|
|
|
|
if ((handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) && (handle >= UNIFI_MAX_CONNECTIONS)) {
|
|
unifi_warning(priv, "bad station Handle = %x\n", handle);
|
|
return;
|
|
}
|
|
|
|
if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
if ((staRecord = ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[handle]))) == NULL) {
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
unifi_warning(priv, "uf_handle_tim_cfm: station record is NULL handle = %x\n", handle);
|
|
return;
|
|
}
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
}
|
|
switch(timSetStatus)
|
|
{
|
|
case CSR_WIFI_TIM_SETTING:
|
|
timSetValue = CSR_WIFI_TIM_SET;
|
|
break;
|
|
case CSR_WIFI_TIM_RESETTING:
|
|
timSetValue = CSR_WIFI_TIM_RESET;
|
|
break;
|
|
default:
|
|
unifi_warning(priv, "timSet state is %x: Debug\n", timSetStatus);
|
|
return;
|
|
}
|
|
|
|
/* check TIM confirm for success/failures */
|
|
switch(cfm->ResultCode)
|
|
{
|
|
case CSR_RC_SUCCESS:
|
|
if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
|
|
/* Unicast frame & station record available */
|
|
if (timSetStatus == staRecord->timSet) {
|
|
staRecord->timSet = timSetValue;
|
|
/* fh_cmd_q can also be full at some point of time!,
|
|
* resetting count as queue is cleaned by firmware at this point
|
|
*/
|
|
retryCount = 0;
|
|
unifi_trace(priv, UDBG2, "tim (%s) successfully in firmware\n", (timSetValue)?"SET":"RESET");
|
|
} else {
|
|
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",
|
|
receiverProcessId, timSetStatus, staRecord->timSet, handle);
|
|
}
|
|
|
|
/* Reset TIM pending flag to send next TIM request */
|
|
staRecord->timRequestPendingFlag = FALSE;
|
|
|
|
/* Make sure that one more UpdateTim request is queued, if Queued its value
|
|
* should be CSR_WIFI_TIM_SET or CSR_WIFI_TIM_RESET
|
|
*/
|
|
if (0xFF != staRecord->updateTimReqQueued)
|
|
{
|
|
/* Process the UpdateTim Request which is queued while previous UpdateTim was in progress */
|
|
if (staRecord->timSet != staRecord->updateTimReqQueued)
|
|
{
|
|
unifi_trace(priv, UDBG2, "uf_handle_tim_cfm : Processing Queued UpdateTimReq \n");
|
|
|
|
update_tim(priv, staRecord->aid, staRecord->updateTimReqQueued, interfaceTag, handle);
|
|
|
|
staRecord->updateTimReqQueued = 0xFF;
|
|
}
|
|
}
|
|
} else {
|
|
|
|
interfacePriv->bcTimSet = timSetValue;
|
|
/* fh_cmd_q can also be full at some point of time!,
|
|
* resetting count as queue is cleaned by firmware at this point
|
|
*/
|
|
retryCount = 0;
|
|
unifi_trace(priv, UDBG3, "tim (%s) successfully for broadcast frame in firmware\n", (timSetValue)?"SET":"RESET");
|
|
|
|
/* Reset DTIM pending flag to send next DTIM request */
|
|
interfacePriv->bcTimSetReqPendingFlag = FALSE;
|
|
|
|
/* Make sure that one more UpdateDTim request is queued, if Queued its value
|
|
* should be CSR_WIFI_TIM_SET or CSR_WIFI_TIM_RESET
|
|
*/
|
|
if (0xFF != interfacePriv->bcTimSetReqQueued)
|
|
{
|
|
/* Process the UpdateTim Request which is queued while previous UpdateTim was in progress */
|
|
if (interfacePriv->bcTimSet != interfacePriv->bcTimSetReqQueued)
|
|
{
|
|
unifi_trace(priv, UDBG2, "uf_handle_tim_cfm : Processing Queued UpdateDTimReq \n");
|
|
|
|
update_tim(priv, 0, interfacePriv->bcTimSetReqQueued, interfaceTag, 0xFFFFFFFF);
|
|
|
|
interfacePriv->bcTimSetReqQueued = 0xFF;
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case CSR_RC_INVALID_PARAMETERS:
|
|
case CSR_RC_INSUFFICIENT_RESOURCE:
|
|
/* check for max retry limit & send again
|
|
* MAX_RETRY_LIMIT is not maintained for each set of transactions..Its generic
|
|
* If failure crosses this Limit, we have to take a call to FIX
|
|
*/
|
|
if (retryCount > UNIFI_MAX_RETRY_LIMIT) {
|
|
u8 moreData = FALSE;
|
|
retryCount = 0;
|
|
/* Because of continuos traffic in fh_cmd_q the tim set request is failing (exceeding retry limit)
|
|
* but if we didn't synchronize our timSet varible state with firmware then it can cause below issues
|
|
* cond 1. We want to SET tim in firmware if its fails & max retry limit reached
|
|
* -> If host set's the timSet to 1, we wont try to send(as max retry reached) update tim but
|
|
* firmware is not updated with queue(TIM) status so it wont set TIM in beacon finally host start piling
|
|
* up data & wont try to set tim in firmware (This can cause worser performance)
|
|
* cond 2. We want to reset tim in firmware it fails & reaches max retry limit
|
|
* -> If host sets the timSet to Zero, it wont try to set a TIM request unless we wont have any packets
|
|
* to be queued, so beacon unnecessarily advertizes the TIM
|
|
*/
|
|
|
|
if(staRecord) {
|
|
if(!staRecord->wmmOrQosEnabled) {
|
|
moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
|
|
!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]) ||
|
|
!list_empty(&staRecord->mgtFrames));
|
|
} else {
|
|
/* Peer is QSTA */
|
|
u8 allDeliveryEnabled = 0, dataAvailable = 0;
|
|
/* Check if all AC's are Delivery Enabled */
|
|
is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
|
|
/*check for more data in non-delivery enabled queues*/
|
|
moreData = (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable));
|
|
|
|
}
|
|
/* To avoid cond 1 & 2, check internal Queues status, if we have more Data then set RESET the timSet(0),
|
|
* so we are trying to be in sync with firmware & next packets before queuing atleast try to
|
|
* set TIM in firmware otherwise it SET timSet(1)
|
|
*/
|
|
if (moreData) {
|
|
staRecord->timSet = CSR_WIFI_TIM_RESET;
|
|
} else {
|
|
staRecord->timSet = CSR_WIFI_TIM_SET;
|
|
}
|
|
} else {
|
|
/* Its a broadcast frames */
|
|
moreData = (!list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) ||
|
|
!list_empty(&interfacePriv->genericMulticastOrBroadCastFrames));
|
|
if (moreData) {
|
|
update_tim(priv, 0, CSR_WIFI_TIM_SET, interfaceTag, 0xFFFFFFFF);
|
|
} else {
|
|
update_tim(priv, 0, CSR_WIFI_TIM_RESET, interfaceTag, 0xFFFFFFFF);
|
|
}
|
|
}
|
|
|
|
unifi_error(priv, "no of error's for TIM setting crossed the Limit: verify\n");
|
|
return;
|
|
}
|
|
retryCount++;
|
|
|
|
if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
|
|
if (timSetStatus == staRecord->timSet) {
|
|
unifi_warning(priv, "tim request failed, retry for AID = %x\n", staRecord->aid);
|
|
update_tim(priv, staRecord->aid, timSetValue, interfaceTag, handle);
|
|
} else {
|
|
unifi_trace(priv, UDBG1, "failure: request & confirm states are not matching in TIM cfm: Debug status = %x, staRecord->timSet = %x\n",
|
|
timSetStatus, staRecord->timSet);
|
|
}
|
|
} else {
|
|
unifi_warning(priv, "tim request failed, retry for broadcast frames\n");
|
|
update_tim(priv, 0, timSetValue, interfaceTag, 0xFFFFFFFF);
|
|
}
|
|
break;
|
|
default:
|
|
unifi_warning(priv, "tim update request failed resultcode = %x\n", cfm->ResultCode);
|
|
}
|
|
|
|
unifi_trace(priv, UDBG2, "leaving %s\n", __FUNCTION__);
|
|
}
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* update_tim
|
|
*
|
|
*
|
|
* This function updates tim status in firmware for AID[1 to UNIFI_MAX_CONNECTIONS] or
|
|
* AID[0] for broadcast/multicast packets.
|
|
*
|
|
* NOTE: The LSB (least significant BYTE) of senderId while sending this MLME premitive
|
|
* has been modified(utilized) as below
|
|
*
|
|
* SenderID in signal's SignalPrimitiveHeader is 2 byte the lowe byte bitmap is below
|
|
*
|
|
* station handle(6 bits) timSet Status (2 bits)
|
|
* --------------------- ----------------------
|
|
* 0 0 0 0 0 0 | 0 0
|
|
*
|
|
* timSet Status can be one of below:
|
|
*
|
|
* CSR_WIFI_TIM_RESET
|
|
* CSR_WIFI_TIM_RESETTING
|
|
* CSR_WIFI_TIM_SET
|
|
* CSR_WIFI_TIM_SETTING
|
|
*
|
|
* Arguments:
|
|
* priv Pointer to device private context struct
|
|
* aid can be 1 t0 UNIFI_MAX_CONNECTIONS & 0 means multicast/broadcast
|
|
* setTim value SET(1) / RESET(0)
|
|
* interfaceTag the interfaceID on which activity going on
|
|
* handle from (0 <= handle < UNIFI_MAX_CONNECTIONS)
|
|
*
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
void update_tim(unifi_priv_t * priv, u16 aid, u8 setTim, u16 interfaceTag, u32 handle)
|
|
{
|
|
CSR_SIGNAL signal;
|
|
s32 r;
|
|
CSR_MLME_SET_TIM_REQUEST *req = &signal.u.MlmeSetTimRequest;
|
|
bulk_data_param_t *bulkdata = NULL;
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
u8 senderIdLsb = 0;
|
|
CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
|
|
u32 oldTimSetStatus = 0, timSetStatus = 0;
|
|
|
|
unifi_trace(priv, UDBG5, "entering the update_tim routine\n");
|
|
|
|
|
|
if (handle == 0xFFFFFFFF) {
|
|
handle &= CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE;
|
|
if (setTim == interfacePriv->bcTimSet)
|
|
{
|
|
unifi_trace(priv, UDBG3, "update_tim, Drop:Hdl=%x, timval=%d, globalTim=%d\n", handle, setTim, interfacePriv->bcTimSet);
|
|
return;
|
|
}
|
|
} else if ((handle != 0xFFFFFFFF) && (handle >= UNIFI_MAX_CONNECTIONS)) {
|
|
unifi_warning(priv, "bad station Handle = %x\n", handle);
|
|
return;
|
|
}
|
|
|
|
if (setTim) {
|
|
timSetStatus = CSR_WIFI_TIM_SETTING;
|
|
} else {
|
|
timSetStatus = CSR_WIFI_TIM_RESETTING;
|
|
}
|
|
|
|
if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
|
|
if ((staRecord = ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[handle]))) == NULL) {
|
|
unifi_warning(priv, "station record is NULL in update_tim: handle = %x :debug\n", handle);
|
|
return;
|
|
}
|
|
/* In case of signal sending failed, revert back to old state */
|
|
oldTimSetStatus = staRecord->timSet;
|
|
staRecord->timSet = timSetStatus;
|
|
}
|
|
|
|
/* pack senderID LSB */
|
|
senderIdLsb = CSR_WIFI_PACK_SENDER_ID_LSB_FOR_TIM_REQ(handle, timSetStatus);
|
|
|
|
/* initialize signal to zero */
|
|
memset(&signal, 0, sizeof(CSR_SIGNAL));
|
|
|
|
/* Frame the MLME-SET-TIM request */
|
|
signal.SignalPrimitiveHeader.SignalId = CSR_MLME_SET_TIM_REQUEST_ID;
|
|
signal.SignalPrimitiveHeader.ReceiverProcessId = 0;
|
|
CSR_COPY_UINT16_TO_LITTLE_ENDIAN(((priv->netdev_client->sender_id & 0xff00) | senderIdLsb),
|
|
(u8*)&signal.SignalPrimitiveHeader.SenderProcessId);
|
|
|
|
/* set The virtual interfaceIdentifier, aid, tim value */
|
|
req->VirtualInterfaceIdentifier = uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag);
|
|
req->AssociationId = aid;
|
|
req->TimValue = setTim;
|
|
|
|
|
|
unifi_trace(priv, UDBG2, "update_tim:AID %x,senderIdLsb = 0x%x, handle = 0x%x, timSetStatus = %x, sender proceesID = %x \n",
|
|
aid,senderIdLsb, handle, timSetStatus, signal.SignalPrimitiveHeader.SenderProcessId);
|
|
|
|
/* Send the signal to UniFi */
|
|
r = ul_send_signal_unpacked(priv, &signal, bulkdata);
|
|
if (r) {
|
|
/* No need to free bulk data, as TIM request doesn't carries any data */
|
|
unifi_error(priv, "Error queueing CSR_MLME_SET_TIM_REQUEST signal\n");
|
|
if (staRecord) {
|
|
staRecord->timSet = oldTimSetStatus ;
|
|
}
|
|
else
|
|
{
|
|
/* MLME_SET_TIM.req sending failed here for AID0, so revert back our bcTimSet status */
|
|
interfacePriv->bcTimSet = !setTim;
|
|
}
|
|
}
|
|
else {
|
|
/* Update tim request pending flag and ensure no more TIM set requests are send
|
|
for the same station until TIM confirm is received */
|
|
if (staRecord) {
|
|
staRecord->timRequestPendingFlag = TRUE;
|
|
}
|
|
else
|
|
{
|
|
/* Update tim request (for AID 0) pending flag and ensure no more DTIM set requests are send
|
|
* for the same station until TIM confirm is received
|
|
*/
|
|
interfacePriv->bcTimSetReqPendingFlag = TRUE;
|
|
}
|
|
}
|
|
unifi_trace(priv, UDBG5, "leaving the update_tim routine\n");
|
|
}
|
|
|
|
static
|
|
void process_peer_active_transition(unifi_priv_t * priv,
|
|
CsrWifiRouterCtrlStaInfo_t *staRecord,
|
|
u16 interfaceTag)
|
|
{
|
|
int r,i;
|
|
u8 spaceAvail[4] = {TRUE,TRUE,TRUE,TRUE};
|
|
tx_buffered_packets_t * buffered_pkt = NULL;
|
|
unsigned long lock_flags;
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
unifi_trace(priv, UDBG5, "entering process_peer_active_transition\n");
|
|
|
|
if(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
|
|
/* giving more priority to multicast packets so delaying unicast packets*/
|
|
unifi_trace(priv,UDBG2, "Multicast transmission is going on so resume unicast transmission after DTIM over\n");
|
|
|
|
/* As station is active now, even though AP is not able to send frames to it
|
|
* because of DTIM, it needs to reset the TIM here
|
|
*/
|
|
if (!staRecord->timRequestPendingFlag){
|
|
if((staRecord->timSet == CSR_WIFI_TIM_SET) || (staRecord->timSet == CSR_WIFI_TIM_SETTING)){
|
|
update_tim(priv, staRecord->aid, 0, interfaceTag, staRecord->assignedHandle);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
staRecord->updateTimReqQueued = 0;
|
|
unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
|
|
staRecord->aid);
|
|
}
|
|
return;
|
|
}
|
|
while((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->mgtFrames))) {
|
|
buffered_pkt->transmissionControl &=
|
|
~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,0,FALSE)) == -ENOSPC) {
|
|
unifi_trace(priv, UDBG2, "p_p_a_t:(ENOSPC) Mgt Frame queueing \n");
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &staRecord->mgtFrames);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
|
|
spaceAvail[3] = FALSE;
|
|
break;
|
|
} else {
|
|
if(r){
|
|
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
}
|
|
if (!staRecord->timRequestPendingFlag) {
|
|
if (staRecord->txSuspend) {
|
|
if(staRecord->timSet == CSR_WIFI_TIM_SET) {
|
|
update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
staRecord->updateTimReqQueued = 0;
|
|
unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
|
|
staRecord->aid);
|
|
}
|
|
for(i=3;i>=0;i--) {
|
|
if(!spaceAvail[i])
|
|
continue;
|
|
unifi_trace(priv, UDBG6, "p_p_a_t:data pkt sending for AC %d \n",i);
|
|
while((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[i]))) {
|
|
buffered_pkt->transmissionControl &=
|
|
~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,0,FALSE)) == -ENOSPC) {
|
|
/* Clear the trigger bit transmission control*/
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &staRecord->dataPdu[i]);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
priv->pausedStaHandle[i]=(u8)(staRecord->assignedHandle);
|
|
break;
|
|
} else {
|
|
if(r){
|
|
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
}
|
|
}
|
|
if (!staRecord->timRequestPendingFlag){
|
|
if((staRecord->timSet == CSR_WIFI_TIM_SET) || (staRecord->timSet == CSR_WIFI_TIM_SETTING)) {
|
|
unifi_trace(priv, UDBG3, "p_p_a_t:resetting tim .....\n");
|
|
update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
staRecord->updateTimReqQueued = 0;
|
|
unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
|
|
staRecord->aid);
|
|
}
|
|
unifi_trace(priv, UDBG5, "leaving process_peer_active_transition\n");
|
|
}
|
|
|
|
|
|
|
|
void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,u16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm)
|
|
{
|
|
netInterface_priv_t *interfacePriv;
|
|
u8 i;
|
|
CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
|
|
interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
|
|
if(pkt_cfm->HostTag == interfacePriv->multicastPduHostTag) {
|
|
unifi_trace(priv,UDBG2,"CFM for marked Multicast Tag = %x\n",interfacePriv->multicastPduHostTag);
|
|
interfacePriv->multicastPduHostTag = 0xffffffff;
|
|
resume_suspended_uapsd(priv,interfaceTag);
|
|
resume_unicast_buffered_frames(priv,interfaceTag);
|
|
if(list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) &&
|
|
list_empty(&interfacePriv->genericMulticastOrBroadCastFrames)) {
|
|
unifi_trace(priv,UDBG1,"Resetting multicastTIM");
|
|
if (!interfacePriv->bcTimSetReqPendingFlag)
|
|
{
|
|
update_tim(priv,0,CSR_WIFI_TIM_RESET,interfaceTag, 0xFFFFFFFF);
|
|
}
|
|
else
|
|
{
|
|
/* Cache the DTimSet value so that it will processed immidiatly after
|
|
* completing the current setDTim Request
|
|
*/
|
|
interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_RESET;
|
|
unifi_trace(priv, UDBG2, "uf_process_ma_pkt_cfm_for_ap : One more UpdateDTim Request(%d) Queued \n",
|
|
interfacePriv->bcTimSetReqQueued);
|
|
}
|
|
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Check if it is a Confirm for null data frame used
|
|
* for probing station activity
|
|
*/
|
|
for(i =0; i < UNIFI_MAX_CONNECTIONS; i++) {
|
|
staRecord = (CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[i]);
|
|
if (staRecord && (staRecord->nullDataHostTag == pkt_cfm->HostTag)) {
|
|
|
|
unifi_trace(priv, UDBG1, "CFM for Inactive probe Null frame (tag = %x, status = %d)\n",
|
|
pkt_cfm->HostTag,
|
|
pkt_cfm->TransmissionStatus
|
|
);
|
|
staRecord->nullDataHostTag = INVALID_HOST_TAG;
|
|
|
|
if(pkt_cfm->TransmissionStatus == CSR_TX_RETRY_LIMIT){
|
|
CsrTime now;
|
|
CsrTime inactive_time;
|
|
|
|
unifi_trace(priv, UDBG1, "Nulldata to probe STA ALIVE Failed with retry limit\n");
|
|
/* Recheck if there is some activity after null data is sent.
|
|
*
|
|
* If still there is no activity then send a disconnected indication
|
|
* to SME to delete the station record.
|
|
*/
|
|
if (staRecord->activity_flag){
|
|
return;
|
|
}
|
|
now = CsrTimeGet(NULL);
|
|
|
|
if (staRecord->lastActivity > now)
|
|
{
|
|
/* simple timer wrap (for 1 wrap) */
|
|
inactive_time = CsrTimeAdd((CsrTime)CsrTimeSub(CSR_SCHED_TIME_MAX, staRecord->lastActivity),
|
|
now);
|
|
}
|
|
else
|
|
{
|
|
inactive_time = (CsrTime)CsrTimeSub(now, staRecord->lastActivity);
|
|
}
|
|
|
|
if (inactive_time >= STA_INACTIVE_TIMEOUT_VAL)
|
|
{
|
|
struct list_head send_cfm_list;
|
|
u8 j;
|
|
|
|
/* The SME/NME may be waiting for confirmation for requested frames to this station.
|
|
* Though this is --VERY UNLIKELY-- in case of station in active mode. But still as a
|
|
* a defensive check, it loops through buffered frames for this station and if confirmation
|
|
* is requested, send auto confirmation with failure status. Also flush the frames so
|
|
* that these are not processed again in PEER_DEL_REQ handler.
|
|
*/
|
|
INIT_LIST_HEAD(&send_cfm_list);
|
|
|
|
uf_prepare_send_cfm_list_for_queued_pkts(priv,
|
|
&send_cfm_list,
|
|
&(staRecord->mgtFrames));
|
|
|
|
uf_flush_list(priv, &(staRecord->mgtFrames));
|
|
|
|
for(j = 0; j < MAX_ACCESS_CATOGORY; j++){
|
|
uf_prepare_send_cfm_list_for_queued_pkts(priv,
|
|
&send_cfm_list,
|
|
&(staRecord->dataPdu[j]));
|
|
|
|
uf_flush_list(priv,&(staRecord->dataPdu[j]));
|
|
}
|
|
|
|
send_auto_ma_packet_confirm(priv, staRecord->interfacePriv, &send_cfm_list);
|
|
|
|
|
|
|
|
unifi_warning(priv, "uf_process_ma_pkt_cfm_for_ap: Router Disconnected IND Peer (%x-%x-%x-%x-%x-%x)\n",
|
|
staRecord->peerMacAddress.a[0],
|
|
staRecord->peerMacAddress.a[1],
|
|
staRecord->peerMacAddress.a[2],
|
|
staRecord->peerMacAddress.a[3],
|
|
staRecord->peerMacAddress.a[4],
|
|
staRecord->peerMacAddress.a[5]);
|
|
|
|
CsrWifiRouterCtrlConnectedIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,
|
|
0,
|
|
staRecord->interfacePriv->InterfaceTag,
|
|
staRecord->peerMacAddress,
|
|
CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED);
|
|
}
|
|
|
|
}
|
|
else if (pkt_cfm->TransmissionStatus == CSR_TX_SUCCESSFUL)
|
|
{
|
|
staRecord->activity_flag = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
u16 uf_get_vif_identifier (CsrWifiRouterCtrlMode mode, u16 tag)
|
|
{
|
|
switch(mode)
|
|
{
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_STA:
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
|
|
return (0x02<<8|tag);
|
|
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_AP:
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
|
|
return (0x03<<8|tag);
|
|
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
|
|
return (0x01<<8|tag);
|
|
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_MONITOR:
|
|
return (0x04<<8|tag);
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_AMP:
|
|
return (0x05<<8|tag);
|
|
default:
|
|
return tag;
|
|
}
|
|
}
|
|
|
|
#ifdef CSR_SUPPORT_SME
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* update_macheader
|
|
*
|
|
*
|
|
* These functions updates mac header for intra BSS packet
|
|
* routing.
|
|
* NOTE: This function always has to be called in rx context which
|
|
* is in bh thread context since GFP_KERNEL is used. In soft IRQ/ Interrupt
|
|
* context shouldn't be used
|
|
*
|
|
* Arguments:
|
|
* priv Pointer to device private context struct
|
|
* skb Socket buffer containing data packet to transmit
|
|
* newSkb Socket buffer containing data packet + Mac header if no sufficient headroom in skb
|
|
* priority to append QOS control header in Mac header
|
|
* bulkdata if newSkb allocated then bulkdata updated to send to unifi
|
|
* interfaceTag the interfaceID on which activity going on
|
|
* macHeaderLengthInBytes no. of bytes of mac header in received frame
|
|
* qosDestination used to append Qos control field
|
|
*
|
|
* Returns:
|
|
* Zero on success or -1 on error.
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
|
|
static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
|
|
struct sk_buff *newSkb, CSR_PRIORITY *priority,
|
|
bulk_data_param_t *bulkdata, u16 interfaceTag,
|
|
u8 macHeaderLengthInBytes,
|
|
u8 qosDestination)
|
|
{
|
|
|
|
u16 *fc = NULL;
|
|
u8 direction = 0, toDs, fromDs;
|
|
u8 *bufPtr = NULL;
|
|
u8 sa[ETH_ALEN], da[ETH_ALEN];
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
int headroom;
|
|
u8 macHeaderBuf[IEEE802_11_DATA_FRAME_MAC_HEADER_SIZE] = {0};
|
|
|
|
unifi_trace(priv, UDBG5, "entering the update_macheader function\n");
|
|
|
|
/* temporary buffer for the Mac header storage */
|
|
memcpy(macHeaderBuf, skb->data, macHeaderLengthInBytes);
|
|
|
|
/* remove the Macheader from the skb */
|
|
skb_pull(skb, macHeaderLengthInBytes);
|
|
|
|
/* get the skb headroom for skb_push check */
|
|
headroom = skb_headroom(skb);
|
|
|
|
/* pointer to frame control field */
|
|
fc = (u16*) macHeaderBuf;
|
|
|
|
toDs = (*fc & cpu_to_le16(IEEE802_11_FC_TO_DS_MASK))?1 : 0;
|
|
fromDs = (*fc & cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK))? 1: 0;
|
|
unifi_trace(priv, UDBG5, "In update_macheader function, fromDs = %x, toDs = %x\n", fromDs, toDs);
|
|
direction = ((fromDs | (toDs << 1)) & 0x3);
|
|
|
|
/* Address1 or 3 from the macheader */
|
|
memcpy(da, macHeaderBuf+4+toDs*12, ETH_ALEN);
|
|
/* Address2, 3 or 4 from the mac header */
|
|
memcpy(sa, macHeaderBuf+10+fromDs*(6+toDs*8), ETH_ALEN);
|
|
|
|
unifi_trace(priv, UDBG3, "update_macheader:direction = %x\n", direction);
|
|
/* update the toDs, fromDs & address fields in Mac header */
|
|
switch(direction)
|
|
{
|
|
case 2:
|
|
/* toDs = 1 & fromDs = 0 , toAp when frames received from peer
|
|
* while sending this packet to Destination the Mac header changed
|
|
* as fromDs = 1 & toDs = 0, fromAp
|
|
*/
|
|
*fc &= cpu_to_le16(~IEEE802_11_FC_TO_DS_MASK);
|
|
*fc |= cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK);
|
|
/* Address1: MAC address of the actual destination (4 = 2+2) */
|
|
memcpy(macHeaderBuf + 4, da, ETH_ALEN);
|
|
/* Address2: The MAC address of the AP (10 = 2+2+6) */
|
|
memcpy(macHeaderBuf + 10, &interfacePriv->bssid, ETH_ALEN);
|
|
/* Address3: MAC address of the actual source from mac header (16 = 2+2+6+6) */
|
|
memcpy(macHeaderBuf + 16, sa, ETH_ALEN);
|
|
break;
|
|
case 3:
|
|
unifi_trace(priv, UDBG3, "when both the toDs & fromDS set, NOT SUPPORTED\n");
|
|
break;
|
|
default:
|
|
unifi_trace(priv, UDBG3, "problem in decoding packet in update_macheader \n");
|
|
return -1;
|
|
}
|
|
|
|
/* frameType is Data always, Validation is done before calling this function */
|
|
|
|
/* check for the souce station type */
|
|
switch(le16_to_cpu(*fc) & IEEE80211_FC_SUBTYPE_MASK)
|
|
{
|
|
case IEEE802_11_FC_TYPE_QOS_DATA & IEEE80211_FC_SUBTYPE_MASK:
|
|
/* No need to modify the qos control field */
|
|
if (!qosDestination) {
|
|
|
|
/* If source Sta is QOS enabled & if this bit set, then HTC is supported by
|
|
* peer station & htc field present in macHeader
|
|
*/
|
|
if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
|
|
/* HT control field present in Mac header
|
|
* 6 = sizeof(qosControl) + sizeof(htc)
|
|
*/
|
|
macHeaderLengthInBytes -= 6;
|
|
} else {
|
|
macHeaderLengthInBytes -= 2;
|
|
}
|
|
/* Destination STA is non qos so change subtype to DATA */
|
|
*fc &= cpu_to_le16(~IEEE80211_FC_SUBTYPE_MASK);
|
|
*fc |= cpu_to_le16(IEEE802_11_FC_TYPE_DATA);
|
|
/* remove the qos control field & HTC(if present). new macHeaderLengthInBytes is less than old
|
|
* macHeaderLengthInBytes so no need to verify skb headroom
|
|
*/
|
|
if (headroom < macHeaderLengthInBytes) {
|
|
unifi_trace(priv, UDBG1, " sufficient headroom not there to push updated mac header \n");
|
|
return -1;
|
|
}
|
|
bufPtr = (u8 *) skb_push(skb, macHeaderLengthInBytes);
|
|
|
|
/* update bulk data os_data_ptr */
|
|
bulkdata->d[0].os_data_ptr = skb->data;
|
|
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
|
|
bulkdata->d[0].data_length = skb->len;
|
|
|
|
} else {
|
|
/* pointing to QOS control field */
|
|
u8 qc;
|
|
if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
|
|
qc = *((u8*)(macHeaderBuf + (macHeaderLengthInBytes - 4 - 2)));
|
|
} else {
|
|
qc = *((u8*)(macHeaderBuf + (macHeaderLengthInBytes - 2)));
|
|
}
|
|
|
|
if ((qc & IEEE802_11_QC_TID_MASK) > 7) {
|
|
*priority = 7;
|
|
} else {
|
|
*priority = qc & IEEE802_11_QC_TID_MASK;
|
|
}
|
|
|
|
unifi_trace(priv, UDBG1, "Incoming packet priority from QSTA is %x\n", *priority);
|
|
|
|
if (headroom < macHeaderLengthInBytes) {
|
|
unifi_trace(priv, UDBG3, " sufficient headroom not there to push updated mac header \n");
|
|
return -1;
|
|
}
|
|
bufPtr = (u8 *) skb_push(skb, macHeaderLengthInBytes);
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
bulk_data_param_t data_ptrs;
|
|
CsrResult csrResult;
|
|
unifi_trace(priv, UDBG5, "normal Data packet, NO QOS \n");
|
|
|
|
if (qosDestination) {
|
|
u8 qc = 0;
|
|
unifi_trace(priv, UDBG3, "destination is QOS station \n");
|
|
|
|
/* Set Ma-Packet.req UP to UP0 */
|
|
*priority = CSR_QOS_UP0;
|
|
|
|
/* prepare the qos control field */
|
|
qc |= CSR_QOS_UP0;
|
|
/* no Amsdu is in ap buffer so eosp is left 0 */
|
|
if (da[0] & 0x1) {
|
|
/* multicast/broadcast frames, no acknowledgement needed */
|
|
qc |= 1 << 5;
|
|
}
|
|
|
|
/* update new Mac header Length with 2 = sizeof(qos control) */
|
|
macHeaderLengthInBytes += 2;
|
|
|
|
/* received DATA frame but destiantion is QOS station so update subtype to QOS*/
|
|
*fc &= cpu_to_le16(~IEEE80211_FC_SUBTYPE_MASK);
|
|
*fc |= cpu_to_le16(IEEE802_11_FC_TYPE_QOS_DATA);
|
|
|
|
/* appendQosControlOffset = macHeaderLengthInBytes - 2, since source sta is not QOS */
|
|
macHeaderBuf[macHeaderLengthInBytes - 2] = qc;
|
|
/* txopLimit is 0 */
|
|
macHeaderBuf[macHeaderLengthInBytes - 1] = 0;
|
|
if (headroom < macHeaderLengthInBytes) {
|
|
csrResult = unifi_net_data_malloc(priv, &data_ptrs.d[0], skb->len + macHeaderLengthInBytes);
|
|
|
|
if (csrResult != CSR_RESULT_SUCCESS) {
|
|
unifi_error(priv, " failed to allocate request_data. in update_macheader func\n");
|
|
return -1;
|
|
}
|
|
newSkb = (struct sk_buff *)(data_ptrs.d[0].os_net_buf_ptr);
|
|
newSkb->len = skb->len + macHeaderLengthInBytes;
|
|
|
|
memcpy((void*)data_ptrs.d[0].os_data_ptr + macHeaderLengthInBytes,
|
|
skb->data, skb->len);
|
|
|
|
bulkdata->d[0].os_data_ptr = newSkb->data;
|
|
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
|
|
bulkdata->d[0].data_length = newSkb->len;
|
|
|
|
bufPtr = (u8*)data_ptrs.d[0].os_data_ptr;
|
|
|
|
/* The old skb will not be used again */
|
|
kfree_skb(skb);
|
|
} else {
|
|
/* skb headroom is sufficient to append Macheader */
|
|
bufPtr = (u8*)skb_push(skb, macHeaderLengthInBytes);
|
|
bulkdata->d[0].os_data_ptr = skb->data;
|
|
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
|
|
bulkdata->d[0].data_length = skb->len;
|
|
}
|
|
} else {
|
|
unifi_trace(priv, UDBG3, "destination is not a QSTA\n");
|
|
if (headroom < macHeaderLengthInBytes) {
|
|
csrResult = unifi_net_data_malloc(priv, &data_ptrs.d[0], skb->len + macHeaderLengthInBytes);
|
|
|
|
if (csrResult != CSR_RESULT_SUCCESS) {
|
|
unifi_error(priv, " failed to allocate request_data. in update_macheader func\n");
|
|
return -1;
|
|
}
|
|
newSkb = (struct sk_buff *)(data_ptrs.d[0].os_net_buf_ptr);
|
|
newSkb->len = skb->len + macHeaderLengthInBytes;
|
|
|
|
memcpy((void*)data_ptrs.d[0].os_data_ptr + macHeaderLengthInBytes,
|
|
skb->data, skb->len);
|
|
|
|
bulkdata->d[0].os_data_ptr = newSkb->data;
|
|
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
|
|
bulkdata->d[0].data_length = newSkb->len;
|
|
|
|
bufPtr = (u8*)data_ptrs.d[0].os_data_ptr;
|
|
|
|
/* The old skb will not be used again */
|
|
kfree_skb(skb);
|
|
} else {
|
|
/* skb headroom is sufficient to append Macheader */
|
|
bufPtr = (u8*)skb_push(skb, macHeaderLengthInBytes);
|
|
bulkdata->d[0].os_data_ptr = skb->data;
|
|
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
|
|
bulkdata->d[0].data_length = skb->len;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* prepare the complete skb, by pushing the MAC header to the begining of the skb->data */
|
|
unifi_trace(priv, UDBG5, "updated Mac Header: %d \n",macHeaderLengthInBytes);
|
|
memcpy(bufPtr, macHeaderBuf, macHeaderLengthInBytes);
|
|
|
|
unifi_trace(priv, UDBG5, "leaving the update_macheader function\n");
|
|
return 0;
|
|
}
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* uf_ap_process_data_pdu
|
|
*
|
|
*
|
|
* Takes care of intra BSS admission control & routing packets within BSS
|
|
*
|
|
* Arguments:
|
|
* priv Pointer to device private context struct
|
|
* skb Socket buffer containing data packet to transmit
|
|
* ehdr ethernet header to fetch priority of packet
|
|
* srcStaInfo source stations record for connection verification
|
|
* packed_signal
|
|
* signal_len
|
|
* signal MA-PACKET.indication signal
|
|
* bulkdata if newSkb allocated then bulkdata updated to send to unifi
|
|
* macHeaderLengthInBytes no. of bytes of mac header in received frame
|
|
*
|
|
* Returns:
|
|
* Zero on success(ap processing complete) or -1 if packet also have to be sent to NETDEV.
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
int
|
|
uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
|
|
struct ethhdr *ehdr, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
|
|
const CSR_SIGNAL *signal,
|
|
bulk_data_param_t *bulkdata,
|
|
u8 macHeaderLengthInBytes)
|
|
{
|
|
const CSR_MA_PACKET_INDICATION *ind = &(signal->u.MaPacketIndication);
|
|
u16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0x00ff);
|
|
struct sk_buff *newSkb = NULL;
|
|
/* pointer to skb or private skb created using skb_copy() */
|
|
struct sk_buff *skbPtr = skb;
|
|
u8 sendToNetdev = FALSE;
|
|
u8 qosDestination = FALSE;
|
|
CSR_PRIORITY priority = CSR_CONTENTION;
|
|
CsrWifiRouterCtrlStaInfo_t *dstStaInfo = NULL;
|
|
netInterface_priv_t *interfacePriv;
|
|
|
|
unifi_trace(priv, UDBG5, "entering uf_ap_process_data_pdu %d\n",macHeaderLengthInBytes);
|
|
/* InterfaceTag validation from MA_PACKET.indication */
|
|
if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
|
|
unifi_trace(priv, UDBG1, "Interface Tag is Invalid in uf_ap_process_data_pdu\n");
|
|
unifi_net_data_free(priv, &bulkdata->d[0]);
|
|
return 0;
|
|
}
|
|
interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
if((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) &&
|
|
(interfacePriv->intraBssEnabled == FALSE)) {
|
|
unifi_trace(priv, UDBG2, "uf_ap_process_data_pdu:P2P GO intrabssEnabled?= %d\n", interfacePriv->intraBssEnabled);
|
|
|
|
/*In P2P GO case, if intraBSS distribution Disabled then don't do IntraBSS routing */
|
|
/* If destination in our BSS then drop otherwise give packet to netdev */
|
|
dstStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, ehdr->h_dest, interfaceTag);
|
|
if (dstStaInfo) {
|
|
unifi_net_data_free(priv, &bulkdata->d[0]);
|
|
return 0;
|
|
}
|
|
/* May be associated P2PCLI trying to send the packets on backbone (Netdev) */
|
|
return -1;
|
|
}
|
|
|
|
if(!memcmp(ehdr->h_dest, interfacePriv->bssid.a, ETH_ALEN)) {
|
|
/* This packet will be given to the TCP/IP stack since this packet is for us(AP)
|
|
* No routing needed */
|
|
unifi_trace(priv, UDBG4, "destination address is csr_ap\n");
|
|
return -1;
|
|
}
|
|
|
|
/* fetch the destination record from staion record database */
|
|
dstStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, ehdr->h_dest, interfaceTag);
|
|
|
|
/* AP mode processing, & if packet is unicast */
|
|
if(!dstStaInfo) {
|
|
if (!(ehdr->h_dest[0] & 0x1)) {
|
|
/* destination not in station record & its a unicast packet, so pass the packet to network stack */
|
|
unifi_trace(priv, UDBG3, "unicast frame & destination record not exist, send to netdev proto = %x\n", htons(skb->protocol));
|
|
return -1;
|
|
} else {
|
|
/* packet is multicast/broadcast */
|
|
/* copy the skb to skbPtr, send skb to netdev & skbPtr to multicast/broad cast list */
|
|
unifi_trace(priv, UDBG5, "skb_copy, in uf_ap_process_data_pdu, protocol = %x\n", htons(skb->protocol));
|
|
skbPtr = skb_copy(skb, GFP_KERNEL);
|
|
if(skbPtr == NULL) {
|
|
/* We don't have memory to don't send the frame in BSS*/
|
|
unifi_notice(priv, "broacast/multicast frame can't be sent in BSS No memeory: proto = %x\n", htons(skb->protocol));
|
|
return -1;
|
|
}
|
|
sendToNetdev = TRUE;
|
|
}
|
|
} else {
|
|
|
|
/* validate the Peer & Destination Station record */
|
|
if (uf_process_station_records_for_sending_data(priv, interfaceTag, srcStaInfo, dstStaInfo)) {
|
|
unifi_notice(priv, "uf_ap_process_data_pdu: station record validation failed \n");
|
|
interfacePriv->stats.rx_errors++;
|
|
unifi_net_data_free(priv, &bulkdata->d[0]);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* BroadCast packet received and it's been sent as non QOS packets.
|
|
* Since WMM spec not mandates broadcast/multicast to be sent as QOS data only,
|
|
* if all Peers are QSTA
|
|
*/
|
|
if(sendToNetdev) {
|
|
/* BroadCast packet and it's been sent as non QOS packets */
|
|
qosDestination = FALSE;
|
|
} else if(dstStaInfo && (dstStaInfo->wmmOrQosEnabled == TRUE)) {
|
|
qosDestination = TRUE;
|
|
}
|
|
|
|
unifi_trace(priv, UDBG3, "uf_ap_process_data_pdu QoS destination = %s\n", (qosDestination)? "TRUE": "FALSE");
|
|
|
|
/* packet is allowed to send to unifi, update the Mac header */
|
|
if (update_macheader(priv, skbPtr, newSkb, &priority, bulkdata, interfaceTag, macHeaderLengthInBytes, qosDestination)) {
|
|
interfacePriv->stats.rx_errors++;
|
|
unifi_notice(priv, "(Packet Drop) failed to update the Mac header in uf_ap_process_data_pdu\n");
|
|
if (sendToNetdev) {
|
|
/* Free's the skb_copy(skbPtr) data since packet processing failed */
|
|
bulkdata->d[0].os_data_ptr = skbPtr->data;
|
|
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skbPtr;
|
|
bulkdata->d[0].data_length = skbPtr->len;
|
|
unifi_net_data_free(priv, &bulkdata->d[0]);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
unifi_trace(priv, UDBG3, "Mac Header updated...calling uf_process_ma_packet_req \n");
|
|
|
|
/* Packet is ready to send to unifi ,transmissionControl = 0x0004, confirmation is not needed for data packets */
|
|
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)) {
|
|
if (sendToNetdev) {
|
|
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");
|
|
/* Free's the skb_copy(skbPtr) data since packet processing failed */
|
|
bulkdata->d[0].os_data_ptr = skbPtr->data;
|
|
bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skbPtr;
|
|
bulkdata->d[0].data_length = skbPtr->len;
|
|
unifi_net_data_free(priv, &bulkdata->d[0]);
|
|
} else {
|
|
/* This free's the skb data */
|
|
unifi_trace(priv, UDBG1, "In uf_ap_process_data_pdu, (Packet Drop). Unicast data so freeing original skb \n");
|
|
unifi_net_data_free(priv, &bulkdata->d[0]);
|
|
}
|
|
}
|
|
unifi_trace(priv, UDBG5, "leaving uf_ap_process_data_pdu\n");
|
|
|
|
if (sendToNetdev) {
|
|
/* The packet is multicast/broadcast, so after AP processing packet has to
|
|
* be sent to netdev, if peer port state is open
|
|
*/
|
|
unifi_trace(priv, UDBG4, "Packet will be routed to NetDev\n");
|
|
return -1;
|
|
}
|
|
/* Ap handled the packet & its a unicast packet, no need to send to netdev */
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
|
|
u8 *peerMacAddress,
|
|
CSR_CLIENT_TAG hostTag,
|
|
u16 interfaceTag,
|
|
CSR_TRANSMISSION_CONTROL transmissionControl,
|
|
CSR_RATE TransmitRate,
|
|
CSR_PRIORITY priority,
|
|
CSR_PROCESS_ID leSenderProcessId,
|
|
bulk_data_param_t *bulkdata)
|
|
{
|
|
CsrResult status = CSR_RESULT_SUCCESS;
|
|
CSR_SIGNAL signal;
|
|
int result;
|
|
#ifdef CSR_SUPPORT_SME
|
|
CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
|
|
const u8 *macHdrLocation = bulkdata->d[0].os_data_ptr;
|
|
CsrWifiPacketType pktType;
|
|
int frameType = 0;
|
|
u8 queuePacketDozing = FALSE;
|
|
u32 priority_q;
|
|
u16 frmCtrl;
|
|
struct list_head * list = NULL; /* List to which buffered PDUs are to be enqueued*/
|
|
u8 setBcTim=FALSE;
|
|
netInterface_priv_t *interfacePriv;
|
|
u8 requeueOnSamePos = FALSE;
|
|
u32 handle = 0xFFFFFFFF;
|
|
unsigned long lock_flags;
|
|
|
|
unifi_trace(priv, UDBG5,
|
|
"entering uf_process_ma_packet_req, peer: %pMF\n",
|
|
peerMacAddress);
|
|
|
|
if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
|
|
unifi_error(priv, "interfaceTag >= CSR_WIFI_NUM_INTERFACES, interfacetag = %d\n", interfaceTag);
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
|
|
/* fetch the station record for corresponding peer mac address */
|
|
if ((staRecord = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, peerMacAddress, interfaceTag))) {
|
|
handle = staRecord->assignedHandle;
|
|
}
|
|
|
|
/* Frame ma-packet.req, this is saved/transmitted depend on queue state */
|
|
unifi_frame_ma_packet_req(priv, priority, TransmitRate, hostTag,
|
|
interfaceTag, transmissionControl, leSenderProcessId,
|
|
peerMacAddress, &signal);
|
|
|
|
/* Since it's common path between STA & AP mode, in case of STA packet
|
|
* need not to be queued but in AP case we have to queue PDU's in
|
|
* different scenarios
|
|
*/
|
|
switch(interfacePriv->interfaceMode)
|
|
{
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_AP:
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
|
|
/* For this mode processing done below */
|
|
break;
|
|
default:
|
|
/* In case of STA/IBSS/P2PCLI/AMP, no checks needed send the packet down & return */
|
|
unifi_trace(priv, UDBG5, "In %s, interface mode is %x \n", __FUNCTION__, interfacePriv->interfaceMode);
|
|
if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_NONE) {
|
|
unifi_warning(priv, "In %s, interface mode NONE \n", __FUNCTION__);
|
|
}
|
|
if ((result = ul_send_signal_unpacked(priv, &signal, bulkdata))) {
|
|
status = CSR_RESULT_FAILURE;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/* -----Only AP/P2pGO mode handling falls below----- */
|
|
|
|
/* convert priority to queue */
|
|
priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
|
|
|
|
/* check the powersave status of the peer */
|
|
if (staRecord && (staRecord->currentPeerState ==
|
|
CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)) {
|
|
/* Peer is dozing & packet have to be delivered, so buffer the packet &
|
|
* update the TIM
|
|
*/
|
|
queuePacketDozing = TRUE;
|
|
}
|
|
|
|
/* find the type of frame unicast or mulicast/broadcast */
|
|
if (*peerMacAddress & 0x1) {
|
|
/* Multicast/broadCast data are always triggered by vif_availability.ind
|
|
* at the DTIM
|
|
*/
|
|
pktType = CSR_WIFI_MULTICAST_PDU;
|
|
} else {
|
|
pktType = CSR_WIFI_UNICAST_PDU;
|
|
}
|
|
|
|
/* Fetch the frame control field from mac header & check for frame type */
|
|
frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation);
|
|
|
|
/* Processing done according to Frame/Packet type */
|
|
frameType = ((frmCtrl & 0x000c) >> FRAME_CONTROL_TYPE_FIELD_OFFSET);
|
|
switch(frameType)
|
|
{
|
|
case IEEE802_11_FRAMETYPE_MANAGEMENT:
|
|
|
|
switch(pktType)
|
|
{
|
|
case CSR_WIFI_UNICAST_PDU:
|
|
unifi_trace(priv, UDBG5, "management unicast PDU in uf_process_ma_packet_req \n");
|
|
/* push the packet in to the queue with appropriate mgt list */
|
|
if (!staRecord) {
|
|
/* push the packet to the unifi if list is empty (if packet lost how to re-enque) */
|
|
if (list_empty(&interfacePriv->genericMgtFrames)) {
|
|
#ifdef CSR_SUPPORT_SME
|
|
if(!(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
|
|
#endif
|
|
|
|
unifi_trace(priv, UDBG3, "genericMgtFrames list is empty uf_process_ma_packet_req \n");
|
|
result = ul_send_signal_unpacked(priv, &signal, bulkdata);
|
|
/* reque only on ENOSPC */
|
|
if(result == -ENOSPC) {
|
|
/* requeue the failed packet to genericMgtFrame with same position */
|
|
unifi_trace(priv, UDBG1, "(ENOSPC) Sending genericMgtFrames Failed so buffering\n");
|
|
list = &interfacePriv->genericMgtFrames;
|
|
requeueOnSamePos = TRUE;
|
|
}
|
|
#ifdef CSR_SUPPORT_SME
|
|
}else{
|
|
list = &interfacePriv->genericMgtFrames;
|
|
unifi_trace(priv, UDBG3, "genericMgtFrames queue empty and dtim started\n hosttag is 0x%x,\n",signal.u.MaPacketRequest.HostTag);
|
|
update_eosp_to_head_of_broadcast_list_head(priv,interfaceTag);
|
|
}
|
|
#endif
|
|
} else {
|
|
/* Queue the packet to genericMgtFrame of unifi_priv_t data structure */
|
|
list = &interfacePriv->genericMgtFrames;
|
|
unifi_trace(priv, UDBG2, "genericMgtFrames queue not empty\n");
|
|
}
|
|
} else {
|
|
/* check peer power state */
|
|
if (queuePacketDozing || !list_empty(&staRecord->mgtFrames) || IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
|
|
/* peer is in dozing mode, so queue packet in mgt frame list of station record */
|
|
/*if multicast traffic is going on, buffer the unicast packets*/
|
|
list = &staRecord->mgtFrames;
|
|
|
|
unifi_trace(priv, UDBG1, "staRecord->MgtFrames list empty? = %s, handle = %d, queuePacketDozing = %d\n",
|
|
(list_empty(&staRecord->mgtFrames))? "YES": "NO", staRecord->assignedHandle, queuePacketDozing);
|
|
if(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)){
|
|
update_eosp_to_head_of_broadcast_list_head(priv,interfaceTag);
|
|
}
|
|
|
|
} else {
|
|
unifi_trace(priv, UDBG5, "staRecord->mgtFrames list is empty uf_process_ma_packet_req \n");
|
|
result = ul_send_signal_unpacked(priv, &signal, bulkdata);
|
|
if(result == -ENOSPC) {
|
|
/* requeue the failed packet to staRecord->mgtFrames with same position */
|
|
list = &staRecord->mgtFrames;
|
|
requeueOnSamePos = TRUE;
|
|
unifi_trace(priv, UDBG1, "(ENOSPC) Sending MgtFrames Failed handle = %d so buffering\n",staRecord->assignedHandle);
|
|
priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
|
|
} else if (result) {
|
|
status = CSR_RESULT_FAILURE;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case CSR_WIFI_MULTICAST_PDU:
|
|
unifi_trace(priv, UDBG5, "management multicast/broadcast PDU in uf_process_ma_packet_req 'QUEUE it' \n");
|
|
/* Queue the packet to genericMulticastOrBroadCastMgtFrames of unifi_priv_t data structure
|
|
* will be sent when we receive VIF AVAILABILITY from firmware as part of DTIM
|
|
*/
|
|
|
|
list = &interfacePriv->genericMulticastOrBroadCastMgtFrames;
|
|
if((interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_IBSS) &&
|
|
(list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames))) {
|
|
setBcTim=TRUE;
|
|
}
|
|
break;
|
|
default:
|
|
unifi_error(priv, "condition never meets: packet type unrecognized\n");
|
|
}
|
|
break;
|
|
case IEEE802_11_FRAMETYPE_DATA:
|
|
switch(pktType)
|
|
{
|
|
case CSR_WIFI_UNICAST_PDU:
|
|
unifi_trace(priv, UDBG5, "data unicast PDU in uf_process_ma_packet_req \n");
|
|
/* check peer power state, list status & peer port status */
|
|
if(!staRecord) {
|
|
unifi_error(priv, "In %s unicast but staRecord = NULL\n", __FUNCTION__);
|
|
return CSR_RESULT_FAILURE;
|
|
} else if (queuePacketDozing || isRouterBufferEnabled(priv,priority_q)|| !list_empty(&staRecord->dataPdu[priority_q]) || IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
|
|
/* peer is in dozing mode, so queue packet in mgt frame list of station record */
|
|
/* if multicast traffic is going on, buffet the unicast packets */
|
|
unifi_trace(priv, UDBG2, "Enqueued to staRecord->dataPdu[%d] queuePacketDozing=%d,\
|
|
Buffering enabled = %d \n", priority_q,queuePacketDozing,isRouterBufferEnabled(priv,priority_q));
|
|
list = &staRecord->dataPdu[priority_q];
|
|
} else {
|
|
unifi_trace(priv, UDBG5, "staRecord->dataPdu[%d] list is empty uf_process_ma_packet_req \n", priority_q);
|
|
/* Pdu allowed to send to unifi */
|
|
result = ul_send_signal_unpacked(priv, &signal, bulkdata);
|
|
if(result == -ENOSPC) {
|
|
/* requeue the failed packet to staRecord->dataPdu[priority_q] with same position */
|
|
unifi_trace(priv, UDBG1, "(ENOSPC) Sending Unicast DataPDU to queue %d Failed so buffering\n",priority_q);
|
|
requeueOnSamePos = TRUE;
|
|
list = &staRecord->dataPdu[priority_q];
|
|
priv->pausedStaHandle[priority_q]=(u8)(staRecord->assignedHandle);
|
|
if(!isRouterBufferEnabled(priv,priority_q)) {
|
|
unifi_error(priv,"Buffering Not enabled for queue %d \n",priority_q);
|
|
}
|
|
} else if (result) {
|
|
status = CSR_RESULT_FAILURE;
|
|
}
|
|
}
|
|
break;
|
|
case CSR_WIFI_MULTICAST_PDU:
|
|
unifi_trace(priv, UDBG5, "data multicast/broadcast PDU in uf_process_ma_packet_req \n");
|
|
/* Queue the packet to genericMulticastOrBroadCastFrames list of unifi_priv_t data structure
|
|
* will be sent when we receive VIF AVAILABILITY from firmware as part of DTIM
|
|
*/
|
|
list = &interfacePriv->genericMulticastOrBroadCastFrames;
|
|
if(list_empty(&interfacePriv->genericMulticastOrBroadCastFrames)) {
|
|
setBcTim = TRUE;
|
|
}
|
|
break;
|
|
default:
|
|
unifi_error(priv, "condition never meets: packet type un recognized\n");
|
|
}
|
|
break;
|
|
default:
|
|
unifi_error(priv, "unrecognized frame type\n");
|
|
}
|
|
if(list) {
|
|
status = enque_tx_data_pdu(priv, bulkdata,list, &signal,requeueOnSamePos);
|
|
/* Record no. of packet queued for each peer */
|
|
if (staRecord && (pktType == CSR_WIFI_UNICAST_PDU) && (!status)) {
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
staRecord->noOfPktQueued++;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
}
|
|
else if ((pktType == CSR_WIFI_MULTICAST_PDU) && (!status))
|
|
{
|
|
/* If broadcast Tim is set && queuing is successfull, then only update TIM */
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
interfacePriv->noOfbroadcastPktQueued++;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
}
|
|
}
|
|
/* If broadcast Tim is set && queuing is successfull, then only update TIM */
|
|
if(setBcTim && !status) {
|
|
unifi_trace(priv, UDBG3, "tim set due to broadcast pkt\n");
|
|
if (!interfacePriv->bcTimSetReqPendingFlag)
|
|
{
|
|
update_tim(priv,0,CSR_WIFI_TIM_SET,interfaceTag, handle);
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_SET;
|
|
unifi_trace(priv, UDBG2, "uf_process_ma_packet_req : One more UpdateDTim Request(:%d) Queued \n",
|
|
interfacePriv->bcTimSetReqQueued);
|
|
}
|
|
} else if(staRecord && staRecord->currentPeerState ==
|
|
CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE) {
|
|
if(staRecord->timSet == CSR_WIFI_TIM_RESET || staRecord->timSet == CSR_WIFI_TIM_RESETTING) {
|
|
if(!staRecord->wmmOrQosEnabled) {
|
|
if(!list_empty(&staRecord->mgtFrames) ||
|
|
!list_empty(&staRecord->dataPdu[3]) ||
|
|
!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION])) {
|
|
unifi_trace(priv, UDBG3, "tim set due to unicast pkt & peer in powersave\n");
|
|
if (!staRecord->timRequestPendingFlag){
|
|
update_tim(priv,staRecord->aid,1,interfaceTag, handle);
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
staRecord->updateTimReqQueued = 1;
|
|
unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
|
|
staRecord->aid);
|
|
}
|
|
}
|
|
} else {
|
|
/* Check for non delivery enable(i.e trigger enable), all delivery enable & legacy AC for TIM update in firmware */
|
|
u8 allDeliveryEnabled = 0, dataAvailable = 0;
|
|
/* Check if all AC's are Delivery Enabled */
|
|
is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
|
|
if (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable)
|
|
|| (!list_empty(&staRecord->mgtFrames))) {
|
|
if (!staRecord->timRequestPendingFlag) {
|
|
update_tim(priv,staRecord->aid,1,interfaceTag, handle);
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
staRecord->updateTimReqQueued = 1;
|
|
unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
|
|
staRecord->aid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if((list) && (pktType == CSR_WIFI_UNICAST_PDU && !queuePacketDozing) && !(isRouterBufferEnabled(priv,priority_q)) && !(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
|
|
unifi_trace(priv, UDBG2, "buffering cleared for queue = %d So resending buffered frames\n",priority_q);
|
|
uf_send_buffered_frames(priv, priority_q);
|
|
}
|
|
unifi_trace(priv, UDBG5, "leaving uf_process_ma_packet_req \n");
|
|
return status;
|
|
#else
|
|
#ifdef CSR_NATIVE_LINUX
|
|
if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
|
|
unifi_error(priv, "interfaceTag >= CSR_WIFI_NUM_INTERFACES, interfacetag = %d\n", interfaceTag);
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
/* Frame ma-packet.req, this is saved/transmitted depend on queue state */
|
|
unifi_frame_ma_packet_req(priv, priority, TransmitRate, hostTag, interfaceTag,
|
|
transmissionControl, leSenderProcessId,
|
|
peerMacAddress, &signal);
|
|
result = ul_send_signal_unpacked(priv, &signal, bulkdata);
|
|
if (result) {
|
|
return CSR_RESULT_FAILURE;
|
|
}
|
|
#endif
|
|
return status;
|
|
#endif
|
|
}
|
|
|
|
#ifdef CSR_SUPPORT_SME
|
|
s8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, u16 interfaceTag, const u8 *daddr)
|
|
{
|
|
s8 protection = 0;
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
switch(interfacePriv->interfaceMode)
|
|
{
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_STA:
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_AMP:
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
|
|
protection = interfacePriv->protect;
|
|
break;
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_AP:
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
|
|
{
|
|
CsrWifiRouterCtrlStaInfo_t *dstStaInfo = NULL;
|
|
if (daddr[0] & 0x1) {
|
|
unifi_trace(priv, UDBG3, "broadcast/multicast packet in send_ma_pkt_request\n");
|
|
/* In this mode, the protect member of priv structure has an information of how
|
|
* AP/P2PGO has started, & the member updated in set mode request for AP/P2PGO
|
|
*/
|
|
protection = interfacePriv->protect;
|
|
} else {
|
|
/* fetch the destination record from staion record database */
|
|
dstStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, daddr, interfaceTag);
|
|
if (!dstStaInfo) {
|
|
unifi_trace(priv, UDBG3, "peer not found in station record in send_ma_pkt_request\n");
|
|
return -1;
|
|
}
|
|
protection = dstStaInfo->protection;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
unifi_trace(priv, UDBG2, "mode unknown in send_ma_pkt_request\n");
|
|
}
|
|
return protection;
|
|
}
|
|
#endif
|
|
#ifdef CSR_SUPPORT_SME
|
|
u8 send_multicast_frames(unifi_priv_t *priv, u16 interfaceTag)
|
|
{
|
|
int r;
|
|
tx_buffered_packets_t * buffered_pkt = NULL;
|
|
u8 moreData = FALSE;
|
|
u8 pduSent =0;
|
|
unsigned long lock_flags;
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
u32 hostTag = 0xffffffff;
|
|
|
|
func_enter();
|
|
if(!isRouterBufferEnabled(priv,UNIFI_TRAFFIC_Q_VO)) {
|
|
while((interfacePriv->dtimActive)&& (buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMulticastOrBroadCastMgtFrames))) {
|
|
buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK);
|
|
moreData = (buffered_pkt->transmissionControl & TRANSMISSION_CONTROL_EOSP_MASK)?FALSE:TRUE;
|
|
|
|
|
|
unifi_trace(priv,UDBG2,"DTIM Occurred for interface:sending Mgt packet %d\n",interfaceTag);
|
|
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,NULL,moreData,FALSE)) == -ENOSPC) {
|
|
unifi_trace(priv,UDBG1,"frame_and_send_queued_pdu failed with ENOSPC for host tag = %x\n", buffered_pkt->hostTag);
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &interfacePriv->genericMulticastOrBroadCastMgtFrames);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
break;
|
|
} else {
|
|
unifi_trace(priv,UDBG1,"send_multicast_frames: Send genericMulticastOrBroadCastMgtFrames (%x, %x)\n",
|
|
buffered_pkt->hostTag,
|
|
r);
|
|
if(r) {
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
if(!moreData) {
|
|
|
|
interfacePriv->dtimActive = FALSE;
|
|
if(!r) {
|
|
hostTag = buffered_pkt->hostTag;
|
|
pduSent++;
|
|
} else {
|
|
send_vif_availibility_rsp(priv,uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag),CSR_RC_UNSPECIFIED_FAILURE);
|
|
}
|
|
}
|
|
/* Buffered frame sent successfully */
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
interfacePriv->noOfbroadcastPktQueued--;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
kfree(buffered_pkt);
|
|
}
|
|
|
|
}
|
|
}
|
|
if(!isRouterBufferEnabled(priv,UNIFI_TRAFFIC_Q_CONTENTION)) {
|
|
while((interfacePriv->dtimActive)&& (buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMulticastOrBroadCastFrames))) {
|
|
buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
|
|
moreData = (buffered_pkt->transmissionControl & TRANSMISSION_CONTROL_EOSP_MASK)?FALSE:TRUE;
|
|
|
|
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,NULL,moreData,FALSE)) == -ENOSPC) {
|
|
/* Clear the trigger bit transmission control*/
|
|
buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK);
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &interfacePriv->genericMulticastOrBroadCastFrames);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
break;
|
|
} else {
|
|
if(r) {
|
|
unifi_trace(priv,UDBG1,"send_multicast_frames: Send genericMulticastOrBroadCastFrame failed (%x, %x)\n",
|
|
buffered_pkt->hostTag,
|
|
r);
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
if(!moreData) {
|
|
interfacePriv->dtimActive = FALSE;
|
|
if(!r) {
|
|
pduSent ++;
|
|
hostTag = buffered_pkt->hostTag;
|
|
} else {
|
|
send_vif_availibility_rsp(priv,uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag),CSR_RC_UNSPECIFIED_FAILURE);
|
|
}
|
|
}
|
|
/* Buffered frame sent successfully */
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
interfacePriv->noOfbroadcastPktQueued--;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
kfree(buffered_pkt);
|
|
}
|
|
}
|
|
}
|
|
if((interfacePriv->dtimActive == FALSE)) {
|
|
/* Record the host Tag*/
|
|
unifi_trace(priv,UDBG2,"send_multicast_frames: Recorded hostTag of EOSP packet: = 0x%x\n",hostTag);
|
|
interfacePriv->multicastPduHostTag = hostTag;
|
|
}
|
|
return pduSent;
|
|
}
|
|
#endif
|
|
void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,u8 *sigdata,
|
|
u32 siglen)
|
|
{
|
|
#ifdef CSR_SUPPORT_SME
|
|
CSR_SIGNAL signal;
|
|
CSR_MA_VIF_AVAILABILITY_INDICATION *ind;
|
|
int r;
|
|
u16 interfaceTag;
|
|
u8 pduSent =0;
|
|
CSR_RESULT_CODE resultCode = CSR_RC_SUCCESS;
|
|
netInterface_priv_t *interfacePriv;
|
|
|
|
func_enter();
|
|
unifi_trace(priv, UDBG3,
|
|
"uf_process_ma_vif_availibility_ind: Process signal 0x%.4X\n",
|
|
*((u16*)sigdata));
|
|
|
|
r = read_unpack_signal(sigdata, &signal);
|
|
if (r) {
|
|
unifi_error(priv,
|
|
"uf_process_ma_vif_availibility_ind: Received unknown signal 0x%.4X.\n",
|
|
CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata));
|
|
func_exit();
|
|
return;
|
|
}
|
|
ind = &signal.u.MaVifAvailabilityIndication;
|
|
interfaceTag=ind->VirtualInterfaceIdentifier & 0xff;
|
|
|
|
if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
|
|
unifi_error(priv, "in vif_availability_ind interfaceTag is wrong\n");
|
|
return;
|
|
}
|
|
|
|
interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
if(ind->Multicast) {
|
|
if(list_empty(&interfacePriv->genericMulticastOrBroadCastFrames) &&
|
|
list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames)) {
|
|
/* This condition can occur because of a potential race where the
|
|
TIM is not yet reset as host is waiting for confirm but it is sent
|
|
by firmware and DTIM occurs*/
|
|
unifi_notice(priv,"ma_vif_availibility_ind recevied for multicast but queues are empty%d\n",interfaceTag);
|
|
send_vif_availibility_rsp(priv,ind->VirtualInterfaceIdentifier,CSR_RC_NO_BUFFERED_BROADCAST_MULTICAST_FRAMES);
|
|
interfacePriv->dtimActive = FALSE;
|
|
if(interfacePriv->multicastPduHostTag == 0xffffffff) {
|
|
unifi_notice(priv,"ma_vif_availibility_ind recevied for multicast but queues are empty%d\n",interfaceTag);
|
|
/* This may be an extra request in very rare race conditions but it is fine as it would atleast remove the potential lock up */
|
|
if (!interfacePriv->bcTimSetReqPendingFlag)
|
|
{
|
|
update_tim(priv,0,CSR_WIFI_TIM_RESET,interfaceTag, 0xFFFFFFFF);
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_RESET;
|
|
unifi_trace(priv, UDBG2, "uf_process_ma_vif_availibility_ind : One more UpdateDTim Request(%d) Queued \n",
|
|
interfacePriv->bcTimSetReqQueued);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if(interfacePriv->dtimActive) {
|
|
unifi_trace(priv,UDBG2,"DTIM Occurred for already active DTIM interface %d\n",interfaceTag);
|
|
return;
|
|
} else {
|
|
unifi_trace(priv,UDBG2,"DTIM Occurred for interface %d\n",interfaceTag);
|
|
if(list_empty(&interfacePriv->genericMulticastOrBroadCastFrames)) {
|
|
set_eosp_transmit_ctrl(priv,&interfacePriv->genericMulticastOrBroadCastMgtFrames);
|
|
} else {
|
|
set_eosp_transmit_ctrl(priv,&interfacePriv->genericMulticastOrBroadCastFrames);
|
|
}
|
|
}
|
|
interfacePriv->dtimActive = TRUE;
|
|
pduSent = send_multicast_frames(priv,interfaceTag);
|
|
}
|
|
else {
|
|
unifi_error(priv,"Interface switching is not supported %d\n",interfaceTag);
|
|
resultCode = CSR_RC_NOT_SUPPORTED;
|
|
send_vif_availibility_rsp(priv,ind->VirtualInterfaceIdentifier,CSR_RC_NOT_SUPPORTED);
|
|
}
|
|
#endif
|
|
}
|
|
#ifdef CSR_SUPPORT_SME
|
|
|
|
#define GET_ACTIVE_INTERFACE_TAG(priv) 0
|
|
|
|
static u8 uf_is_more_data_for_delivery_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t *staRecord)
|
|
{
|
|
s8 i;
|
|
|
|
for(i=UNIFI_TRAFFIC_Q_VO; i >= UNIFI_TRAFFIC_Q_BK; i--)
|
|
{
|
|
if(((staRecord->powersaveMode[i]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)
|
|
||(staRecord->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED))
|
|
&&(!list_empty(&staRecord->dataPdu[i]))) {
|
|
unifi_trace(priv,UDBG2,"uf_is_more_data_for_delivery_ac: Data Available AC = %d\n", i);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
unifi_trace(priv,UDBG2,"uf_is_more_data_for_delivery_ac: Data NOT Available \n");
|
|
return FALSE;
|
|
}
|
|
|
|
static u8 uf_is_more_data_for_usp_delivery(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t *staRecord, unifi_TrafficQueue queue)
|
|
{
|
|
s8 i;
|
|
|
|
for(i = queue; i >= UNIFI_TRAFFIC_Q_BK; i--)
|
|
{
|
|
if(((staRecord->powersaveMode[i]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)
|
|
||(staRecord->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED))
|
|
&&(!list_empty(&staRecord->dataPdu[i]))) {
|
|
unifi_trace(priv,UDBG2,"uf_is_more_data_for_usp_delivery: Data Available AC = %d\n", i);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
unifi_trace(priv,UDBG2,"uf_is_more_data_for_usp_delivery: Data NOT Available \n");
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* uf_send_buffered_data_from_delivery_ac
|
|
*
|
|
* This function takes care of
|
|
* -> Parsing the delivery enabled queue & sending frame down to HIP
|
|
* -> Setting EOSP=1 when USP to be terminated
|
|
* -> Depending on MAX SP length services the USP
|
|
*
|
|
* NOTE:This function always called from uf_handle_uspframes_delivery(), Dont
|
|
* call this function from any other location in code
|
|
*
|
|
* Arguments:
|
|
* priv Pointer to device private context struct
|
|
* vif interface specific HIP vif instance
|
|
* staInfo peer for which UAPSD to be scheduled
|
|
* queue AC from which Data to be sent in USP
|
|
* txList access category for processing list
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv,
|
|
CsrWifiRouterCtrlStaInfo_t * staInfo,
|
|
u8 queue,
|
|
struct list_head *txList)
|
|
{
|
|
|
|
u16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
|
|
tx_buffered_packets_t * buffered_pkt = NULL;
|
|
unsigned long lock_flags;
|
|
u8 eosp=FALSE;
|
|
s8 r =0;
|
|
u8 moreData = FALSE;
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
unifi_trace(priv, UDBG2, "++uf_send_buffered_data_from_delivery_ac, active=%x\n", staInfo->uapsdActive);
|
|
|
|
if (queue > UNIFI_TRAFFIC_Q_VO)
|
|
{
|
|
return;
|
|
}
|
|
while((buffered_pkt=dequeue_tx_data_pdu(priv, txList))) {
|
|
if((IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
|
|
unifi_trace(priv, UDBG2, "uf_send_buffered_data_from_delivery_ac: DTIM Active, suspend UAPSD, staId: 0x%x\n",
|
|
staInfo->aid);
|
|
|
|
/* Once resume called, the U-APSD delivery operation will resume */
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
staInfo->uspSuspend = TRUE;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
/* re-queueing the packet as DTIM started */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q,txList);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
break;
|
|
}
|
|
|
|
buffered_pkt->transmissionControl &=
|
|
~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
|
|
|
|
if((staInfo->wmmOrQosEnabled == TRUE)&&(staInfo->uapsdActive == TRUE)) {
|
|
|
|
buffered_pkt->transmissionControl = TRANSMISSION_CONTROL_TRIGGER_MASK;
|
|
|
|
/* Check All delivery enables Ac for more data, because caller of this
|
|
* function not aware about last packet
|
|
* (First check in moreData fetching helps in draining out Mgt frames Q)
|
|
*/
|
|
moreData = (!list_empty(txList) || uf_is_more_data_for_usp_delivery(priv, staInfo, queue));
|
|
|
|
if(staInfo->noOfSpFramesSent == (staInfo->maxSpLength - 1)) {
|
|
moreData = FALSE;
|
|
}
|
|
|
|
if(moreData == FALSE) {
|
|
eosp = TRUE;
|
|
buffered_pkt->transmissionControl =
|
|
(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
}
|
|
} else {
|
|
/* Non QoS and non U-APSD */
|
|
unifi_warning(priv, "uf_send_buffered_data_from_delivery_ac: non U-APSD !!! \n");
|
|
}
|
|
|
|
unifi_trace(priv,UDBG2,"uf_send_buffered_data_from_delivery_ac : MoreData:%d, EOSP:%d\n",moreData,eosp);
|
|
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,moreData,eosp)) == -ENOSPC) {
|
|
|
|
unifi_trace(priv, UDBG2, "uf_send_buffered_data_from_delivery_ac: UASPD suspended, ENOSPC in hipQ=%x\n", queue);
|
|
|
|
/* Once resume called, the U-APSD delivery operation will resume */
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
staInfo->uspSuspend = TRUE;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q,txList);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
priv->pausedStaHandle[queue]=(u8)(staInfo->assignedHandle);
|
|
break;
|
|
} else {
|
|
if(r){
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
staInfo->noOfSpFramesSent++;
|
|
if((!moreData) || (staInfo->noOfSpFramesSent == staInfo->maxSpLength)) {
|
|
unifi_trace(priv, UDBG2, "uf_send_buffered_data_from_delivery_ac: Terminating USP\n");
|
|
staInfo->uapsdActive = FALSE;
|
|
staInfo->uspSuspend = FALSE;
|
|
staInfo->noOfSpFramesSent = 0;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
break;
|
|
}
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
}
|
|
}
|
|
unifi_trace(priv, UDBG2, "--uf_send_buffered_data_from_delivery_ac, active=%x\n", staInfo->uapsdActive);
|
|
}
|
|
|
|
void uf_send_buffered_data_from_ac(unifi_priv_t *priv,
|
|
CsrWifiRouterCtrlStaInfo_t * staInfo,
|
|
u8 queue,
|
|
struct list_head *txList)
|
|
{
|
|
tx_buffered_packets_t * buffered_pkt = NULL;
|
|
unsigned long lock_flags;
|
|
u8 eosp=FALSE;
|
|
u8 moreData = FALSE;
|
|
s8 r =0;
|
|
|
|
func_enter();
|
|
|
|
unifi_trace(priv,UDBG2,"uf_send_buffered_data_from_ac :\n");
|
|
|
|
while(!isRouterBufferEnabled(priv,queue) &&
|
|
((buffered_pkt=dequeue_tx_data_pdu(priv, txList))!=NULL)){
|
|
|
|
buffered_pkt->transmissionControl &=
|
|
~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
|
|
|
|
unifi_trace(priv,UDBG3,"uf_send_buffered_data_from_ac : MoreData:%d, EOSP:%d\n",moreData,eosp);
|
|
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,moreData,eosp)) == -ENOSPC) {
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q,txList);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
if(staInfo != NULL){
|
|
priv->pausedStaHandle[queue]=(u8)(staInfo->assignedHandle);
|
|
}
|
|
unifi_trace(priv,UDBG3," uf_send_buffered_data_from_ac: PDU sending failed .. no space for queue %d \n",queue);
|
|
} else {
|
|
if(r){
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
}
|
|
|
|
func_exit();
|
|
|
|
}
|
|
|
|
void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue q)
|
|
{
|
|
u16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
|
|
u32 startIndex=0,endIndex=0;
|
|
CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
|
|
u8 queue;
|
|
u8 moreData = FALSE;
|
|
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
if(!((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP) ||
|
|
(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO)))
|
|
return;
|
|
func_enter();
|
|
|
|
queue = (q<=3)?q:0;
|
|
|
|
if(interfacePriv->dtimActive) {
|
|
/* this function updates dtimActive*/
|
|
send_multicast_frames(priv,interfaceTag);
|
|
if(!interfacePriv->dtimActive) {
|
|
moreData = (!list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) ||
|
|
!list_empty(&interfacePriv->genericMulticastOrBroadCastFrames));
|
|
if(!moreData) {
|
|
if (!interfacePriv->bcTimSetReqPendingFlag)
|
|
{
|
|
update_tim(priv,0,CSR_WIFI_TIM_RESET,interfaceTag, 0XFFFFFFFF);
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_RESET;
|
|
unifi_trace(priv, UDBG2, "uf_send_buffered_frames : One more UpdateDTim Request(%d) Queued \n",
|
|
interfacePriv->bcTimSetReqQueued);
|
|
}
|
|
}
|
|
} else {
|
|
moreData = (!list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) ||
|
|
!list_empty(&interfacePriv->genericMulticastOrBroadCastFrames));
|
|
if(!moreData) {
|
|
/* This should never happen but if it happens, we need a way out */
|
|
unifi_error(priv,"ERROR: No More Data but DTIM is active sending Response\n");
|
|
send_vif_availibility_rsp(priv,uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag),CSR_RC_NO_BUFFERED_BROADCAST_MULTICAST_FRAMES);
|
|
interfacePriv->dtimActive = FALSE;
|
|
}
|
|
}
|
|
func_exit();
|
|
return;
|
|
}
|
|
if(priv->pausedStaHandle[queue] > 7) {
|
|
priv->pausedStaHandle[queue] = 0;
|
|
}
|
|
|
|
if(queue == UNIFI_TRAFFIC_Q_VO) {
|
|
|
|
|
|
unifi_trace(priv,UDBG2,"uf_send_buffered_frames : trying mgt from queue=%d\n",queue);
|
|
for(startIndex= 0; startIndex < UNIFI_MAX_CONNECTIONS;startIndex++) {
|
|
staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv,startIndex,interfaceTag);
|
|
if(!staInfo ) {
|
|
continue;
|
|
} else if((staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)
|
|
&&(staInfo->uapsdActive == FALSE) ) {
|
|
continue;
|
|
}
|
|
|
|
if((staInfo != NULL)&&(staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)
|
|
&&(staInfo->uapsdActive == FALSE)){
|
|
/*Non-UAPSD case push the management frames out*/
|
|
if(!list_empty(&staInfo->mgtFrames)){
|
|
uf_send_buffered_data_from_ac(priv,staInfo, UNIFI_TRAFFIC_Q_VO, &staInfo->mgtFrames);
|
|
}
|
|
}
|
|
|
|
if(isRouterBufferEnabled(priv,queue)) {
|
|
unifi_notice(priv,"uf_send_buffered_frames : No space Left for queue = %d\n",queue);
|
|
break;
|
|
}
|
|
}
|
|
/*push generic management frames out*/
|
|
if(!list_empty(&interfacePriv->genericMgtFrames)) {
|
|
unifi_trace(priv,UDBG2,"uf_send_buffered_frames : trying generic mgt from queue=%d\n",queue);
|
|
uf_send_buffered_data_from_ac(priv,staInfo, UNIFI_TRAFFIC_Q_VO, &interfacePriv->genericMgtFrames);
|
|
}
|
|
}
|
|
|
|
|
|
unifi_trace(priv,UDBG2,"uf_send_buffered_frames : Resume called for Queue=%d\n",queue);
|
|
unifi_trace(priv,UDBG2,"uf_send_buffered_frames : start=%d end=%d\n",startIndex,endIndex);
|
|
|
|
startIndex = priv->pausedStaHandle[queue];
|
|
endIndex = (startIndex + UNIFI_MAX_CONNECTIONS -1) % UNIFI_MAX_CONNECTIONS;
|
|
|
|
while(startIndex != endIndex) {
|
|
staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv,startIndex,interfaceTag);
|
|
if(!staInfo) {
|
|
startIndex ++;
|
|
if(startIndex >= UNIFI_MAX_CONNECTIONS) {
|
|
startIndex = 0;
|
|
}
|
|
continue;
|
|
} else if((staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)
|
|
&&(staInfo->uapsdActive == FALSE)) {
|
|
startIndex ++;
|
|
if(startIndex >= UNIFI_MAX_CONNECTIONS) {
|
|
startIndex = 0;
|
|
}
|
|
continue;
|
|
}
|
|
/* Peer is active or U-APSD is active so send PDUs to the peer */
|
|
unifi_trace(priv,UDBG2,"uf_send_buffered_frames : trying data from queue=%d\n",queue);
|
|
|
|
|
|
if((staInfo != NULL)&&(staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)
|
|
&&(staInfo->uapsdActive == FALSE)) {
|
|
if(!list_empty(&staInfo->dataPdu[queue])) {
|
|
|
|
/*Non-UAPSD case push the AC frames out*/
|
|
uf_send_buffered_data_from_ac(priv, staInfo, queue, (&staInfo->dataPdu[queue]));
|
|
}
|
|
}
|
|
startIndex ++;
|
|
if(startIndex >= UNIFI_MAX_CONNECTIONS) {
|
|
startIndex = 0;
|
|
}
|
|
}
|
|
if(isRouterBufferEnabled(priv,queue)) {
|
|
priv->pausedStaHandle[queue] = endIndex;
|
|
} else {
|
|
priv->pausedStaHandle[queue] = 0;
|
|
}
|
|
|
|
/* U-APSD might have stopped because of ENOSPC in lib_hip (pause activity).
|
|
* So restart it if U-APSD was active with any of the station
|
|
*/
|
|
unifi_trace(priv, UDBG4, "csrWifiHipSendBufferedFrames: UAPSD Resume Q=%x\n", queue);
|
|
resume_suspended_uapsd(priv, interfaceTag);
|
|
func_exit();
|
|
}
|
|
|
|
|
|
u8 uf_is_more_data_for_non_delivery_ac(CsrWifiRouterCtrlStaInfo_t *staRecord)
|
|
{
|
|
u8 i;
|
|
|
|
for(i=0;i<=3;i++)
|
|
{
|
|
if(((staRecord->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_ONLY_ENABLED)
|
|
||(staRecord->powersaveMode[i]==CSR_WIFI_AC_LEGACY_POWER_SAVE))
|
|
&&(!list_empty(&staRecord->dataPdu[i]))){
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
if(((staRecord->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_TRIGGER_ONLY_ENABLED)
|
|
||(staRecord->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_LEGACY_POWER_SAVE))
|
|
&&(!list_empty(&staRecord->mgtFrames))){
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
int uf_process_station_records_for_sending_data(unifi_priv_t *priv,u16 interfaceTag,
|
|
CsrWifiRouterCtrlStaInfo_t *srcStaInfo,
|
|
CsrWifiRouterCtrlStaInfo_t *dstStaInfo)
|
|
{
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
unifi_trace(priv, UDBG5, "entering uf_process_station_records_for_sending_data\n");
|
|
|
|
if (srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED) {
|
|
unifi_error(priv, "Peer State not connected AID = %x, handle = %x, control port state = %x\n",
|
|
srcStaInfo->aid, srcStaInfo->assignedHandle, srcStaInfo->peerControlledPort->port_action);
|
|
return -1;
|
|
}
|
|
switch (interfacePriv->interfaceMode)
|
|
{
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_AP:
|
|
unifi_trace(priv, UDBG5, "mode is AP/P2PGO\n");
|
|
break;
|
|
default:
|
|
unifi_warning(priv, "mode is nor AP neither P2PGO, packet cant be xmit\n");
|
|
return -1;
|
|
}
|
|
|
|
switch(dstStaInfo->peerControlledPort->port_action)
|
|
{
|
|
case CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD:
|
|
case CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_BLOCK:
|
|
unifi_trace(priv, UDBG5, "destination port is closed/blocked, discarding the packet\n");
|
|
return -1;
|
|
default:
|
|
unifi_trace(priv, UDBG5, "destination port state is open\n");
|
|
}
|
|
|
|
/* port state is open, destination station record is valid, Power save state is
|
|
* validated in uf_process_ma_packet_req function
|
|
*/
|
|
unifi_trace(priv, UDBG5, "leaving uf_process_station_records_for_sending_data\n");
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* uf_handle_uspframes_delivery
|
|
*
|
|
* This function takes care of handling USP session for peer, when
|
|
* -> trigger frame from peer
|
|
* -> suspended USP to be processed (resumed)
|
|
*
|
|
* NOTE: uf_send_buffered_data_from_delivery_ac() always called from this function, Dont
|
|
* make a direct call to uf_send_buffered_data_from_delivery_ac() from any other part of
|
|
* code
|
|
*
|
|
* Arguments:
|
|
* priv Pointer to device private context struct
|
|
* staInfo peer for which UAPSD to be scheduled
|
|
* interfaceTag virtual interface tag
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
static void uf_handle_uspframes_delivery(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t *staInfo, u16 interfaceTag)
|
|
{
|
|
|
|
s8 i;
|
|
u8 allDeliveryEnabled = 0, dataAvailable = 0;
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
unsigned long lock_flags;
|
|
|
|
unifi_trace(priv, UDBG2, " ++ uf_handle_uspframes_delivery, uapsd active=%x, suspended?=%x\n",
|
|
staInfo->uapsdActive, staInfo->uspSuspend);
|
|
|
|
/* Check for Buffered frames according to priority order & deliver it
|
|
* 1. AC_VO delivery enable & Mgt frames available
|
|
* 2. Process remaining Ac's from order AC_VO to AC_BK
|
|
*/
|
|
|
|
/* USP initiated by WMMPS enabled peer & SET the status flag to TRUE */
|
|
if (!staInfo->uspSuspend && staInfo->uapsdActive)
|
|
{
|
|
unifi_notice(priv, "uf_handle_uspframes_delivery: U-APSD already active! STA=%x:%x:%x:%x:%x:%x\n",
|
|
staInfo->peerMacAddress.a[0], staInfo->peerMacAddress.a[1],
|
|
staInfo->peerMacAddress.a[2], staInfo->peerMacAddress.a[3],
|
|
staInfo->peerMacAddress.a[4], staInfo->peerMacAddress.a[5]);
|
|
return;
|
|
}
|
|
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
staInfo->uapsdActive = TRUE;
|
|
staInfo->uspSuspend = FALSE;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
|
|
if(((staInfo->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED)||
|
|
(staInfo->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE))
|
|
&& (!list_empty(&staInfo->mgtFrames))) {
|
|
|
|
/* Management queue has data && UNIFI_TRAFFIC_Q_VO is delivery enable */
|
|
unifi_trace(priv, UDBG4, "uf_handle_uspframes_delivery: Sending buffered management frames\n");
|
|
uf_send_buffered_data_from_delivery_ac(priv, staInfo, UNIFI_TRAFFIC_Q_VO, &staInfo->mgtFrames);
|
|
}
|
|
|
|
if (!uf_is_more_data_for_delivery_ac(priv, staInfo)) {
|
|
/* All delivery enable AC's are empty, so QNULL to be sent to terminate the USP
|
|
* NOTE: If we have sent Mgt frame also, we must send QNULL followed to terminate USP
|
|
*/
|
|
if (!staInfo->uspSuspend) {
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
staInfo->uapsdActive = FALSE;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
|
|
unifi_trace(priv, UDBG2, "uf_handle_uspframes_delivery: sending QNull for trigger\n");
|
|
uf_send_qos_null(priv, interfaceTag, staInfo->peerMacAddress.a, (CSR_PRIORITY) staInfo->triggerFramePriority, staInfo);
|
|
staInfo->triggerFramePriority = CSR_QOS_UP0;
|
|
} else {
|
|
unifi_trace(priv, UDBG2, "uf_handle_uspframes_delivery: MgtQ xfer suspended\n");
|
|
}
|
|
} else {
|
|
for(i = UNIFI_TRAFFIC_Q_VO; i >= UNIFI_TRAFFIC_Q_BK; i--) {
|
|
if(((staInfo->powersaveMode[i]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)
|
|
||(staInfo->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED))
|
|
&& (!list_empty(&staInfo->dataPdu[i]))) {
|
|
/* Deliver Data according to AC priority (from VO to BK) as part of USP */
|
|
unifi_trace(priv, UDBG4, "uf_handle_uspframes_delivery: Buffered data frames from Queue (%d) for USP\n", i);
|
|
uf_send_buffered_data_from_delivery_ac(priv, staInfo, i, &staInfo->dataPdu[i]);
|
|
}
|
|
|
|
if ((!staInfo->uapsdActive) ||
|
|
(staInfo->uspSuspend && IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
|
|
/* If DTIM active found on one AC, No need to parse the remaining AC's
|
|
* as USP suspended. Break out of loop
|
|
*/
|
|
unifi_trace(priv, UDBG2, "uf_handle_uspframes_delivery: suspend=%x, DTIM=%x, USP terminated=%s\n",
|
|
staInfo->uspSuspend, IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag),
|
|
staInfo->uapsdActive?"NO":"YES");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Depending on the USP status, update the TIM accordingly for delivery enabled AC only
|
|
* (since we are not manipulating any Non-delivery list(AC))
|
|
*/
|
|
is_all_ac_deliver_enabled_and_moredata(staInfo, &allDeliveryEnabled, &dataAvailable);
|
|
if ((allDeliveryEnabled && !dataAvailable)) {
|
|
if ((staInfo->timSet != CSR_WIFI_TIM_RESET) || (staInfo->timSet != CSR_WIFI_TIM_RESETTING)) {
|
|
staInfo->updateTimReqQueued = (u8) CSR_WIFI_TIM_RESET;
|
|
unifi_trace(priv, UDBG4, " --uf_handle_uspframes_delivery, UAPSD timset\n");
|
|
if (!staInfo->timRequestPendingFlag) {
|
|
update_tim(priv, staInfo->aid, 0, interfaceTag, staInfo->assignedHandle);
|
|
}
|
|
}
|
|
}
|
|
unifi_trace(priv, UDBG2, " --uf_handle_uspframes_delivery, uapsd active=%x, suspend?=%x\n",
|
|
staInfo->uapsdActive, staInfo->uspSuspend);
|
|
}
|
|
|
|
void uf_process_wmm_deliver_ac_uapsd(unifi_priv_t * priv,
|
|
CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
|
|
u16 qosControl,
|
|
u16 interfaceTag)
|
|
{
|
|
CSR_PRIORITY priority;
|
|
unifi_TrafficQueue priority_q;
|
|
unsigned long lock_flags;
|
|
|
|
unifi_trace(priv, UDBG2, "++uf_process_wmm_deliver_ac_uapsd: uapsdactive?=%x\n", srcStaInfo->uapsdActive);
|
|
/* If recceived Frames trigger Frame and Devlivery enabled AC has data
|
|
* then transmit from High priorty delivery enabled AC
|
|
*/
|
|
priority = (CSR_PRIORITY)(qosControl & IEEE802_11_QC_TID_MASK);
|
|
priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
|
|
|
|
if((srcStaInfo->powersaveMode[priority_q]==CSR_WIFI_AC_TRIGGER_ONLY_ENABLED)
|
|
||(srcStaInfo->powersaveMode[priority_q]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED)) {
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
srcStaInfo->triggerFramePriority = priority;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
unifi_trace(priv, UDBG2, "uf_process_wmm_deliver_ac_uapsd: trigger frame, Begin U-APSD, triggerQ=%x\n", priority_q);
|
|
uf_handle_uspframes_delivery(priv, srcStaInfo, interfaceTag);
|
|
}
|
|
unifi_trace(priv, UDBG2, "--uf_process_wmm_deliver_ac_uapsd: uapsdactive?=%x\n", srcStaInfo->uapsdActive);
|
|
}
|
|
|
|
|
|
void uf_send_qos_null(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
|
|
{
|
|
bulk_data_param_t bulkdata;
|
|
CsrResult csrResult;
|
|
struct sk_buff *skb, *newSkb = NULL;
|
|
CsrWifiMacAddress peerAddress;
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
CSR_TRANSMISSION_CONTROL transmissionControl = (TRANSMISSION_CONTROL_EOSP_MASK | TRANSMISSION_CONTROL_TRIGGER_MASK);
|
|
int r;
|
|
CSR_SIGNAL signal;
|
|
u32 priority_q;
|
|
CSR_RATE transmitRate = 0;
|
|
|
|
|
|
func_enter();
|
|
/* Send a Null Frame to Peer,
|
|
* 32= size of mac header */
|
|
csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], MAC_HEADER_SIZE + QOS_CONTROL_HEADER_SIZE);
|
|
|
|
if (csrResult != CSR_RESULT_SUCCESS) {
|
|
unifi_error(priv, " failed to allocate request_data. in uf_send_qos_null func\n");
|
|
return ;
|
|
}
|
|
skb = (struct sk_buff *)(bulkdata.d[0].os_net_buf_ptr);
|
|
skb->len = 0;
|
|
bulkdata.d[0].os_data_ptr = skb->data;
|
|
bulkdata.d[0].os_net_buf_ptr = (unsigned char*)skb;
|
|
bulkdata.d[0].net_buf_length = bulkdata.d[0].data_length = skb->len;
|
|
bulkdata.d[1].os_data_ptr = NULL;
|
|
bulkdata.d[1].os_net_buf_ptr = NULL;
|
|
bulkdata.d[1].net_buf_length = bulkdata.d[1].data_length = 0;
|
|
|
|
/* For null frames protection bit should not be set in MAC header, so passing value 0 below for protection field */
|
|
|
|
if (prepare_and_add_macheader(priv, skb, newSkb, priority, &bulkdata, interfaceTag, da, interfacePriv->bssid.a, 0)) {
|
|
unifi_error(priv, "failed to create MAC header\n");
|
|
unifi_net_data_free(priv, &bulkdata.d[0]);
|
|
return;
|
|
}
|
|
memcpy(peerAddress.a, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
|
|
/* convert priority to queue */
|
|
priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
|
|
|
|
/* Frame ma-packet.req, this is saved/transmitted depend on queue state
|
|
* send the null frame at data rate of 1 Mb/s for AP or 6 Mb/s for P2PGO
|
|
*/
|
|
switch (interfacePriv->interfaceMode)
|
|
{
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_AP:
|
|
transmitRate = 2;
|
|
break;
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
|
|
transmitRate = 12;
|
|
break;
|
|
default:
|
|
transmitRate = 0;
|
|
}
|
|
unifi_frame_ma_packet_req(priv, priority, transmitRate, 0xffffffff, interfaceTag,
|
|
transmissionControl, priv->netdev_client->sender_id,
|
|
peerAddress.a, &signal);
|
|
|
|
r = ul_send_signal_unpacked(priv, &signal, &bulkdata);
|
|
if(r) {
|
|
unifi_error(priv, "failed to send QOS data null packet result: %d\n",r);
|
|
unifi_net_data_free(priv, &bulkdata.d[0]);
|
|
}
|
|
|
|
func_exit();
|
|
return;
|
|
|
|
}
|
|
void uf_send_nulldata(unifi_priv_t * priv,u16 interfaceTag, const u8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
|
|
{
|
|
bulk_data_param_t bulkdata;
|
|
CsrResult csrResult;
|
|
struct sk_buff *skb, *newSkb = NULL;
|
|
CsrWifiMacAddress peerAddress;
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
CSR_TRANSMISSION_CONTROL transmissionControl = 0;
|
|
int r;
|
|
CSR_SIGNAL signal;
|
|
u32 priority_q;
|
|
CSR_RATE transmitRate = 0;
|
|
CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
|
|
unsigned long lock_flags;
|
|
|
|
func_enter();
|
|
/* Send a Null Frame to Peer, size = 24 for MAC header */
|
|
csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], MAC_HEADER_SIZE);
|
|
|
|
if (csrResult != CSR_RESULT_SUCCESS) {
|
|
unifi_error(priv, "uf_send_nulldata: Failed to allocate memory for NULL frame\n");
|
|
return ;
|
|
}
|
|
skb = (struct sk_buff *)(bulkdata.d[0].os_net_buf_ptr);
|
|
skb->len = 0;
|
|
bulkdata.d[0].os_data_ptr = skb->data;
|
|
bulkdata.d[0].os_net_buf_ptr = (unsigned char*)skb;
|
|
bulkdata.d[0].net_buf_length = bulkdata.d[0].data_length = skb->len;
|
|
bulkdata.d[1].os_data_ptr = NULL;
|
|
bulkdata.d[1].os_net_buf_ptr = NULL;
|
|
bulkdata.d[1].net_buf_length = bulkdata.d[1].data_length = 0;
|
|
|
|
/* For null frames protection bit should not be set in MAC header, so passing value 0 below for protection field */
|
|
if (prepare_and_add_macheader(priv, skb, newSkb, priority, &bulkdata, interfaceTag, da, interfacePriv->bssid.a, 0)) {
|
|
unifi_error(priv, "uf_send_nulldata: Failed to create MAC header\n");
|
|
unifi_net_data_free(priv, &bulkdata.d[0]);
|
|
return;
|
|
}
|
|
memcpy(peerAddress.a, ((u8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
|
|
/* convert priority to queue */
|
|
priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
|
|
transmissionControl &= ~(CSR_NO_CONFIRM_REQUIRED);
|
|
|
|
/* Frame ma-packet.req, this is saved/transmitted depend on queue state
|
|
* send the null frame at data rate of 1 Mb/s for AP or 6 Mb/s for P2PGO
|
|
*/
|
|
switch (interfacePriv->interfaceMode)
|
|
{
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_AP:
|
|
transmitRate = 2;
|
|
break;
|
|
case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
|
|
transmitRate = 12;
|
|
break;
|
|
default:
|
|
transmitRate = 0;
|
|
}
|
|
unifi_frame_ma_packet_req(priv, priority, transmitRate, INVALID_HOST_TAG, interfaceTag,
|
|
transmissionControl, priv->netdev_client->sender_id,
|
|
peerAddress.a, &signal);
|
|
|
|
/* Save host tag to check the status on reception of MA packet confirm */
|
|
srcStaInfo->nullDataHostTag = req->HostTag;
|
|
unifi_trace(priv, UDBG1, "uf_send_nulldata: STA AID = %d hostTag = %x\n", srcStaInfo->aid, req->HostTag);
|
|
|
|
r = ul_send_signal_unpacked(priv, &signal, &bulkdata);
|
|
|
|
if(r == -ENOSPC) {
|
|
unifi_trace(priv, UDBG1, "uf_send_nulldata: ENOSPC Requeue the Null frame\n");
|
|
enque_tx_data_pdu(priv, &bulkdata, &srcStaInfo->dataPdu[priority_q], &signal, 1);
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
srcStaInfo->noOfPktQueued++;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
|
|
|
|
}
|
|
if(r && r != -ENOSPC){
|
|
unifi_error(priv, "uf_send_nulldata: Failed to send Null frame Error = %d\n",r);
|
|
unifi_net_data_free(priv, &bulkdata.d[0]);
|
|
srcStaInfo->nullDataHostTag = INVALID_HOST_TAG;
|
|
}
|
|
|
|
func_exit();
|
|
return;
|
|
}
|
|
|
|
u8 uf_check_broadcast_bssid(unifi_priv_t *priv, const bulk_data_param_t *bulkdata)
|
|
{
|
|
u8 *bssid = NULL;
|
|
static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
|
|
u8 toDs, fromDs;
|
|
|
|
toDs = (((bulkdata->d[0].os_data_ptr)[1]) & 0x01) ? 1 : 0;
|
|
fromDs =(((bulkdata->d[0].os_data_ptr)[1]) & 0x02) ? 1 : 0;
|
|
|
|
if (toDs && fromDs)
|
|
{
|
|
unifi_trace(priv, UDBG6, "Address 4 present, Don't try to find BSSID\n");
|
|
bssid = NULL;
|
|
}
|
|
else if((toDs == 0) && (fromDs ==0))
|
|
{
|
|
/* BSSID is Address 3 */
|
|
bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4 + (2 * ETH_ALEN));
|
|
}
|
|
else if(toDs)
|
|
{
|
|
/* BSSID is Address 1 */
|
|
bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4);
|
|
}
|
|
else if(fromDs)
|
|
{
|
|
/* BSSID is Address 2 */
|
|
bssid = (u8 *) (bulkdata->d[0].os_data_ptr + 4 + ETH_ALEN);
|
|
}
|
|
|
|
if (memcmp(broadcast_address.a, bssid, ETH_ALEN)== 0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
u8 uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
|
|
u8 pmBit,u16 interfaceTag)
|
|
{
|
|
u8 moreData = FALSE;
|
|
u8 powerSaveChanged = FALSE;
|
|
unsigned long lock_flags;
|
|
|
|
unifi_trace(priv, UDBG3, "entering uf_process_pm_bit_for_peer\n");
|
|
if (pmBit) {
|
|
priv->allPeerDozing |= (0x01 << (srcStaInfo->assignedHandle));
|
|
} else {
|
|
priv->allPeerDozing &= ~(0x01 << (srcStaInfo->assignedHandle));
|
|
}
|
|
if(pmBit) {
|
|
if(srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE) {
|
|
|
|
/* disable the preemption */
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
srcStaInfo->currentPeerState =CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE;
|
|
powerSaveChanged = TRUE;
|
|
/* enable the preemption */
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
} else {
|
|
return powerSaveChanged;
|
|
}
|
|
} else {
|
|
if(srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE) {
|
|
/* disable the preemption */
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
srcStaInfo->currentPeerState = CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE;
|
|
powerSaveChanged = TRUE;
|
|
/* enable the preemption */
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
}else {
|
|
return powerSaveChanged;
|
|
}
|
|
}
|
|
|
|
|
|
if(srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE) {
|
|
unifi_trace(priv,UDBG3, "Peer with AID = %d is active now\n",srcStaInfo->aid);
|
|
process_peer_active_transition(priv,srcStaInfo,interfaceTag);
|
|
} else {
|
|
unifi_trace(priv,UDBG3, "Peer with AID = %d is in PS Now\n",srcStaInfo->aid);
|
|
/* Set TIM if needed */
|
|
if(!srcStaInfo->wmmOrQosEnabled) {
|
|
moreData = (!list_empty(&srcStaInfo->mgtFrames) ||
|
|
!list_empty(&srcStaInfo->dataPdu[UNIFI_TRAFFIC_Q_VO])||
|
|
!list_empty(&srcStaInfo->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]));
|
|
if(moreData && (srcStaInfo->timSet == CSR_WIFI_TIM_RESET)) {
|
|
unifi_trace(priv, UDBG3, "This condition should not occur\n");
|
|
if (!srcStaInfo->timRequestPendingFlag){
|
|
update_tim(priv,srcStaInfo->aid,1,interfaceTag, srcStaInfo->assignedHandle);
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
srcStaInfo->updateTimReqQueued = 1;
|
|
unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", srcStaInfo->updateTimReqQueued,
|
|
srcStaInfo->aid);
|
|
}
|
|
|
|
}
|
|
} else {
|
|
u8 allDeliveryEnabled = 0, dataAvailable = 0;
|
|
unifi_trace(priv, UDBG5, "Qos in AP Mode\n");
|
|
/* Check if all AC's are Delivery Enabled */
|
|
is_all_ac_deliver_enabled_and_moredata(srcStaInfo, &allDeliveryEnabled, &dataAvailable);
|
|
/*check for more data in non-delivery enabled queues*/
|
|
moreData = (uf_is_more_data_for_non_delivery_ac(srcStaInfo) || (allDeliveryEnabled && dataAvailable));
|
|
|
|
if(moreData && (srcStaInfo->timSet == CSR_WIFI_TIM_RESET)) {
|
|
if (!srcStaInfo->timRequestPendingFlag){
|
|
update_tim(priv,srcStaInfo->aid,1,interfaceTag, srcStaInfo->assignedHandle);
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
srcStaInfo->updateTimReqQueued = 1;
|
|
unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", srcStaInfo->updateTimReqQueued,
|
|
srcStaInfo->aid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
unifi_trace(priv, UDBG3, "leaving uf_process_pm_bit_for_peer\n");
|
|
return powerSaveChanged;
|
|
}
|
|
|
|
|
|
|
|
void uf_process_ps_poll(unifi_priv_t *priv,u8* sa,u8* da,u8 pmBit,u16 interfaceTag)
|
|
{
|
|
CsrWifiRouterCtrlStaInfo_t *staRecord =
|
|
CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, sa, interfaceTag);
|
|
tx_buffered_packets_t * buffered_pkt = NULL;
|
|
CsrWifiMacAddress peerMacAddress;
|
|
unsigned long lock_flags;
|
|
s8 r =0;
|
|
u8 moreData = FALSE;
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
unifi_trace(priv, UDBG3, "entering uf_process_ps_poll\n");
|
|
if(!staRecord) {
|
|
memcpy(peerMacAddress.a,sa,ETH_ALEN);
|
|
unifi_trace(priv, UDBG3, "In uf_process_ps_poll, sta record not found:unexpected frame addr = %x:%x:%x:%x:%x:%x\n",
|
|
sa[0], sa[1],sa[2], sa[3], sa[4],sa[5]);
|
|
CsrWifiRouterCtrlUnexpectedFrameIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,interfaceTag,peerMacAddress);
|
|
return;
|
|
}
|
|
|
|
uf_process_pm_bit_for_peer(priv,staRecord,pmBit,interfaceTag);
|
|
|
|
/* Update station last activity time */
|
|
staRecord->activity_flag = TRUE;
|
|
|
|
/* This should not change the PM bit as PS-POLL has PM bit always set */
|
|
if(!pmBit) {
|
|
unifi_notice (priv," PM bit reset in PS-POLL\n");
|
|
return;
|
|
}
|
|
|
|
if(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
|
|
/* giving more priority to multicast packets so dropping ps-poll*/
|
|
unifi_notice (priv," multicast transmission is going on so don't take action on PS-POLL\n");
|
|
return;
|
|
}
|
|
|
|
if(!staRecord->wmmOrQosEnabled) {
|
|
if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->mgtFrames))) {
|
|
buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
|
|
moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
|
|
!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]) ||
|
|
!list_empty(&staRecord->mgtFrames));
|
|
|
|
buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
|
|
/* Clear the trigger bit transmission control*/
|
|
buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &staRecord->mgtFrames);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
|
|
priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
|
|
} else {
|
|
if(r){
|
|
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
} else if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]))) {
|
|
buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
|
|
moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
|
|
!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]));
|
|
|
|
buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
|
|
/* Clear the trigger bit transmission control*/
|
|
buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
priv->pausedStaHandle[3]=(u8)(staRecord->assignedHandle);
|
|
unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
|
|
} else {
|
|
if(r){
|
|
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
} else if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]))) {
|
|
buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
|
|
moreData = !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]);
|
|
|
|
buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
|
|
/* Clear the trigger bit transmission control*/
|
|
buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
|
|
unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
|
|
} else {
|
|
if(r){
|
|
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
} else {
|
|
/* Actually since we have sent an ACK, there
|
|
* there is no need to send a NULL frame*/
|
|
}
|
|
moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]) ||
|
|
!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
|
|
!list_empty(&staRecord->mgtFrames));
|
|
if(!moreData && (staRecord->timSet == CSR_WIFI_TIM_SET)) {
|
|
unifi_trace(priv, UDBG3, "more data = NULL, set tim to 0 in uf_process_ps_poll\n");
|
|
if (!staRecord->timRequestPendingFlag){
|
|
update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
staRecord->updateTimReqQueued = 0;
|
|
unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
|
|
staRecord->aid);
|
|
}
|
|
}
|
|
} else {
|
|
|
|
u8 allDeliveryEnabled = 0, dataAvailable = 0;
|
|
unifi_trace(priv, UDBG3,"Qos Support station.Processing PS-Poll\n");
|
|
|
|
/*Send Data From Management Frames*/
|
|
/* Priority orders for delivering the buffered packets are
|
|
* 1. Deliver the Management frames if there
|
|
* 2. Other access catagory frames which are non deliver enable including UNIFI_TRAFFIC_Q_VO
|
|
* priority is from VO->BK
|
|
*/
|
|
|
|
/* Check if all AC's are Delivery Enabled */
|
|
is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
|
|
|
|
if (allDeliveryEnabled) {
|
|
unifi_trace(priv, UDBG3, "uf_process_ps_poll: All ACs are delivery enable so Sending QOS Null in response of Ps-poll\n");
|
|
uf_send_qos_null(priv,interfaceTag,sa,CSR_QOS_UP0,staRecord);
|
|
return;
|
|
}
|
|
|
|
if (!list_empty(&staRecord->mgtFrames)) {
|
|
if ((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->mgtFrames))) {
|
|
/* We dont have packets in non delivery enabled UNIFI_TRAFFIC_Q_VO, So we are looking in management
|
|
* queue of the station record
|
|
*/
|
|
moreData = uf_is_more_data_for_non_delivery_ac(staRecord);
|
|
buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
|
|
/* Last parameter is EOSP & its false always for PS-POLL processing */
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
|
|
/* Clear the trigger bit transmission control*/
|
|
buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &staRecord->mgtFrames);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
|
|
unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
|
|
} else {
|
|
if(r){
|
|
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
} else {
|
|
unifi_error(priv, "uf_process_ps_poll: Mgt frame list empty!! \n");
|
|
}
|
|
|
|
} else {
|
|
s8 i;
|
|
/* We dont have buffered packet in mangement frame queue (1 failed), So proceed with condition 2
|
|
* UNIFI_TRAFFIC_Q_VO -> VI -> BE -> BK
|
|
*/
|
|
for(i= 3; i>=0; i--) {
|
|
if (!IS_DELIVERY_ENABLED(staRecord->powersaveMode[i])) {
|
|
/* Send One packet, if queue is NULL then continue */
|
|
if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[i]))) {
|
|
moreData = uf_is_more_data_for_non_delivery_ac(staRecord);
|
|
|
|
buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
|
|
/* Last parameter is EOSP & its false always for PS-POLL processing */
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
|
|
/* Clear the trigger bit transmission control*/
|
|
buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &staRecord->dataPdu[i]);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
priv->pausedStaHandle[0]=(u8)(staRecord->assignedHandle);
|
|
unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
|
|
} else {
|
|
if(r) {
|
|
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/* Check if all AC's are Delivery Enabled */
|
|
is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
|
|
/*check for more data in non-delivery enabled queues*/
|
|
moreData = (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable));
|
|
if(!moreData && (staRecord->timSet == CSR_WIFI_TIM_SET)) {
|
|
unifi_trace(priv, UDBG3, "more data = NULL, set tim to 0 in uf_process_ps_poll\n");
|
|
if (!staRecord->timRequestPendingFlag){
|
|
update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
|
|
}
|
|
else
|
|
{
|
|
/* Cache the TimSet value so that it will processed immidiatly after
|
|
* completing the current setTim Request
|
|
*/
|
|
staRecord->updateTimReqQueued = 0;
|
|
unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
|
|
staRecord->aid);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
unifi_trace(priv, UDBG3, "leaving uf_process_ps_poll\n");
|
|
}
|
|
|
|
|
|
|
|
void add_to_send_cfm_list(unifi_priv_t * priv,
|
|
tx_buffered_packets_t *tx_q_item,
|
|
struct list_head *frames_need_cfm_list)
|
|
{
|
|
tx_buffered_packets_t *send_cfm_list_item = NULL;
|
|
|
|
send_cfm_list_item = (tx_buffered_packets_t *) kmalloc(sizeof(tx_buffered_packets_t), GFP_ATOMIC);
|
|
|
|
if(send_cfm_list_item == NULL){
|
|
unifi_warning(priv, "%s: Failed to allocate memory for new list item \n");
|
|
return;
|
|
}
|
|
|
|
INIT_LIST_HEAD(&send_cfm_list_item->q);
|
|
|
|
send_cfm_list_item->hostTag = tx_q_item->hostTag;
|
|
send_cfm_list_item->interfaceTag = tx_q_item->interfaceTag;
|
|
send_cfm_list_item->transmissionControl = tx_q_item->transmissionControl;
|
|
send_cfm_list_item->leSenderProcessId = tx_q_item->leSenderProcessId;
|
|
send_cfm_list_item->rate = tx_q_item->rate;
|
|
memcpy(send_cfm_list_item->peerMacAddress.a, tx_q_item->peerMacAddress.a, ETH_ALEN);
|
|
send_cfm_list_item->priority = tx_q_item->priority;
|
|
|
|
list_add_tail(&send_cfm_list_item->q, frames_need_cfm_list);
|
|
}
|
|
|
|
void uf_prepare_send_cfm_list_for_queued_pkts(unifi_priv_t * priv,
|
|
struct list_head *frames_need_cfm_list,
|
|
struct list_head * list)
|
|
{
|
|
tx_buffered_packets_t *tx_q_item = NULL;
|
|
struct list_head *listHead;
|
|
struct list_head *placeHolder;
|
|
unsigned long lock_flags;
|
|
|
|
func_enter();
|
|
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
|
|
/* Search through the list and if confirmation required for any frames,
|
|
add it to the send_cfm list */
|
|
list_for_each_safe(listHead, placeHolder, list) {
|
|
tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
|
|
|
|
if(!tx_q_item) {
|
|
unifi_error(priv, "Entry should exist, otherwise it is a (BUG)\n");
|
|
continue;
|
|
}
|
|
|
|
/* check if confirmation is requested and if the sender ID
|
|
is not netdevice client then save the entry in the list for need cfms */
|
|
if (!(tx_q_item->transmissionControl & CSR_NO_CONFIRM_REQUIRED) &&
|
|
(tx_q_item->leSenderProcessId != priv->netdev_client->sender_id)){
|
|
unifi_trace(priv, UDBG1, "%s: SenderProcessID=%x host tag=%x transmission control=%x\n",
|
|
__FUNCTION__,
|
|
tx_q_item->leSenderProcessId,
|
|
tx_q_item->hostTag,
|
|
tx_q_item->transmissionControl);
|
|
|
|
add_to_send_cfm_list(priv, tx_q_item, frames_need_cfm_list);
|
|
}
|
|
}
|
|
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
|
|
func_exit();
|
|
}
|
|
|
|
|
|
|
|
void uf_flush_list(unifi_priv_t * priv, struct list_head * list)
|
|
{
|
|
tx_buffered_packets_t *tx_q_item;
|
|
struct list_head *listHead;
|
|
struct list_head *placeHolder;
|
|
unsigned long lock_flags;
|
|
|
|
unifi_trace(priv, UDBG5, "entering the uf_flush_list \n");
|
|
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
/* go through list, delete & free memory */
|
|
list_for_each_safe(listHead, placeHolder, list) {
|
|
tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
|
|
|
|
if(!tx_q_item) {
|
|
unifi_error(priv, "entry should exists, otherwise crashes (bug)\n");
|
|
}
|
|
unifi_trace(priv, UDBG5,
|
|
"proccess_tx: in uf_flush_list peerMacAddress=%02X%02X%02X%02X%02X%02X senderProcessId=%x\n",
|
|
tx_q_item->peerMacAddress.a[0], tx_q_item->peerMacAddress.a[1],
|
|
tx_q_item->peerMacAddress.a[2], tx_q_item->peerMacAddress.a[3],
|
|
tx_q_item->peerMacAddress.a[4], tx_q_item->peerMacAddress.a[5],
|
|
tx_q_item->leSenderProcessId);
|
|
|
|
list_del(listHead);
|
|
/* free the allocated memory */
|
|
unifi_net_data_free(priv, &tx_q_item->bulkdata);
|
|
kfree(tx_q_item);
|
|
tx_q_item = NULL;
|
|
if (!priv->noOfPktQueuedInDriver) {
|
|
unifi_error(priv, "packets queued in driver 0 still decrementing in %s\n", __FUNCTION__);
|
|
} else {
|
|
priv->noOfPktQueuedInDriver--;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
}
|
|
|
|
tx_buffered_packets_t *dequeue_tx_data_pdu(unifi_priv_t *priv, struct list_head *txList)
|
|
{
|
|
/* dequeue the tx data packets from the appropriate queue */
|
|
tx_buffered_packets_t *tx_q_item = NULL;
|
|
struct list_head *listHead;
|
|
struct list_head *placeHolder;
|
|
unsigned long lock_flags;
|
|
|
|
unifi_trace(priv, UDBG5, "entering dequeue_tx_data_pdu\n");
|
|
/* check for list empty */
|
|
if (list_empty(txList)) {
|
|
unifi_trace(priv, UDBG5, "In dequeue_tx_data_pdu, the list is empty\n");
|
|
return NULL;
|
|
}
|
|
|
|
/* Verification, if packet count is negetive */
|
|
if (priv->noOfPktQueuedInDriver == 0xFFFF) {
|
|
unifi_warning(priv, "no packet available in queue: debug");
|
|
return NULL;
|
|
}
|
|
|
|
/* return first node after header, & delete from the list && atleast one item exist */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_for_each_safe(listHead, placeHolder, txList) {
|
|
tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
|
|
list_del(listHead);
|
|
break;
|
|
}
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
|
|
if (tx_q_item) {
|
|
unifi_trace(priv, UDBG5,
|
|
"proccess_tx: In dequeue_tx_data_pdu peerMacAddress=%02X%02X%02X%02X%02X%02X senderProcessId=%x\n",
|
|
tx_q_item->peerMacAddress.a[0], tx_q_item->peerMacAddress.a[1],
|
|
tx_q_item->peerMacAddress.a[2], tx_q_item->peerMacAddress.a[3],
|
|
tx_q_item->peerMacAddress.a[4], tx_q_item->peerMacAddress.a[5],
|
|
tx_q_item->leSenderProcessId);
|
|
}
|
|
|
|
unifi_trace(priv, UDBG5, "leaving dequeue_tx_data_pdu\n");
|
|
return tx_q_item;
|
|
}
|
|
/* generic function to get the station record handler */
|
|
CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(unifi_priv_t *priv,
|
|
const u8 *peerMacAddress,
|
|
u16 interfaceTag)
|
|
{
|
|
u8 i;
|
|
netInterface_priv_t *interfacePriv;
|
|
unsigned long lock_flags;
|
|
|
|
if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
|
|
unifi_error(priv, "interfaceTag is not proper, interfaceTag = %d\n", interfaceTag);
|
|
return NULL;
|
|
}
|
|
|
|
interfacePriv = priv->interfacePriv[interfaceTag];
|
|
|
|
/* disable the preemption untill station record is fetched */
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
|
|
for (i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
|
|
if (interfacePriv->staInfo[i]!= NULL) {
|
|
if (!memcmp(((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[i]))->peerMacAddress.a, peerMacAddress, ETH_ALEN)) {
|
|
/* enable the preemption as station record is fetched */
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
unifi_trace(priv, UDBG5, "peer entry found in station record\n");
|
|
return ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[i]));
|
|
}
|
|
}
|
|
}
|
|
/* enable the preemption as station record is fetched */
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
unifi_trace(priv, UDBG5, "peer entry not found in station record\n");
|
|
return NULL;
|
|
}
|
|
/* generic function to get the station record handler from the handle */
|
|
CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_priv_t *priv,
|
|
u32 handle,
|
|
u16 interfaceTag)
|
|
{
|
|
netInterface_priv_t *interfacePriv;
|
|
|
|
if ((handle >= UNIFI_MAX_CONNECTIONS) || (interfaceTag >= CSR_WIFI_NUM_INTERFACES)) {
|
|
unifi_error(priv, "handle/interfaceTag is not proper, handle = %d, interfaceTag = %d\n", handle, interfaceTag);
|
|
return NULL;
|
|
}
|
|
interfacePriv = priv->interfacePriv[interfaceTag];
|
|
return ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[handle]));
|
|
}
|
|
|
|
/* Function to do inactivity */
|
|
void uf_check_inactivity(unifi_priv_t *priv, u16 interfaceTag, CsrTime currentTime)
|
|
{
|
|
u32 i;
|
|
CsrWifiRouterCtrlStaInfo_t *staInfo;
|
|
CsrTime elapsedTime; /* Time in microseconds */
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
CsrWifiMacAddress peerMacAddress;
|
|
unsigned long lock_flags;
|
|
|
|
if (interfacePriv == NULL) {
|
|
unifi_trace(priv, UDBG3, "uf_check_inactivity: Interface priv is NULL \n");
|
|
return;
|
|
}
|
|
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
/* Go through the list of stations to check for inactivity */
|
|
for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
|
|
staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv, i, interfaceTag);
|
|
if(!staInfo ) {
|
|
continue;
|
|
}
|
|
|
|
unifi_trace(priv, UDBG3, "Running Inactivity handler Time %xus station's last activity %xus\n",
|
|
currentTime, staInfo->lastActivity);
|
|
|
|
|
|
elapsedTime = (currentTime >= staInfo->lastActivity)?
|
|
(currentTime - staInfo->lastActivity):
|
|
(~((u32)0) - staInfo->lastActivity + currentTime);
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
|
|
if (elapsedTime > MAX_INACTIVITY_INTERVAL) {
|
|
memcpy((u8*)&peerMacAddress, (u8*)&staInfo->peerMacAddress, sizeof(CsrWifiMacAddress));
|
|
|
|
/* Indicate inactivity for the station */
|
|
unifi_trace(priv, UDBG3, "Station %x:%x:%x:%x:%x:%x inactive since %xus\n sending Inactive Ind\n",
|
|
peerMacAddress.a[0], peerMacAddress.a[1],
|
|
peerMacAddress.a[2], peerMacAddress.a[3],
|
|
peerMacAddress.a[4], peerMacAddress.a[5],
|
|
elapsedTime);
|
|
|
|
CsrWifiRouterCtrlStaInactiveIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, peerMacAddress);
|
|
}
|
|
}
|
|
|
|
interfacePriv->last_inactivity_check = currentTime;
|
|
}
|
|
|
|
/* Function to update activity of a station */
|
|
void uf_update_sta_activity(unifi_priv_t *priv, u16 interfaceTag, const u8 *peerMacAddress)
|
|
{
|
|
CsrTime elapsedTime, currentTime; /* Time in microseconds */
|
|
CsrTime timeHi; /* Not used - Time in microseconds */
|
|
CsrWifiRouterCtrlStaInfo_t *staInfo;
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
unsigned long lock_flags;
|
|
|
|
if (interfacePriv == NULL) {
|
|
unifi_trace(priv, UDBG3, "uf_check_inactivity: Interface priv is NULL \n");
|
|
return;
|
|
}
|
|
|
|
currentTime = CsrTimeGet(&timeHi);
|
|
|
|
|
|
staInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, peerMacAddress, interfaceTag);
|
|
|
|
if (staInfo == NULL) {
|
|
unifi_trace(priv, UDBG4, "Sta does not exist yet");
|
|
return;
|
|
}
|
|
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
/* Update activity */
|
|
staInfo->lastActivity = currentTime;
|
|
|
|
/* See if inactivity handler needs to be run
|
|
* Here it is theoretically possible that the counter may have wrapped around. But
|
|
* since we just want to know when to run the inactivity handler it does not really matter.
|
|
* Especially since this is data path it makes sense in keeping it simple and avoiding
|
|
* 64 bit handling */
|
|
elapsedTime = (currentTime >= interfacePriv->last_inactivity_check)?
|
|
(currentTime - interfacePriv->last_inactivity_check):
|
|
(~((u32)0) - interfacePriv->last_inactivity_check + currentTime);
|
|
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
|
|
/* Check if it is time to run the inactivity handler */
|
|
if (elapsedTime > INACTIVITY_CHECK_INTERVAL) {
|
|
uf_check_inactivity(priv, interfaceTag, currentTime);
|
|
}
|
|
}
|
|
void resume_unicast_buffered_frames(unifi_priv_t *priv, u16 interfaceTag)
|
|
{
|
|
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
u8 i;
|
|
int j;
|
|
tx_buffered_packets_t * buffered_pkt = NULL;
|
|
u8 hipslotFree[4] = {TRUE,TRUE,TRUE,TRUE};
|
|
int r;
|
|
unsigned long lock_flags;
|
|
|
|
func_enter();
|
|
while(!isRouterBufferEnabled(priv,3) &&
|
|
((buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMgtFrames))!=NULL)) {
|
|
buffered_pkt->transmissionControl &=
|
|
~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,NULL,0,FALSE)) == -ENOSPC) {
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &interfacePriv->genericMgtFrames);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
hipslotFree[3]=FALSE;
|
|
break;
|
|
}else {
|
|
if(r){
|
|
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
}
|
|
for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
|
|
CsrWifiRouterCtrlStaInfo_t *staInfo = interfacePriv->staInfo[i];
|
|
if(!hipslotFree[0] && !hipslotFree[1] && !hipslotFree[2] && !hipslotFree[3]) {
|
|
unifi_trace(priv, UDBG3, "(ENOSPC) in resume_unicast_buffered_frames:: hip slots are full \n");
|
|
break;
|
|
}
|
|
if (staInfo && (staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)) {
|
|
while((( TRUE == hipslotFree[3] ) && (buffered_pkt=dequeue_tx_data_pdu(priv, &staInfo->mgtFrames)))) {
|
|
buffered_pkt->transmissionControl &=
|
|
~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,0,FALSE)) == -ENOSPC) {
|
|
unifi_trace(priv, UDBG3, "(ENOSPC) in resume_unicast_buffered_frames:: hip slots are full for voice queue\n");
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &staInfo->mgtFrames);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
priv->pausedStaHandle[3]=(u8)(staInfo->assignedHandle);
|
|
hipslotFree[3] = FALSE;
|
|
break;
|
|
} else {
|
|
if(r){
|
|
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
}
|
|
|
|
for(j=3;j>=0;j--) {
|
|
if(!hipslotFree[j])
|
|
continue;
|
|
|
|
while((buffered_pkt=dequeue_tx_data_pdu(priv, &staInfo->dataPdu[j]))) {
|
|
buffered_pkt->transmissionControl &=
|
|
~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
|
|
if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,0,FALSE)) == -ENOSPC) {
|
|
/* Enqueue at the head of the queue */
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_add(&buffered_pkt->q, &staInfo->dataPdu[j]);
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
priv->pausedStaHandle[j]=(u8)(staInfo->assignedHandle);
|
|
hipslotFree[j]=FALSE;
|
|
break;
|
|
} else {
|
|
if(r){
|
|
unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
|
|
/* the PDU failed where we can't do any thing so free the storage */
|
|
unifi_net_data_free(priv, &buffered_pkt->bulkdata);
|
|
}
|
|
kfree(buffered_pkt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
func_exit();
|
|
}
|
|
void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,u16 interfaceTag)
|
|
{
|
|
|
|
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
|
|
unsigned long lock_flags;
|
|
struct list_head *listHead;
|
|
struct list_head *placeHolder;
|
|
tx_buffered_packets_t *tx_q_item;
|
|
|
|
func_enter();
|
|
if (interfacePriv->noOfbroadcastPktQueued) {
|
|
|
|
/* Update the EOSP to the HEAD of b/c list
|
|
* beacuse we have received any mgmt packet so it should not hold for long time
|
|
* peer may time out.
|
|
*/
|
|
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
|
|
list_for_each_safe(listHead, placeHolder, &interfacePriv->genericMulticastOrBroadCastFrames) {
|
|
tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
|
|
tx_q_item->transmissionControl |= TRANSMISSION_CONTROL_EOSP_MASK;
|
|
tx_q_item->transmissionControl = (tx_q_item->transmissionControl & ~(CSR_NO_CONFIRM_REQUIRED));
|
|
unifi_trace(priv, UDBG1,"updating eosp for list Head hostTag:= 0x%x ",tx_q_item->hostTag);
|
|
break;
|
|
}
|
|
spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
|
|
}
|
|
func_exit();
|
|
}
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* resume_suspended_uapsd
|
|
*
|
|
* This function takes care processing packets of Unscheduled Service Period,
|
|
* which been suspended earlier due to DTIM/HIP ENOSPC scenarios
|
|
*
|
|
* Arguments:
|
|
* priv Pointer to device private context struct
|
|
* interfaceTag For which resume should happen
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
void resume_suspended_uapsd(unifi_priv_t* priv,u16 interfaceTag)
|
|
{
|
|
|
|
u8 startIndex;
|
|
CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
|
|
unsigned long lock_flags;
|
|
|
|
unifi_trace(priv, UDBG2, "++resume_suspended_uapsd: \n");
|
|
for(startIndex= 0; startIndex < UNIFI_MAX_CONNECTIONS;startIndex++) {
|
|
staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv,startIndex,interfaceTag);
|
|
|
|
if(!staInfo || !staInfo->wmmOrQosEnabled) {
|
|
continue;
|
|
} else if((staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)
|
|
&&staInfo->uapsdActive && staInfo->uspSuspend) {
|
|
/* U-APSD Still active & previously suspended either ENOSPC of FH queues OR
|
|
* due to DTIM activity
|
|
*/
|
|
uf_handle_uspframes_delivery(priv, staInfo, interfaceTag);
|
|
} else {
|
|
unifi_trace(priv, UDBG2, "resume_suspended_uapsd: PS state=%x, uapsdActive?=%x, suspend?=%x\n",
|
|
staInfo->currentPeerState, staInfo->uapsdActive, staInfo->uspSuspend);
|
|
if (staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)
|
|
{
|
|
spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
|
|
staInfo->uapsdActive = FALSE;
|
|
staInfo->uspSuspend = FALSE;
|
|
spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
|
|
}
|
|
}
|
|
}
|
|
unifi_trace(priv, UDBG2, "--resume_suspended_uapsd:\n");
|
|
}
|
|
|
|
#endif
|