drivers/net/wireless/rsi/rsi_91x_core.c

   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  */
  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  */
  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  */
  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  */
 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  */
 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  */
 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  */
 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
 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
 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  */
 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         wh = (struct ieee80211_hdr *)&skb->data[0];
 404         tx_params->sta_id = 0;
 405
 406         vif = rsi_get_vif(adapter, wh->addr2);
 407         if (!vif)
 408                 goto xmit_fail;
 409         tx_params->vif = vif;
 410         tx_params->vap_id = ((struct vif_priv *)vif->drv_priv)->vap_id;
 411         if ((ieee80211_is_mgmt(wh->frame_control)) ||
 412             (ieee80211_is_ctl(wh->frame_control)) ||
 413             (ieee80211_is_qos_nullfunc(wh->frame_control))) {
 414                 if (ieee80211_is_assoc_req(wh->frame_control) ||
 415                     ieee80211_is_reassoc_req(wh->frame_control)) {
 416                         struct ieee80211_bss_conf *bss = &vif->bss_conf;
 417
 418                         common->eapol4_confirm = false;
 419                         rsi_hal_send_sta_notify_frame(common,
 420                                                       RSI_IFTYPE_STATION,
 421                                                       STA_CONNECTED, bss->bssid,
 422                                                       bss->qos, bss->aid, 0,
 423                                                       vif);
 424                 }
 425
 426                 q_num = MGMT_SOFT_Q;
 427                 skb->priority = q_num;
 428
 429                 if (rsi_prepare_mgmt_desc(common, skb)) {
 430                         rsi_dbg(ERR_ZONE, "Failed to prepare desc\n");
 431                         goto xmit_fail;
 432                 }
 433         } else {
 434                 if (ieee80211_is_data_qos(wh->frame_control)) {
 435                         u8 *qos = ieee80211_get_qos_ctl(wh);
 436
 437                         tid = *qos & IEEE80211_QOS_CTL_TID_MASK;
 438                         skb->priority = TID_TO_WME_AC(tid);
 439                 } else {
 440                         tid = IEEE80211_NONQOS_TID;
 441                         skb->priority = BE_Q;
 442                 }
 443
 444                 q_num = skb->priority;
 445                 tx_params->tid = tid;
 446
 447                 if (((vif->type == NL80211_IFTYPE_AP) ||
 448                      (vif->type == NL80211_IFTYPE_P2P_GO)) &&
 449                     (!is_broadcast_ether_addr(wh->addr1)) &&
 450                     (!is_multicast_ether_addr(wh->addr1))) {
 451                         rsta = rsi_find_sta(common, wh->addr1);
 452                         if (!rsta)
 453                                 goto xmit_fail;
 454                         tx_params->sta_id = rsta->sta_id;
 455                 } else {
 456                         tx_params->sta_id = 0;
 457                 }
 458
 459                 if (rsta) {
 460                         /* Start aggregation if not done for this tid */
 461                         if (!rsta->start_tx_aggr[tid]) {
 462                                 rsta->start_tx_aggr[tid] = true;
 463                                 ieee80211_start_tx_ba_session(rsta->sta,
 464                                                               tid, 0);
 465                         }
 466                 }
 467                 if (skb->protocol == cpu_to_be16(ETH_P_PAE)) {
 468                         q_num = MGMT_SOFT_Q;
 469                         skb->priority = q_num;
 470                 }
 471                 if (rsi_prepare_data_desc(common, skb)) {
 472                         rsi_dbg(ERR_ZONE, "Failed to prepare data desc\n");
 473                         goto xmit_fail;
 474                 }
 475         }
 476
 477         if ((q_num < MGMT_SOFT_Q) &&
 478             ((skb_queue_len(&common->tx_queue[q_num]) + 1) >=
 479              DATA_QUEUE_WATER_MARK)) {
 480                 rsi_dbg(ERR_ZONE, "%s: sw queue full\n", __func__);
 481                 if (!ieee80211_queue_stopped(adapter->hw, WME_AC(q_num)))
 482                         ieee80211_stop_queue(adapter->hw, WME_AC(q_num));
 483                 rsi_set_event(&common->tx_thread.event);
 484                 goto xmit_fail;
 485         }
 486
 487         rsi_core_queue_pkt(common, skb);
 488         rsi_dbg(DATA_TX_ZONE, "%s: ===> Scheduling TX thread <===\n", __func__);
 489         rsi_set_event(&common->tx_thread.event);
 490
 491         return;
 492
 493 xmit_fail:
 494         rsi_dbg(ERR_ZONE, "%s: Failed to queue packet\n", __func__);
 495         /* Dropping pkt here */
 496         ieee80211_free_txskb(common->priv->hw, skb);
 497 }