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