drivers/net/wireless/mediatek/mt76/tx.c

   1 // SPDX-License-Identifier: ISC
   2 /*
   3  * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
   4  */
   5
   6 #include "mt76.h"
   7
   8 static int
   9 mt76_txq_get_qid(struct ieee80211_txq *txq)
  10 {
  11         if (!txq->sta)
  12                 return MT_TXQ_BE;
  13
  14         return txq->ac;
  15 }
  16
  17 void
  18 mt76_tx_check_agg_ssn(struct ieee80211_sta *sta, struct sk_buff *skb)
  19 {
  20         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
  21         struct ieee80211_txq *txq;
  22         struct mt76_txq *mtxq;
  23         u8 tid;
  24
  25         if (!sta || !ieee80211_is_data_qos(hdr->frame_control) ||
  26             !ieee80211_is_data_present(hdr->frame_control))
  27                 return;
  28
  29         tid = skb->priority & IEEE80211_QOS_CTL_TAG1D_MASK;
  30         txq = sta->txq[tid];
  31         mtxq = (struct mt76_txq *)txq->drv_priv;
  32         if (!mtxq->aggr)
  33                 return;
  34
  35         mtxq->agg_ssn = le16_to_cpu(hdr->seq_ctrl) + 0x10;
  36 }
  37 EXPORT_SYMBOL_GPL(mt76_tx_check_agg_ssn);
  38
  39 void
  40 mt76_tx_status_lock(struct mt76_dev *dev, struct sk_buff_head *list)
  41                    __acquires(&dev->status_lock)
  42 {
  43         __skb_queue_head_init(list);
  44         spin_lock_bh(&dev->status_lock);
  45 }
  46 EXPORT_SYMBOL_GPL(mt76_tx_status_lock);
  47
  48 void
  49 mt76_tx_status_unlock(struct mt76_dev *dev, struct sk_buff_head *list)
  50                       __releases(&dev->status_lock)
  51 {
  52         struct ieee80211_hw *hw;
  53         struct sk_buff *skb;
  54
  55         spin_unlock_bh(&dev->status_lock);
  56
  57         rcu_read_lock();
  58         while ((skb = __skb_dequeue(list)) != NULL) {
  59                 struct ieee80211_tx_status status = {
  60                         .skb = skb,
  61                         .info = IEEE80211_SKB_CB(skb),
  62                 };
  63                 struct mt76_tx_cb *cb = mt76_tx_skb_cb(skb);
  64                 struct mt76_wcid *wcid;
  65
  66                 wcid = rcu_dereference(dev->wcid[cb->wcid]);
  67                 if (wcid) {
  68                         status.sta = wcid_to_sta(wcid);
  69
  70                         if (status.sta)
  71                                 status.rate = &wcid->rate;
  72                 }
  73
  74                 hw = mt76_tx_status_get_hw(dev, skb);
  75                 ieee80211_tx_status_ext(hw, &status);
  76         }
  77         rcu_read_unlock();
  78 }
  79 EXPORT_SYMBOL_GPL(mt76_tx_status_unlock);
  80
  81 static void
  82 __mt76_tx_status_skb_done(struct mt76_dev *dev, struct sk_buff *skb, u8 flags,
  83                           struct sk_buff_head *list)
  84 {
  85         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  86         struct mt76_tx_cb *cb = mt76_tx_skb_cb(skb);
  87         u8 done = MT_TX_CB_DMA_DONE | MT_TX_CB_TXS_DONE;
  88
  89         flags |= cb->flags;
  90         cb->flags = flags;
  91
  92         if ((flags & done) != done)
  93                 return;
  94
  95         /* Tx status can be unreliable. if it fails, mark the frame as ACKed */
  96         if (flags & MT_TX_CB_TXS_FAILED) {
  97                 info->status.rates[0].count = 0;
  98                 info->status.rates[0].idx = -1;
  99                 info->flags |= IEEE80211_TX_STAT_ACK;
 100         }
 101
 102         __skb_queue_tail(list, skb);
 103 }
 104
 105 void
 106 mt76_tx_status_skb_done(struct mt76_dev *dev, struct sk_buff *skb,
 107                         struct sk_buff_head *list)
 108 {
 109         __mt76_tx_status_skb_done(dev, skb, MT_TX_CB_TXS_DONE, list);
 110 }
 111 EXPORT_SYMBOL_GPL(mt76_tx_status_skb_done);
 112
 113 int
 114 mt76_tx_status_skb_add(struct mt76_dev *dev, struct mt76_wcid *wcid,
 115                        struct sk_buff *skb)
 116 {
 117         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 118         struct mt76_tx_cb *cb = mt76_tx_skb_cb(skb);
 119         int pid;
 120
 121         memset(cb, 0, sizeof(*cb));
 122
 123         if (!wcid)
 124                 return MT_PACKET_ID_NO_ACK;
 125
 126         if (info->flags & IEEE80211_TX_CTL_NO_ACK)
 127                 return MT_PACKET_ID_NO_ACK;
 128
 129         if (!(info->flags & (IEEE80211_TX_CTL_REQ_TX_STATUS |
 130                              IEEE80211_TX_CTL_RATE_CTRL_PROBE)))
 131                 return MT_PACKET_ID_NO_SKB;
 132
 133         spin_lock_bh(&dev->status_lock);
 134
 135         pid = idr_alloc(&wcid->pktid, skb, MT_PACKET_ID_FIRST,
 136                         MT_PACKET_ID_MASK, GFP_ATOMIC);
 137         if (pid < 0) {
 138                 pid = MT_PACKET_ID_NO_SKB;
 139                 goto out;
 140         }
 141
 142         cb->wcid = wcid->idx;
 143         cb->pktid = pid;
 144
 145         if (list_empty(&wcid->list))
 146                 list_add_tail(&wcid->list, &dev->wcid_list);
 147
 148 out:
 149         spin_unlock_bh(&dev->status_lock);
 150
 151         return pid;
 152 }
 153 EXPORT_SYMBOL_GPL(mt76_tx_status_skb_add);
 154
 155 struct sk_buff *
 156 mt76_tx_status_skb_get(struct mt76_dev *dev, struct mt76_wcid *wcid, int pktid,
 157                        struct sk_buff_head *list)
 158 {
 159         struct sk_buff *skb;
 160         int id;
 161
 162         lockdep_assert_held(&dev->status_lock);
 163
 164         skb = idr_remove(&wcid->pktid, pktid);
 165         if (skb)
 166                 goto out;
 167
 168         /* look for stale entries in the wcid idr queue */
 169         idr_for_each_entry(&wcid->pktid, skb, id) {
 170                 struct mt76_tx_cb *cb = mt76_tx_skb_cb(skb);
 171
 172                 if (pktid >= 0) {
 173                         if (!(cb->flags & MT_TX_CB_DMA_DONE))
 174                                 continue;
 175
 176                         if (!time_is_after_jiffies(cb->jiffies +
 177                                                    MT_TX_STATUS_SKB_TIMEOUT))
 178                                 continue;
 179                 }
 180
 181                 /* It has been too long since DMA_DONE, time out this packet
 182                  * and stop waiting for TXS callback.
 183                  */
 184                 idr_remove(&wcid->pktid, cb->pktid);
 185                 __mt76_tx_status_skb_done(dev, skb, MT_TX_CB_TXS_FAILED |
 186                                                     MT_TX_CB_TXS_DONE, list);
 187         }
 188
 189 out:
 190         if (idr_is_empty(&wcid->pktid))
 191                 list_del_init(&wcid->list);
 192
 193         return skb;
 194 }
 195 EXPORT_SYMBOL_GPL(mt76_tx_status_skb_get);
 196
 197 void
 198 mt76_tx_status_check(struct mt76_dev *dev, bool flush)
 199 {
 200         struct mt76_wcid *wcid, *tmp;
 201         struct sk_buff_head list;
 202
 203         mt76_tx_status_lock(dev, &list);
 204         list_for_each_entry_safe(wcid, tmp, &dev->wcid_list, list)
 205                 mt76_tx_status_skb_get(dev, wcid, flush ? -1 : 0, &list);
 206         mt76_tx_status_unlock(dev, &list);
 207 }
 208 EXPORT_SYMBOL_GPL(mt76_tx_status_check);
 209
 210 static void
 211 mt76_tx_check_non_aql(struct mt76_dev *dev, struct mt76_wcid *wcid,
 212                       struct sk_buff *skb)
 213 {
 214         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 215         int pending;
 216
 217         if (!wcid || info->tx_time_est)
 218                 return;
 219
 220         pending = atomic_dec_return(&wcid->non_aql_packets);
 221         if (pending < 0)
 222                 atomic_cmpxchg(&wcid->non_aql_packets, pending, 0);
 223 }
 224
 225 void __mt76_tx_complete_skb(struct mt76_dev *dev, u16 wcid_idx, struct sk_buff *skb,
 226                             struct list_head *free_list)
 227 {
 228         struct mt76_tx_cb *cb = mt76_tx_skb_cb(skb);
 229         struct ieee80211_tx_status status = {
 230                 .skb = skb,
 231                 .free_list = free_list,
 232         };
 233         struct mt76_wcid *wcid = NULL;
 234         struct ieee80211_hw *hw;
 235         struct sk_buff_head list;
 236
 237         rcu_read_lock();
 238
 239         if (wcid_idx < ARRAY_SIZE(dev->wcid))
 240                 wcid = rcu_dereference(dev->wcid[wcid_idx]);
 241
 242         mt76_tx_check_non_aql(dev, wcid, skb);
 243
 244 #ifdef CONFIG_NL80211_TESTMODE
 245         if (mt76_is_testmode_skb(dev, skb, &hw)) {
 246                 struct mt76_phy *phy = hw->priv;
 247
 248                 if (skb == phy->test.tx_skb)
 249                         phy->test.tx_done++;
 250                 if (phy->test.tx_queued == phy->test.tx_done)
 251                         wake_up(&dev->tx_wait);
 252
 253                 dev_kfree_skb_any(skb);
 254                 goto out;
 255         }
 256 #endif
 257
 258         if (cb->pktid < MT_PACKET_ID_FIRST) {
 259                 hw = mt76_tx_status_get_hw(dev, skb);
 260                 status.sta = wcid_to_sta(wcid);
 261                 ieee80211_tx_status_ext(hw, &status);
 262                 goto out;
 263         }
 264
 265         mt76_tx_status_lock(dev, &list);
 266         cb->jiffies = jiffies;
 267         __mt76_tx_status_skb_done(dev, skb, MT_TX_CB_DMA_DONE, &list);
 268         mt76_tx_status_unlock(dev, &list);
 269
 270 out:
 271         rcu_read_unlock();
 272 }
 273 EXPORT_SYMBOL_GPL(__mt76_tx_complete_skb);
 274
 275 static int
 276 __mt76_tx_queue_skb(struct mt76_phy *phy, int qid, struct sk_buff *skb,
 277                     struct mt76_wcid *wcid, struct ieee80211_sta *sta,
 278                     bool *stop)
 279 {
 280         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 281         struct mt76_queue *q = phy->q_tx[qid];
 282         struct mt76_dev *dev = phy->dev;
 283         bool non_aql;
 284         int pending;
 285         int idx;
 286
 287         non_aql = !info->tx_time_est;
 288         idx = dev->queue_ops->tx_queue_skb(dev, q, skb, wcid, sta);
 289         if (idx < 0 || !sta)
 290                 return idx;
 291
 292         wcid = (struct mt76_wcid *)sta->drv_priv;
 293         q->entry[idx].wcid = wcid->idx;
 294
 295         if (!non_aql)
 296                 return idx;
 297
 298         pending = atomic_inc_return(&wcid->non_aql_packets);
 299         if (stop && pending >= MT_MAX_NON_AQL_PKT)
 300                 *stop = true;
 301
 302         return idx;
 303 }
 304
 305 void
 306 mt76_tx(struct mt76_phy *phy, struct ieee80211_sta *sta,
 307         struct mt76_wcid *wcid, struct sk_buff *skb)
 308 {
 309         struct mt76_dev *dev = phy->dev;
 310         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 311         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 312         struct mt76_queue *q;
 313         int qid = skb_get_queue_mapping(skb);
 314         bool ext_phy = phy != &dev->phy;
 315
 316         if (mt76_testmode_enabled(phy)) {
 317                 ieee80211_free_txskb(phy->hw, skb);
 318                 return;
 319         }
 320
 321         if (WARN_ON(qid >= MT_TXQ_PSD)) {
 322                 qid = MT_TXQ_BE;
 323                 skb_set_queue_mapping(skb, qid);
 324         }
 325
 326         if ((dev->drv->drv_flags & MT_DRV_HW_MGMT_TXQ) &&
 327             !(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP) &&
 328             !ieee80211_is_data(hdr->frame_control) &&
 329             !ieee80211_is_bufferable_mmpdu(hdr->frame_control)) {
 330                 qid = MT_TXQ_PSD;
 331                 skb_set_queue_mapping(skb, qid);
 332         }
 333
 334         if (wcid && !(wcid->tx_info & MT_WCID_TX_INFO_SET))
 335                 ieee80211_get_tx_rates(info->control.vif, sta, skb,
 336                                        info->control.rates, 1);
 337
 338         if (ext_phy)
 339                 info->hw_queue |= MT_TX_HW_QUEUE_EXT_PHY;
 340
 341         q = phy->q_tx[qid];
 342
 343         spin_lock_bh(&q->lock);
 344         __mt76_tx_queue_skb(phy, qid, skb, wcid, sta, NULL);
 345         dev->queue_ops->kick(dev, q);
 346         spin_unlock_bh(&q->lock);
 347 }
 348 EXPORT_SYMBOL_GPL(mt76_tx);
 349
 350 static struct sk_buff *
 351 mt76_txq_dequeue(struct mt76_phy *phy, struct mt76_txq *mtxq)
 352 {
 353         struct ieee80211_txq *txq = mtxq_to_txq(mtxq);
 354         struct ieee80211_tx_info *info;
 355         bool ext_phy = phy != &phy->dev->phy;
 356         struct sk_buff *skb;
 357
 358         skb = ieee80211_tx_dequeue(phy->hw, txq);
 359         if (!skb)
 360                 return NULL;
 361
 362         info = IEEE80211_SKB_CB(skb);
 363         if (ext_phy)
 364                 info->hw_queue |= MT_TX_HW_QUEUE_EXT_PHY;
 365
 366         return skb;
 367 }
 368
 369 static void
 370 mt76_queue_ps_skb(struct mt76_phy *phy, struct ieee80211_sta *sta,
 371                   struct sk_buff *skb, bool last)
 372 {
 373         struct mt76_wcid *wcid = (struct mt76_wcid *)sta->drv_priv;
 374         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 375
 376         info->control.flags |= IEEE80211_TX_CTRL_PS_RESPONSE;
 377         if (last)
 378                 info->flags |= IEEE80211_TX_STATUS_EOSP |
 379                                IEEE80211_TX_CTL_REQ_TX_STATUS;
 380
 381         mt76_skb_set_moredata(skb, !last);
 382         __mt76_tx_queue_skb(phy, MT_TXQ_PSD, skb, wcid, sta, NULL);
 383 }
 384
 385 void
 386 mt76_release_buffered_frames(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
 387                              u16 tids, int nframes,
 388                              enum ieee80211_frame_release_type reason,
 389                              bool more_data)
 390 {
 391         struct mt76_phy *phy = hw->priv;
 392         struct mt76_dev *dev = phy->dev;
 393         struct sk_buff *last_skb = NULL;
 394         struct mt76_queue *hwq = phy->q_tx[MT_TXQ_PSD];
 395         int i;
 396
 397         spin_lock_bh(&hwq->lock);
 398         for (i = 0; tids && nframes; i++, tids >>= 1) {
 399                 struct ieee80211_txq *txq = sta->txq[i];
 400                 struct mt76_txq *mtxq = (struct mt76_txq *)txq->drv_priv;
 401                 struct sk_buff *skb;
 402
 403                 if (!(tids & 1))
 404                         continue;
 405
 406                 do {
 407                         skb = mt76_txq_dequeue(phy, mtxq);
 408                         if (!skb)
 409                                 break;
 410
 411                         nframes--;
 412                         if (last_skb)
 413                                 mt76_queue_ps_skb(phy, sta, last_skb, false);
 414
 415                         last_skb = skb;
 416                 } while (nframes);
 417         }
 418
 419         if (last_skb) {
 420                 mt76_queue_ps_skb(phy, sta, last_skb, true);
 421                 dev->queue_ops->kick(dev, hwq);
 422         } else {
 423                 ieee80211_sta_eosp(sta);
 424         }
 425
 426         spin_unlock_bh(&hwq->lock);
 427 }
 428 EXPORT_SYMBOL_GPL(mt76_release_buffered_frames);
 429
 430 static bool
 431 mt76_txq_stopped(struct mt76_queue *q)
 432 {
 433         return q->stopped || q->blocked ||
 434                q->queued + MT_TXQ_FREE_THR >= q->ndesc;
 435 }
 436
 437 static int
 438 mt76_txq_send_burst(struct mt76_phy *phy, struct mt76_queue *q,
 439                     struct mt76_txq *mtxq)
 440 {
 441         struct mt76_dev *dev = phy->dev;
 442         struct ieee80211_txq *txq = mtxq_to_txq(mtxq);
 443         enum mt76_txq_id qid = mt76_txq_get_qid(txq);
 444         struct mt76_wcid *wcid = mtxq->wcid;
 445         struct ieee80211_tx_info *info;
 446         struct sk_buff *skb;
 447         int n_frames = 1;
 448         bool stop = false;
 449         int idx;
 450
 451         if (test_bit(MT_WCID_FLAG_PS, &wcid->flags))
 452                 return 0;
 453
 454         if (atomic_read(&wcid->non_aql_packets) >= MT_MAX_NON_AQL_PKT)
 455                 return 0;
 456
 457         skb = mt76_txq_dequeue(phy, mtxq);
 458         if (!skb)
 459                 return 0;
 460
 461         info = IEEE80211_SKB_CB(skb);
 462         if (!(wcid->tx_info & MT_WCID_TX_INFO_SET))
 463                 ieee80211_get_tx_rates(txq->vif, txq->sta, skb,
 464                                        info->control.rates, 1);
 465
 466         idx = __mt76_tx_queue_skb(phy, qid, skb, wcid, txq->sta, &stop);
 467         if (idx < 0)
 468                 return idx;
 469
 470         do {
 471                 if (test_bit(MT76_RESET, &phy->state))
 472                         return -EBUSY;
 473
 474                 if (stop || mt76_txq_stopped(q))
 475                         break;
 476
 477                 skb = mt76_txq_dequeue(phy, mtxq);
 478                 if (!skb)
 479                         break;
 480
 481                 info = IEEE80211_SKB_CB(skb);
 482                 if (!(wcid->tx_info & MT_WCID_TX_INFO_SET))
 483                         ieee80211_get_tx_rates(txq->vif, txq->sta, skb,
 484                                                info->control.rates, 1);
 485
 486                 idx = __mt76_tx_queue_skb(phy, qid, skb, wcid, txq->sta, &stop);
 487                 if (idx < 0)
 488                         break;
 489
 490                 n_frames++;
 491         } while (1);
 492
 493         dev->queue_ops->kick(dev, q);
 494
 495         return n_frames;
 496 }
 497
 498 static int
 499 mt76_txq_schedule_list(struct mt76_phy *phy, enum mt76_txq_id qid)
 500 {
 501         struct mt76_queue *q = phy->q_tx[qid];
 502         struct mt76_dev *dev = phy->dev;
 503         struct ieee80211_txq *txq;
 504         struct mt76_txq *mtxq;
 505         struct mt76_wcid *wcid;
 506         int ret = 0;
 507
 508         while (1) {
 509                 int n_frames = 0;
 510
 511                 if (test_bit(MT76_RESET, &phy->state))
 512                         return -EBUSY;
 513
 514                 if (dev->queue_ops->tx_cleanup &&
 515                     q->queued + 2 * MT_TXQ_FREE_THR >= q->ndesc) {
 516                         dev->queue_ops->tx_cleanup(dev, q, false);
 517                 }
 518
 519                 txq = ieee80211_next_txq(phy->hw, qid);
 520                 if (!txq)
 521                         break;
 522
 523                 mtxq = (struct mt76_txq *)txq->drv_priv;
 524                 wcid = mtxq->wcid;
 525                 if (wcid && test_bit(MT_WCID_FLAG_PS, &wcid->flags))
 526                         continue;
 527
 528                 spin_lock_bh(&q->lock);
 529
 530                 if (mtxq->send_bar && mtxq->aggr) {
 531                         struct ieee80211_txq *txq = mtxq_to_txq(mtxq);
 532                         struct ieee80211_sta *sta = txq->sta;
 533                         struct ieee80211_vif *vif = txq->vif;
 534                         u16 agg_ssn = mtxq->agg_ssn;
 535                         u8 tid = txq->tid;
 536
 537                         mtxq->send_bar = false;
 538                         spin_unlock_bh(&q->lock);
 539                         ieee80211_send_bar(vif, sta->addr, tid, agg_ssn);
 540                         spin_lock_bh(&q->lock);
 541                 }
 542
 543                 if (!mt76_txq_stopped(q))
 544                         n_frames = mt76_txq_send_burst(phy, q, mtxq);
 545
 546                 spin_unlock_bh(&q->lock);
 547
 548                 ieee80211_return_txq(phy->hw, txq, false);
 549
 550                 if (unlikely(n_frames < 0))
 551                         return n_frames;
 552
 553                 ret += n_frames;
 554         }
 555
 556         return ret;
 557 }
 558
 559 void mt76_txq_schedule(struct mt76_phy *phy, enum mt76_txq_id qid)
 560 {
 561         int len;
 562
 563         if (qid >= 4)
 564                 return;
 565
 566         rcu_read_lock();
 567
 568         do {
 569                 ieee80211_txq_schedule_start(phy->hw, qid);
 570                 len = mt76_txq_schedule_list(phy, qid);
 571                 ieee80211_txq_schedule_end(phy->hw, qid);
 572         } while (len > 0);
 573
 574         rcu_read_unlock();
 575 }
 576 EXPORT_SYMBOL_GPL(mt76_txq_schedule);
 577
 578 void mt76_txq_schedule_all(struct mt76_phy *phy)
 579 {
 580         int i;
 581
 582         for (i = 0; i <= MT_TXQ_BK; i++)
 583                 mt76_txq_schedule(phy, i);
 584 }
 585 EXPORT_SYMBOL_GPL(mt76_txq_schedule_all);
 586
 587 void mt76_tx_worker_run(struct mt76_dev *dev)
 588 {
 589         mt76_txq_schedule_all(&dev->phy);
 590         if (dev->phy2)
 591                 mt76_txq_schedule_all(dev->phy2);
 592
 593 #ifdef CONFIG_NL80211_TESTMODE
 594         if (dev->phy.test.tx_pending)
 595                 mt76_testmode_tx_pending(&dev->phy);
 596         if (dev->phy2 && dev->phy2->test.tx_pending)
 597                 mt76_testmode_tx_pending(dev->phy2);
 598 #endif
 599 }
 600 EXPORT_SYMBOL_GPL(mt76_tx_worker_run);
 601
 602 void mt76_tx_worker(struct mt76_worker *w)
 603 {
 604         struct mt76_dev *dev = container_of(w, struct mt76_dev, tx_worker);
 605
 606         mt76_tx_worker_run(dev);
 607 }
 608
 609 void mt76_stop_tx_queues(struct mt76_phy *phy, struct ieee80211_sta *sta,
 610                          bool send_bar)
 611 {
 612         int i;
 613
 614         for (i = 0; i < ARRAY_SIZE(sta->txq); i++) {
 615                 struct ieee80211_txq *txq = sta->txq[i];
 616                 struct mt76_queue *hwq;
 617                 struct mt76_txq *mtxq;
 618
 619                 if (!txq)
 620                         continue;
 621
 622                 hwq = phy->q_tx[mt76_txq_get_qid(txq)];
 623                 mtxq = (struct mt76_txq *)txq->drv_priv;
 624
 625                 spin_lock_bh(&hwq->lock);
 626                 mtxq->send_bar = mtxq->aggr && send_bar;
 627                 spin_unlock_bh(&hwq->lock);
 628         }
 629 }
 630 EXPORT_SYMBOL_GPL(mt76_stop_tx_queues);
 631
 632 void mt76_wake_tx_queue(struct ieee80211_hw *hw, struct ieee80211_txq *txq)
 633 {
 634         struct mt76_phy *phy = hw->priv;
 635         struct mt76_dev *dev = phy->dev;
 636
 637         if (!test_bit(MT76_STATE_RUNNING, &phy->state))
 638                 return;
 639
 640         mt76_worker_schedule(&dev->tx_worker);
 641 }
 642 EXPORT_SYMBOL_GPL(mt76_wake_tx_queue);
 643
 644 u8 mt76_ac_to_hwq(u8 ac)
 645 {
 646         static const u8 wmm_queue_map[] = {
 647                 [IEEE80211_AC_BE] = 0,
 648                 [IEEE80211_AC_BK] = 1,
 649                 [IEEE80211_AC_VI] = 2,
 650                 [IEEE80211_AC_VO] = 3,
 651         };
 652
 653         if (WARN_ON(ac >= IEEE80211_NUM_ACS))
 654                 return 0;
 655
 656         return wmm_queue_map[ac];
 657 }
 658 EXPORT_SYMBOL_GPL(mt76_ac_to_hwq);
 659
 660 int mt76_skb_adjust_pad(struct sk_buff *skb, int pad)
 661 {
 662         struct sk_buff *iter, *last = skb;
 663
 664         /* First packet of a A-MSDU burst keeps track of the whole burst
 665          * length, need to update length of it and the last packet.
 666          */
 667         skb_walk_frags(skb, iter) {
 668                 last = iter;
 669                 if (!iter->next) {
 670                         skb->data_len += pad;
 671                         skb->len += pad;
 672                         break;
 673                 }
 674         }
 675
 676         if (skb_pad(last, pad))
 677                 return -ENOMEM;
 678
 679         __skb_put(last, pad);
 680
 681         return 0;
 682 }
 683 EXPORT_SYMBOL_GPL(mt76_skb_adjust_pad);
 684
 685 void mt76_queue_tx_complete(struct mt76_dev *dev, struct mt76_queue *q,
 686                             struct mt76_queue_entry *e)
 687 {
 688         if (e->skb)
 689                 dev->drv->tx_complete_skb(dev, e);
 690
 691         spin_lock_bh(&q->lock);
 692         q->tail = (q->tail + 1) % q->ndesc;
 693         q->queued--;
 694         spin_unlock_bh(&q->lock);
 695 }
 696 EXPORT_SYMBOL_GPL(mt76_queue_tx_complete);
 697
 698 void __mt76_set_tx_blocked(struct mt76_dev *dev, bool blocked)
 699 {
 700         struct mt76_phy *phy = &dev->phy, *phy2 = dev->phy2;
 701         struct mt76_queue *q, *q2 = NULL;
 702
 703         q = phy->q_tx[0];
 704         if (blocked == q->blocked)
 705                 return;
 706
 707         q->blocked = blocked;
 708         if (phy2) {
 709                 q2 = phy2->q_tx[0];
 710                 q2->blocked = blocked;
 711         }
 712
 713         if (!blocked)
 714                 mt76_worker_schedule(&dev->tx_worker);
 715 }
 716 EXPORT_SYMBOL_GPL(__mt76_set_tx_blocked);
 717
 718 int mt76_token_consume(struct mt76_dev *dev, struct mt76_txwi_cache **ptxwi)
 719 {
 720         int token;
 721
 722         spin_lock_bh(&dev->token_lock);
 723
 724         token = idr_alloc(&dev->token, *ptxwi, 0, dev->drv->token_size,
 725                           GFP_ATOMIC);
 726         if (token >= 0)
 727                 dev->token_count++;
 728
 729         if (dev->token_count >= dev->drv->token_size - MT76_TOKEN_FREE_THR)
 730                 __mt76_set_tx_blocked(dev, true);
 731
 732         spin_unlock_bh(&dev->token_lock);
 733
 734         return token;
 735 }
 736 EXPORT_SYMBOL_GPL(mt76_token_consume);
 737
 738 struct mt76_txwi_cache *
 739 mt76_token_release(struct mt76_dev *dev, int token, bool *wake)
 740 {
 741         struct mt76_txwi_cache *txwi;
 742
 743         spin_lock_bh(&dev->token_lock);
 744
 745         txwi = idr_remove(&dev->token, token);
 746         if (txwi)
 747                 dev->token_count--;
 748
 749         if (dev->token_count < dev->drv->token_size - MT76_TOKEN_FREE_THR &&
 750             dev->phy.q_tx[0]->blocked)
 751                 *wake = true;
 752
 753         spin_unlock_bh(&dev->token_lock);
 754
 755         return txwi;
 756 }
 757 EXPORT_SYMBOL_GPL(mt76_token_release);