drivers/net/wireless/ath/wil6210/rx_reorder.c

   1 // SPDX-License-Identifier: ISC
   2 /*
   3  * Copyright (c) 2014-2017 Qualcomm Atheros, Inc.
   4  * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
   5  */
   6
   7 #include "wil6210.h"
   8 #include "txrx.h"
   9
  10 #define SEQ_MODULO 0x1000
  11 #define SEQ_MASK   0xfff
  12
  13 static inline int seq_less(u16 sq1, u16 sq2)
  14 {
  15         return ((sq1 - sq2) & SEQ_MASK) > (SEQ_MODULO >> 1);
  16 }
  17
  18 static inline u16 seq_inc(u16 sq)
  19 {
  20         return (sq + 1) & SEQ_MASK;
  21 }
  22
  23 static inline u16 seq_sub(u16 sq1, u16 sq2)
  24 {
  25         return (sq1 - sq2) & SEQ_MASK;
  26 }
  27
  28 static inline int reorder_index(struct wil_tid_ampdu_rx *r, u16 seq)
  29 {
  30         return seq_sub(seq, r->ssn) % r->buf_size;
  31 }
  32
  33 static void wil_release_reorder_frame(struct net_device *ndev,
  34                                       struct wil_tid_ampdu_rx *r,
  35                                       int index)
  36 {
  37         struct sk_buff *skb = r->reorder_buf[index];
  38
  39         if (!skb)
  40                 goto no_frame;
  41
  42         /* release the frame from the reorder ring buffer */
  43         r->stored_mpdu_num--;
  44         r->reorder_buf[index] = NULL;
  45         wil_netif_rx_any(skb, ndev);
  46
  47 no_frame:
  48         r->head_seq_num = seq_inc(r->head_seq_num);
  49 }
  50
  51 static void wil_release_reorder_frames(struct net_device *ndev,
  52                                        struct wil_tid_ampdu_rx *r,
  53                                        u16 hseq)
  54 {
  55         int index;
  56
  57         /* note: this function is never called with
  58          * hseq preceding r->head_seq_num, i.e it is always true
  59          * !seq_less(hseq, r->head_seq_num)
  60          * and thus on loop exit it should be
  61          * r->head_seq_num == hseq
  62          */
  63         while (seq_less(r->head_seq_num, hseq) && r->stored_mpdu_num) {
  64                 index = reorder_index(r, r->head_seq_num);
  65                 wil_release_reorder_frame(ndev, r, index);
  66         }
  67         r->head_seq_num = hseq;
  68 }
  69
  70 static void wil_reorder_release(struct net_device *ndev,
  71                                 struct wil_tid_ampdu_rx *r)
  72 {
  73         int index = reorder_index(r, r->head_seq_num);
  74
  75         while (r->reorder_buf[index]) {
  76                 wil_release_reorder_frame(ndev, r, index);
  77                 index = reorder_index(r, r->head_seq_num);
  78         }
  79 }
  80
  81 /* called in NAPI context */
  82 void wil_rx_reorder(struct wil6210_priv *wil, struct sk_buff *skb)
  83 __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
  84 {
  85         struct wil6210_vif *vif;
  86         struct net_device *ndev;
  87         int tid, cid, mid, mcast, retry;
  88         u16 seq;
  89         struct wil_sta_info *sta;
  90         struct wil_tid_ampdu_rx *r;
  91         u16 hseq;
  92         int index;
  93
  94         wil->txrx_ops.get_reorder_params(wil, skb, &tid, &cid, &mid, &seq,
  95                                          &mcast, &retry);
  96         sta = &wil->sta[cid];
  97
  98         wil_dbg_txrx(wil, "MID %d CID %d TID %d Seq 0x%03x mcast %01x\n",
  99                      mid, cid, tid, seq, mcast);
 100
 101         vif = wil->vifs[mid];
 102         if (unlikely(!vif)) {
 103                 wil_dbg_txrx(wil, "invalid VIF, mid %d\n", mid);
 104                 dev_kfree_skb(skb);
 105                 return;
 106         }
 107         ndev = vif_to_ndev(vif);
 108
 109         spin_lock(&sta->tid_rx_lock);
 110
 111         r = sta->tid_rx[tid];
 112         if (!r) {
 113                 wil_netif_rx_any(skb, ndev);
 114                 goto out;
 115         }
 116
 117         if (unlikely(mcast)) {
 118                 if (retry && seq == r->mcast_last_seq) {
 119                         r->drop_dup_mcast++;
 120                         wil_dbg_txrx(wil, "Rx drop: dup mcast seq 0x%03x\n",
 121                                      seq);
 122                         dev_kfree_skb(skb);
 123                         goto out;
 124                 }
 125                 r->mcast_last_seq = seq;
 126                 wil_netif_rx_any(skb, ndev);
 127                 goto out;
 128         }
 129
 130         r->total++;
 131         hseq = r->head_seq_num;
 132
 133         /** Due to the race between WMI events, where BACK establishment
 134          * reported, and data Rx, few packets may be pass up before reorder
 135          * buffer get allocated. Catch up by pretending SSN is what we
 136          * see in the 1-st Rx packet
 137          *
 138          * Another scenario, Rx get delayed and we got packet from before
 139          * BACK. Pass it to the stack and wait.
 140          */
 141         if (r->first_time) {
 142                 r->first_time = false;
 143                 if (seq != r->head_seq_num) {
 144                         if (seq_less(seq, r->head_seq_num)) {
 145                                 wil_err(wil,
 146                                         "Error: frame with early sequence 0x%03x, should be 0x%03x. Waiting...\n",
 147                                         seq, r->head_seq_num);
 148                                 r->first_time = true;
 149                                 wil_netif_rx_any(skb, ndev);
 150                                 goto out;
 151                         }
 152                         wil_err(wil,
 153                                 "Error: 1-st frame with wrong sequence 0x%03x, should be 0x%03x. Fixing...\n",
 154                                 seq, r->head_seq_num);
 155                         r->head_seq_num = seq;
 156                         r->ssn = seq;
 157                 }
 158         }
 159
 160         /* frame with out of date sequence number */
 161         if (seq_less(seq, r->head_seq_num)) {
 162                 r->ssn_last_drop = seq;
 163                 r->drop_old++;
 164                 wil_dbg_txrx(wil, "Rx drop: old seq 0x%03x head 0x%03x\n",
 165                              seq, r->head_seq_num);
 166                 dev_kfree_skb(skb);
 167                 goto out;
 168         }
 169
 170         /*
 171          * If frame the sequence number exceeds our buffering window
 172          * size release some previous frames to make room for this one.
 173          */
 174         if (!seq_less(seq, r->head_seq_num + r->buf_size)) {
 175                 hseq = seq_inc(seq_sub(seq, r->buf_size));
 176                 /* release stored frames up to new head to stack */
 177                 wil_release_reorder_frames(ndev, r, hseq);
 178         }
 179
 180         /* Now the new frame is always in the range of the reordering buffer */
 181
 182         index = reorder_index(r, seq);
 183
 184         /* check if we already stored this frame */
 185         if (r->reorder_buf[index]) {
 186                 r->drop_dup++;
 187                 wil_dbg_txrx(wil, "Rx drop: dup seq 0x%03x\n", seq);
 188                 dev_kfree_skb(skb);
 189                 goto out;
 190         }
 191
 192         /*
 193          * If the current MPDU is in the right order and nothing else
 194          * is stored we can process it directly, no need to buffer it.
 195          * If it is first but there's something stored, we may be able
 196          * to release frames after this one.
 197          */
 198         if (seq == r->head_seq_num && r->stored_mpdu_num == 0) {
 199                 r->head_seq_num = seq_inc(r->head_seq_num);
 200                 wil_netif_rx_any(skb, ndev);
 201                 goto out;
 202         }
 203
 204         /* put the frame in the reordering buffer */
 205         r->reorder_buf[index] = skb;
 206         r->stored_mpdu_num++;
 207         wil_reorder_release(ndev, r);
 208
 209 out:
 210         spin_unlock(&sta->tid_rx_lock);
 211 }
 212
 213 /* process BAR frame, called in NAPI context */
 214 void wil_rx_bar(struct wil6210_priv *wil, struct wil6210_vif *vif,
 215                 u8 cid, u8 tid, u16 seq)
 216 {
 217         struct wil_sta_info *sta = &wil->sta[cid];
 218         struct net_device *ndev = vif_to_ndev(vif);
 219         struct wil_tid_ampdu_rx *r;
 220
 221         spin_lock(&sta->tid_rx_lock);
 222
 223         r = sta->tid_rx[tid];
 224         if (!r) {
 225                 wil_err(wil, "BAR for non-existing CID %d TID %d\n", cid, tid);
 226                 goto out;
 227         }
 228         if (seq_less(seq, r->head_seq_num)) {
 229                 wil_err(wil, "BAR Seq 0x%03x preceding head 0x%03x\n",
 230                         seq, r->head_seq_num);
 231                 goto out;
 232         }
 233         wil_dbg_txrx(wil, "BAR: CID %d MID %d TID %d Seq 0x%03x head 0x%03x\n",
 234                      cid, vif->mid, tid, seq, r->head_seq_num);
 235         wil_release_reorder_frames(ndev, r, seq);
 236
 237 out:
 238         spin_unlock(&sta->tid_rx_lock);
 239 }
 240
 241 struct wil_tid_ampdu_rx *wil_tid_ampdu_rx_alloc(struct wil6210_priv *wil,
 242                                                 int size, u16 ssn)
 243 {
 244         struct wil_tid_ampdu_rx *r = kzalloc(sizeof(*r), GFP_KERNEL);
 245
 246         if (!r)
 247                 return NULL;
 248
 249         r->reorder_buf =
 250                 kcalloc(size, sizeof(struct sk_buff *), GFP_KERNEL);
 251         if (!r->reorder_buf) {
 252                 kfree(r);
 253                 return NULL;
 254         }
 255
 256         r->ssn = ssn;
 257         r->head_seq_num = ssn;
 258         r->buf_size = size;
 259         r->stored_mpdu_num = 0;
 260         r->first_time = true;
 261         r->mcast_last_seq = U16_MAX;
 262         return r;
 263 }
 264
 265 void wil_tid_ampdu_rx_free(struct wil6210_priv *wil,
 266                            struct wil_tid_ampdu_rx *r)
 267 {
 268         int i;
 269
 270         if (!r)
 271                 return;
 272
 273         /* Do not pass remaining frames to the network stack - it may be
 274          * not expecting to get any more Rx. Rx from here may lead to
 275          * kernel OOPS since some per-socket accounting info was already
 276          * released.
 277          */
 278         for (i = 0; i < r->buf_size; i++)
 279                 kfree_skb(r->reorder_buf[i]);
 280
 281         kfree(r->reorder_buf);
 282         kfree(r);
 283 }
 284
 285 /* ADDBA processing */
 286 static u16 wil_agg_size(struct wil6210_priv *wil, u16 req_agg_wsize)
 287 {
 288         u16 max_agg_size = min_t(u16, wil->max_agg_wsize, wil->max_ampdu_size /
 289                                  (mtu_max + WIL_MAX_MPDU_OVERHEAD));
 290
 291         if (!req_agg_wsize)
 292                 return max_agg_size;
 293
 294         return min(max_agg_size, req_agg_wsize);
 295 }
 296
 297 /* Block Ack - Rx side (recipient) */
 298 int wil_addba_rx_request(struct wil6210_priv *wil, u8 mid, u8 cid, u8 tid,
 299                          u8 dialog_token, __le16 ba_param_set,
 300                          __le16 ba_timeout, __le16 ba_seq_ctrl)
 301 __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
 302 {
 303         u16 param_set = le16_to_cpu(ba_param_set);
 304         u16 agg_timeout = le16_to_cpu(ba_timeout);
 305         u16 seq_ctrl = le16_to_cpu(ba_seq_ctrl);
 306         struct wil_sta_info *sta;
 307         u16 agg_wsize;
 308         /* bit 0: A-MSDU supported
 309          * bit 1: policy (should be 0 for us)
 310          * bits 2..5: TID
 311          * bits 6..15: buffer size
 312          */
 313         u16 req_agg_wsize = WIL_GET_BITS(param_set, 6, 15);
 314         bool agg_amsdu = wil->use_enhanced_dma_hw &&
 315                 wil->use_rx_hw_reordering &&
 316                 test_bit(WMI_FW_CAPABILITY_AMSDU, wil->fw_capabilities) &&
 317                 wil->amsdu_en && (param_set & BIT(0));
 318         int ba_policy = param_set & BIT(1);
 319         u16 ssn = seq_ctrl >> 4;
 320         struct wil_tid_ampdu_rx *r;
 321         int rc = 0;
 322
 323         might_sleep();
 324
 325         /* sanity checks */
 326         if (cid >= wil->max_assoc_sta) {
 327                 wil_err(wil, "BACK: invalid CID %d\n", cid);
 328                 rc = -EINVAL;
 329                 goto out;
 330         }
 331
 332         sta = &wil->sta[cid];
 333         if (sta->status != wil_sta_connected) {
 334                 wil_err(wil, "BACK: CID %d not connected\n", cid);
 335                 rc = -EINVAL;
 336                 goto out;
 337         }
 338
 339         wil_dbg_wmi(wil,
 340                     "ADDBA request for CID %d %pM TID %d size %d timeout %d AMSDU%s policy %d token %d SSN 0x%03x\n",
 341                     cid, sta->addr, tid, req_agg_wsize, agg_timeout,
 342                     agg_amsdu ? "+" : "-", !!ba_policy, dialog_token, ssn);
 343
 344         /* apply policies */
 345         if (req_agg_wsize == 0) {
 346                 wil_dbg_misc(wil, "Suggest BACK wsize %d\n",
 347                              wil->max_agg_wsize);
 348                 agg_wsize = wil->max_agg_wsize;
 349         } else {
 350                 agg_wsize = min_t(u16, wil->max_agg_wsize, req_agg_wsize);
 351         }
 352
 353         rc = wil->txrx_ops.wmi_addba_rx_resp(wil, mid, cid, tid, dialog_token,
 354                                              WLAN_STATUS_SUCCESS, agg_amsdu,
 355                                              agg_wsize, agg_timeout);
 356         if (rc) {
 357                 wil_err(wil, "do not apply ba, rc(%d)\n", rc);
 358                 goto out;
 359         }
 360
 361         /* apply */
 362         if (!wil->use_rx_hw_reordering) {
 363                 r = wil_tid_ampdu_rx_alloc(wil, agg_wsize, ssn);
 364                 spin_lock_bh(&sta->tid_rx_lock);
 365                 wil_tid_ampdu_rx_free(wil, sta->tid_rx[tid]);
 366                 sta->tid_rx[tid] = r;
 367                 spin_unlock_bh(&sta->tid_rx_lock);
 368         }
 369
 370 out:
 371         return rc;
 372 }
 373
 374 /* BACK - Tx side (originator) */
 375 int wil_addba_tx_request(struct wil6210_priv *wil, u8 ringid, u16 wsize)
 376 {
 377         u8 agg_wsize = wil_agg_size(wil, wsize);
 378         u16 agg_timeout = 0;
 379         struct wil_ring_tx_data *txdata = &wil->ring_tx_data[ringid];
 380         int rc = 0;
 381
 382         if (txdata->addba_in_progress) {
 383                 wil_dbg_misc(wil, "ADDBA for vring[%d] already in progress\n",
 384                              ringid);
 385                 goto out;
 386         }
 387         if (txdata->agg_wsize) {
 388                 wil_dbg_misc(wil,
 389                              "ADDBA for vring[%d] already done for wsize %d\n",
 390                              ringid, txdata->agg_wsize);
 391                 goto out;
 392         }
 393         txdata->addba_in_progress = true;
 394         rc = wmi_addba(wil, txdata->mid, ringid, agg_wsize, agg_timeout);
 395         if (rc) {
 396                 wil_err(wil, "wmi_addba failed, rc (%d)", rc);
 397                 txdata->addba_in_progress = false;
 398         }
 399
 400 out:
 401         return rc;
 402 }