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