1 /*
2 * Copyright (c) 2014 Redpine Signals Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17 #include "rsi_mgmt.h"
18 #include "rsi_common.h"
19 #include "rsi_hal.h"
20 #include "rsi_coex.h"
21
22 /**
23 * rsi_determine_min_weight_queue() - This function determines the queue with
24 * the min weight.
25 * @common: Pointer to the driver private structure.
26 *
27 * Return: q_num: Corresponding queue number.
28 */
rsi_determine_min_weight_queue(struct rsi_common * common)29 static u8 rsi_determine_min_weight_queue(struct rsi_common *common)
30 {
31 struct wmm_qinfo *tx_qinfo = common->tx_qinfo;
32 u32 q_len = 0;
33 u8 ii = 0;
34
35 for (ii = 0; ii < NUM_EDCA_QUEUES; ii++) {
36 q_len = skb_queue_len(&common->tx_queue[ii]);
37 if ((tx_qinfo[ii].pkt_contended) && q_len) {
38 common->min_weight = tx_qinfo[ii].weight;
39 break;
40 }
41 }
42 return ii;
43 }
44
45 /**
46 * rsi_recalculate_weights() - This function recalculates the weights
47 * corresponding to each queue.
48 * @common: Pointer to the driver private structure.
49 *
50 * Return: recontend_queue bool variable
51 */
rsi_recalculate_weights(struct rsi_common * common)52 static bool rsi_recalculate_weights(struct rsi_common *common)
53 {
54 struct wmm_qinfo *tx_qinfo = common->tx_qinfo;
55 bool recontend_queue = false;
56 u8 ii = 0;
57 u32 q_len = 0;
58
59 for (ii = 0; ii < NUM_EDCA_QUEUES; ii++) {
60 q_len = skb_queue_len(&common->tx_queue[ii]);
61 /* Check for the need of contention */
62 if (q_len) {
63 if (tx_qinfo[ii].pkt_contended) {
64 tx_qinfo[ii].weight =
65 ((tx_qinfo[ii].weight > common->min_weight) ?
66 tx_qinfo[ii].weight - common->min_weight : 0);
67 } else {
68 tx_qinfo[ii].pkt_contended = 1;
69 tx_qinfo[ii].weight = tx_qinfo[ii].wme_params;
70 recontend_queue = true;
71 }
72 } else { /* No packets so no contention */
73 tx_qinfo[ii].weight = 0;
74 tx_qinfo[ii].pkt_contended = 0;
75 }
76 }
77
78 return recontend_queue;
79 }
80
81 /**
82 * rsi_get_num_pkts_dequeue() - This function determines the number of
83 * packets to be dequeued based on the number
84 * of bytes calculated using txop.
85 *
86 * @common: Pointer to the driver private structure.
87 * @q_num: the queue from which pkts have to be dequeued
88 *
89 * Return: pkt_num: Number of pkts to be dequeued.
90 */
rsi_get_num_pkts_dequeue(struct rsi_common * common,u8 q_num)91 static u32 rsi_get_num_pkts_dequeue(struct rsi_common *common, u8 q_num)
92 {
93 struct rsi_hw *adapter = common->priv;
94 struct sk_buff *skb;
95 u32 pkt_cnt = 0;
96 s16 txop = common->tx_qinfo[q_num].txop * 32;
97 __le16 r_txop;
98 struct ieee80211_rate rate;
99 struct ieee80211_hdr *wh;
100 struct ieee80211_vif *vif;
101
102 rate.bitrate = RSI_RATE_MCS0 * 5 * 10; /* Convert to Kbps */
103 if (q_num == VI_Q)
104 txop = ((txop << 5) / 80);
105
106 if (skb_queue_len(&common->tx_queue[q_num]))
107 skb = skb_peek(&common->tx_queue[q_num]);
108 else
109 return 0;
110
111 do {
112 wh = (struct ieee80211_hdr *)skb->data;
113 vif = rsi_get_vif(adapter, wh->addr2);
114 r_txop = ieee80211_generic_frame_duration(adapter->hw,
115 vif,
116 common->band,
117 skb->len, &rate);
118 txop -= le16_to_cpu(r_txop);
119 pkt_cnt += 1;
120 /*checking if pkts are still there*/
121 if (skb_queue_len(&common->tx_queue[q_num]) - pkt_cnt)
122 skb = skb->next;
123 else
124 break;
125
126 } while (txop > 0);
127
128 return pkt_cnt;
129 }
130
131 /**
132 * rsi_core_determine_hal_queue() - This function determines the queue from
133 * which packet has to be dequeued.
134 * @common: Pointer to the driver private structure.
135 *
136 * Return: q_num: Corresponding queue number on success.
137 */
rsi_core_determine_hal_queue(struct rsi_common * common)138 static u8 rsi_core_determine_hal_queue(struct rsi_common *common)
139 {
140 bool recontend_queue = false;
141 u32 q_len = 0;
142 u8 q_num = INVALID_QUEUE;
143 u8 ii = 0;
144
145 if (skb_queue_len(&common->tx_queue[MGMT_BEACON_Q])) {
146 q_num = MGMT_BEACON_Q;
147 return q_num;
148 }
149 if (skb_queue_len(&common->tx_queue[MGMT_SOFT_Q])) {
150 if (!common->mgmt_q_block)
151 q_num = MGMT_SOFT_Q;
152 return q_num;
153 }
154
155 if (common->hw_data_qs_blocked)
156 return q_num;
157
158 if (common->pkt_cnt != 0) {
159 --common->pkt_cnt;
160 return common->selected_qnum;
161 }
162
163 get_queue_num:
164 recontend_queue = false;
165
166 q_num = rsi_determine_min_weight_queue(common);
167
168 ii = q_num;
169
170 /* Selecting the queue with least back off */
171 for (; ii < NUM_EDCA_QUEUES; ii++) {
172 q_len = skb_queue_len(&common->tx_queue[ii]);
173 if (((common->tx_qinfo[ii].pkt_contended) &&
174 (common->tx_qinfo[ii].weight < common->min_weight)) &&
175 q_len) {
176 common->min_weight = common->tx_qinfo[ii].weight;
177 q_num = ii;
178 }
179 }
180
181 if (q_num < NUM_EDCA_QUEUES)
182 common->tx_qinfo[q_num].pkt_contended = 0;
183
184 /* Adjust the back off values for all queues again */
185 recontend_queue = rsi_recalculate_weights(common);
186
187 q_len = skb_queue_len(&common->tx_queue[q_num]);
188 if (!q_len) {
189 /* If any queues are freshly contended and the selected queue
190 * doesn't have any packets
191 * then get the queue number again with fresh values
192 */
193 if (recontend_queue)
194 goto get_queue_num;
195
196 q_num = INVALID_QUEUE;
197 return q_num;
198 }
199
200 common->selected_qnum = q_num;
201 q_len = skb_queue_len(&common->tx_queue[q_num]);
202
203 if (q_num == VO_Q || q_num == VI_Q) {
204 common->pkt_cnt = rsi_get_num_pkts_dequeue(common, q_num);
205 common->pkt_cnt -= 1;
206 }
207
208 return q_num;
209 }
210
211 /**
212 * rsi_core_queue_pkt() - This functions enqueues the packet to the queue
213 * specified by the queue number.
214 * @common: Pointer to the driver private structure.
215 * @skb: Pointer to the socket buffer structure.
216 *
217 * Return: None.
218 */
rsi_core_queue_pkt(struct rsi_common * common,struct sk_buff * skb)219 static void rsi_core_queue_pkt(struct rsi_common *common,
220 struct sk_buff *skb)
221 {
222 u8 q_num = skb->priority;
223 if (q_num >= NUM_SOFT_QUEUES) {
224 rsi_dbg(ERR_ZONE, "%s: Invalid Queue Number: q_num = %d\n",
225 __func__, q_num);
226 dev_kfree_skb(skb);
227 return;
228 }
229
230 skb_queue_tail(&common->tx_queue[q_num], skb);
231 }
232
233 /**
234 * rsi_core_dequeue_pkt() - This functions dequeues the packet from the queue
235 * specified by the queue number.
236 * @common: Pointer to the driver private structure.
237 * @q_num: Queue number.
238 *
239 * Return: Pointer to sk_buff structure.
240 */
rsi_core_dequeue_pkt(struct rsi_common * common,u8 q_num)241 static struct sk_buff *rsi_core_dequeue_pkt(struct rsi_common *common,
242 u8 q_num)
243 {
244 if (q_num >= NUM_SOFT_QUEUES) {
245 rsi_dbg(ERR_ZONE, "%s: Invalid Queue Number: q_num = %d\n",
246 __func__, q_num);
247 return NULL;
248 }
249
250 return skb_dequeue(&common->tx_queue[q_num]);
251 }
252
253 /**
254 * rsi_core_qos_processor() - This function is used to determine the wmm queue
255 * based on the backoff procedure. Data packets are
256 * dequeued from the selected hal queue and sent to
257 * the below layers.
258 * @common: Pointer to the driver private structure.
259 *
260 * Return: None.
261 */
rsi_core_qos_processor(struct rsi_common * common)262 void rsi_core_qos_processor(struct rsi_common *common)
263 {
264 struct rsi_hw *adapter = common->priv;
265 struct sk_buff *skb;
266 unsigned long tstamp_1, tstamp_2;
267 u8 q_num;
268 int status;
269
270 tstamp_1 = jiffies;
271 while (1) {
272 q_num = rsi_core_determine_hal_queue(common);
273 rsi_dbg(DATA_TX_ZONE,
274 "%s: Queue number = %d\n", __func__, q_num);
275
276 if (q_num == INVALID_QUEUE) {
277 rsi_dbg(DATA_TX_ZONE, "%s: No More Pkt\n", __func__);
278 break;
279 }
280 if (common->hibernate_resume)
281 break;
282
283 mutex_lock(&common->tx_lock);
284
285 status = adapter->check_hw_queue_status(adapter, q_num);
286 if ((status <= 0)) {
287 mutex_unlock(&common->tx_lock);
288 break;
289 }
290
291 if ((q_num < MGMT_SOFT_Q) &&
292 ((skb_queue_len(&common->tx_queue[q_num])) <=
293 MIN_DATA_QUEUE_WATER_MARK)) {
294 if (ieee80211_queue_stopped(adapter->hw, WME_AC(q_num)))
295 ieee80211_wake_queue(adapter->hw,
296 WME_AC(q_num));
297 }
298
299 skb = rsi_core_dequeue_pkt(common, q_num);
300 if (skb == NULL) {
301 rsi_dbg(ERR_ZONE, "skb null\n");
302 mutex_unlock(&common->tx_lock);
303 break;
304 }
305 if (q_num == MGMT_BEACON_Q) {
306 status = rsi_send_pkt_to_bus(common, skb);
307 dev_kfree_skb(skb);
308 } else {
309 #ifdef CONFIG_RSI_COEX
310 if (common->coex_mode > 1) {
311 status = rsi_coex_send_pkt(common, skb,
312 RSI_WLAN_Q);
313 } else {
314 #endif
315 if (q_num == MGMT_SOFT_Q)
316 status = rsi_send_mgmt_pkt(common, skb);
317 else
318 status = rsi_send_data_pkt(common, skb);
319 #ifdef CONFIG_RSI_COEX
320 }
321 #endif
322 }
323
324 if (status) {
325 mutex_unlock(&common->tx_lock);
326 break;
327 }
328
329 common->tx_stats.total_tx_pkt_send[q_num]++;
330
331 tstamp_2 = jiffies;
332 mutex_unlock(&common->tx_lock);
333
334 if (time_after(tstamp_2, tstamp_1 + (300 * HZ) / 1000))
335 schedule();
336 }
337 }
338
rsi_find_sta(struct rsi_common * common,u8 * mac_addr)339 struct rsi_sta *rsi_find_sta(struct rsi_common *common, u8 *mac_addr)
340 {
341 int i;
342
343 for (i = 0; i < common->max_stations; i++) {
344 if (!common->stations[i].sta)
345 continue;
346 if (!(memcmp(common->stations[i].sta->addr,
347 mac_addr, ETH_ALEN)))
348 return &common->stations[i];
349 }
350 return NULL;
351 }
352
rsi_get_vif(struct rsi_hw * adapter,u8 * mac)353 struct ieee80211_vif *rsi_get_vif(struct rsi_hw *adapter, u8 *mac)
354 {
355 struct ieee80211_vif *vif;
356 int i;
357
358 for (i = 0; i < RSI_MAX_VIFS; i++) {
359 vif = adapter->vifs[i];
360 if (!vif)
361 continue;
362 if (!memcmp(vif->addr, mac, ETH_ALEN))
363 return vif;
364 }
365 return NULL;
366 }
367
368 /**
369 * rsi_core_xmit() - This function transmits the packets received from mac80211
370 * @common: Pointer to the driver private structure.
371 * @skb: Pointer to the socket buffer structure.
372 *
373 * Return: None.
374 */
rsi_core_xmit(struct rsi_common * common,struct sk_buff * skb)375 void rsi_core_xmit(struct rsi_common *common, struct sk_buff *skb)
376 {
377 struct rsi_hw *adapter = common->priv;
378 struct ieee80211_tx_info *info;
379 struct skb_info *tx_params;
380 struct ieee80211_hdr *wh = NULL;
381 struct ieee80211_vif *vif;
382 u8 q_num, tid = 0;
383 struct rsi_sta *rsta = NULL;
384
385 if ((!skb) || (!skb->len)) {
386 rsi_dbg(ERR_ZONE, "%s: Null skb/zero Length packet\n",
387 __func__);
388 goto xmit_fail;
389 }
390 if (common->fsm_state != FSM_MAC_INIT_DONE) {
391 rsi_dbg(ERR_ZONE, "%s: FSM state not open\n", __func__);
392 goto xmit_fail;
393 }
394 if (common->wow_flags & RSI_WOW_ENABLED) {
395 rsi_dbg(ERR_ZONE,
396 "%s: Blocking Tx_packets when WOWLAN is enabled\n",
397 __func__);
398 goto xmit_fail;
399 }
400
401 info = IEEE80211_SKB_CB(skb);
402 tx_params = (struct skb_info *)info->driver_data;
403 /* info->driver_data and info->control part of union so make copy */
404 tx_params->have_key = !!info->control.hw_key;
405 wh = (struct ieee80211_hdr *)&skb->data[0];
406 tx_params->sta_id = 0;
407
408 vif = rsi_get_vif(adapter, wh->addr2);
409 if (!vif)
410 goto xmit_fail;
411 tx_params->vif = vif;
412 tx_params->vap_id = ((struct vif_priv *)vif->drv_priv)->vap_id;
413 if ((ieee80211_is_mgmt(wh->frame_control)) ||
414 (ieee80211_is_ctl(wh->frame_control)) ||
415 (ieee80211_is_qos_nullfunc(wh->frame_control))) {
416 if (ieee80211_is_assoc_req(wh->frame_control) ||
417 ieee80211_is_reassoc_req(wh->frame_control)) {
418 struct ieee80211_bss_conf *bss = &vif->bss_conf;
419
420 common->eapol4_confirm = false;
421 rsi_hal_send_sta_notify_frame(common,
422 RSI_IFTYPE_STATION,
423 STA_CONNECTED, bss->bssid,
424 bss->qos, bss->aid, 0,
425 vif);
426 }
427
428 q_num = MGMT_SOFT_Q;
429 skb->priority = q_num;
430
431 if (rsi_prepare_mgmt_desc(common, skb)) {
432 rsi_dbg(ERR_ZONE, "Failed to prepare desc\n");
433 goto xmit_fail;
434 }
435 } else {
436 if (ieee80211_is_data_qos(wh->frame_control)) {
437 u8 *qos = ieee80211_get_qos_ctl(wh);
438
439 tid = *qos & IEEE80211_QOS_CTL_TID_MASK;
440 skb->priority = TID_TO_WME_AC(tid);
441 } else {
442 tid = IEEE80211_NONQOS_TID;
443 skb->priority = BE_Q;
444 }
445
446 q_num = skb->priority;
447 tx_params->tid = tid;
448
449 if (((vif->type == NL80211_IFTYPE_AP) ||
450 (vif->type == NL80211_IFTYPE_P2P_GO)) &&
451 (!is_broadcast_ether_addr(wh->addr1)) &&
452 (!is_multicast_ether_addr(wh->addr1))) {
453 rsta = rsi_find_sta(common, wh->addr1);
454 if (!rsta)
455 goto xmit_fail;
456 tx_params->sta_id = rsta->sta_id;
457 } else {
458 tx_params->sta_id = 0;
459 }
460
461 if (rsta) {
462 /* Start aggregation if not done for this tid */
463 if (!rsta->start_tx_aggr[tid]) {
464 rsta->start_tx_aggr[tid] = true;
465 ieee80211_start_tx_ba_session(rsta->sta,
466 tid, 0);
467 }
468 }
469
470 if (IEEE80211_SKB_CB(skb)->control.flags &
471 IEEE80211_TX_CTRL_PORT_CTRL_PROTO) {
472 q_num = MGMT_SOFT_Q;
473 skb->priority = q_num;
474 }
475 if (rsi_prepare_data_desc(common, skb)) {
476 rsi_dbg(ERR_ZONE, "Failed to prepare data desc\n");
477 goto xmit_fail;
478 }
479 }
480
481 if ((q_num < MGMT_SOFT_Q) &&
482 ((skb_queue_len(&common->tx_queue[q_num]) + 1) >=
483 DATA_QUEUE_WATER_MARK)) {
484 rsi_dbg(ERR_ZONE, "%s: sw queue full\n", __func__);
485 if (!ieee80211_queue_stopped(adapter->hw, WME_AC(q_num)))
486 ieee80211_stop_queue(adapter->hw, WME_AC(q_num));
487 rsi_set_event(&common->tx_thread.event);
488 goto xmit_fail;
489 }
490
491 rsi_core_queue_pkt(common, skb);
492 rsi_dbg(DATA_TX_ZONE, "%s: ===> Scheduling TX thread <===\n", __func__);
493 rsi_set_event(&common->tx_thread.event);
494
495 return;
496
497 xmit_fail:
498 rsi_dbg(ERR_ZONE, "%s: Failed to queue packet\n", __func__);
499 /* Dropping pkt here */
500 ieee80211_free_txskb(common->priv->hw, skb);
501 }
502