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

   1 /*
   2  * Copyright (c) 2014-2015 Qualcomm Atheros, 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 "wil6210.h"
  18 #include "txrx.h"
  19
  20 #define SEQ_MODULO 0x1000
  21 #define SEQ_MASK   0xfff
  22
  23 static inline int seq_less(u16 sq1, u16 sq2)
  24 {
  25         return ((sq1 - sq2) & SEQ_MASK) > (SEQ_MODULO >> 1);
  26 }
  27
  28 static inline u16 seq_inc(u16 sq)
  29 {
  30         return (sq + 1) & SEQ_MASK;
  31 }
  32
  33 static inline u16 seq_sub(u16 sq1, u16 sq2)
  34 {
  35         return (sq1 - sq2) & SEQ_MASK;
  36 }
  37
  38 static inline int reorder_index(struct wil_tid_ampdu_rx *r, u16 seq)
  39 {
  40         return seq_sub(seq, r->ssn) % r->buf_size;
  41 }
  42
  43 static void wil_release_reorder_frame(struct wil6210_priv *wil,
  44                                       struct wil_tid_ampdu_rx *r,
  45                                       int index)
  46 {
  47         struct net_device *ndev = wil_to_ndev(wil);
  48         struct sk_buff *skb = r->reorder_buf[index];
  49
  50         if (!skb)
  51                 goto no_frame;
  52
  53         /* release the frame from the reorder ring buffer */
  54         r->stored_mpdu_num--;
  55         r->reorder_buf[index] = NULL;
  56         wil_netif_rx_any(skb, ndev);
  57
  58 no_frame:
  59         r->head_seq_num = seq_inc(r->head_seq_num);
  60 }
  61
  62 static void wil_release_reorder_frames(struct wil6210_priv *wil,
  63                                        struct wil_tid_ampdu_rx *r,
  64                                        u16 hseq)
  65 {
  66         int index;
  67
  68         /* note: this function is never called with
  69          * hseq preceding r->head_seq_num, i.e it is always true
  70          * !seq_less(hseq, r->head_seq_num)
  71          * and thus on loop exit it should be
  72          * r->head_seq_num == hseq
  73          */
  74         while (seq_less(r->head_seq_num, hseq) && r->stored_mpdu_num) {
  75                 index = reorder_index(r, r->head_seq_num);
  76                 wil_release_reorder_frame(wil, r, index);
  77         }
  78         r->head_seq_num = hseq;
  79 }
  80
  81 static void wil_reorder_release(struct wil6210_priv *wil,
  82                                 struct wil_tid_ampdu_rx *r)
  83 {
  84         int index = reorder_index(r, r->head_seq_num);
  85
  86         while (r->reorder_buf[index]) {
  87                 wil_release_reorder_frame(wil, r, index);
  88                 index = reorder_index(r, r->head_seq_num);
  89         }
  90 }
  91
  92 /* called in NAPI context */
  93 void wil_rx_reorder(struct wil6210_priv *wil, struct sk_buff *skb)
  94 __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
  95 {
  96         struct net_device *ndev = wil_to_ndev(wil);
  97         struct vring_rx_desc *d = wil_skb_rxdesc(skb);
  98         int tid = wil_rxdesc_tid(d);
  99         int cid = wil_rxdesc_cid(d);
 100         int mid = wil_rxdesc_mid(d);
 101         u16 seq = wil_rxdesc_seq(d);
 102         int mcast = wil_rxdesc_mcast(d);
 103         struct wil_sta_info *sta = &wil->sta[cid];
 104         struct wil_tid_ampdu_rx *r;
 105         u16 hseq;
 106         int index;
 107
 108         wil_dbg_txrx(wil, "MID %d CID %d TID %d Seq 0x%03x mcast %01x\n",
 109                      mid, cid, tid, seq, mcast);
 110
 111         if (unlikely(mcast)) {
 112                 wil_netif_rx_any(skb, ndev);
 113                 return;
 114         }
 115
 116         spin_lock(&sta->tid_rx_lock);
 117
 118         r = sta->tid_rx[tid];
 119         if (!r) {
 120                 wil_netif_rx_any(skb, ndev);
 121                 goto out;
 122         }
 123
 124         r->total++;
 125         hseq = r->head_seq_num;
 126
 127         /** Due to the race between WMI events, where BACK establishment
 128          * reported, and data Rx, few packets may be pass up before reorder
 129          * buffer get allocated. Catch up by pretending SSN is what we
 130          * see in the 1-st Rx packet
 131          *
 132          * Another scenario, Rx get delayed and we got packet from before
 133          * BACK. Pass it to the stack and wait.
 134          */
 135         if (r->first_time) {
 136                 r->first_time = false;
 137                 if (seq != r->head_seq_num) {
 138                         if (seq_less(seq, r->head_seq_num)) {
 139                                 wil_err(wil,
 140                                         "Error: frame with early sequence 0x%03x, should be 0x%03x. Waiting...\n",
 141                                         seq, r->head_seq_num);
 142                                 r->first_time = true;
 143                                 wil_netif_rx_any(skb, ndev);
 144                                 goto out;
 145                         }
 146                         wil_err(wil,
 147                                 "Error: 1-st frame with wrong sequence 0x%03x, should be 0x%03x. Fixing...\n",
 148                                 seq, r->head_seq_num);
 149                         r->head_seq_num = seq;
 150                         r->ssn = seq;
 151                 }
 152         }
 153
 154         /* frame with out of date sequence number */
 155         if (seq_less(seq, r->head_seq_num)) {
 156                 r->ssn_last_drop = seq;
 157                 r->drop_old++;
 158                 wil_dbg_txrx(wil, "Rx drop: old seq 0x%03x head 0x%03x\n",
 159                              seq, r->head_seq_num);
 160                 dev_kfree_skb(skb);
 161                 goto out;
 162         }
 163
 164         /*
 165          * If frame the sequence number exceeds our buffering window
 166          * size release some previous frames to make room for this one.
 167          */
 168         if (!seq_less(seq, r->head_seq_num + r->buf_size)) {
 169                 hseq = seq_inc(seq_sub(seq, r->buf_size));
 170                 /* release stored frames up to new head to stack */
 171                 wil_release_reorder_frames(wil, r, hseq);
 172         }
 173
 174         /* Now the new frame is always in the range of the reordering buffer */
 175
 176         index = reorder_index(r, seq);
 177
 178         /* check if we already stored this frame */
 179         if (r->reorder_buf[index]) {
 180                 r->drop_dup++;
 181                 wil_dbg_txrx(wil, "Rx drop: dup seq 0x%03x\n", seq);
 182                 dev_kfree_skb(skb);
 183                 goto out;
 184         }
 185
 186         /*
 187          * If the current MPDU is in the right order and nothing else
 188          * is stored we can process it directly, no need to buffer it.
 189          * If it is first but there's something stored, we may be able
 190          * to release frames after this one.
 191          */
 192         if (seq == r->head_seq_num && r->stored_mpdu_num == 0) {
 193                 r->head_seq_num = seq_inc(r->head_seq_num);
 194                 wil_netif_rx_any(skb, ndev);
 195                 goto out;
 196         }
 197
 198         /* put the frame in the reordering buffer */
 199         r->reorder_buf[index] = skb;
 200         r->reorder_time[index] = jiffies;
 201         r->stored_mpdu_num++;
 202         wil_reorder_release(wil, r);
 203
 204 out:
 205         spin_unlock(&sta->tid_rx_lock);
 206 }
 207
 208 /* process BAR frame, called in NAPI context */
 209 void wil_rx_bar(struct wil6210_priv *wil, u8 cid, u8 tid, u16 seq)
 210 {
 211         struct wil_sta_info *sta = &wil->sta[cid];
 212         struct wil_tid_ampdu_rx *r;
 213
 214         spin_lock(&sta->tid_rx_lock);
 215
 216         r = sta->tid_rx[tid];
 217         if (!r) {
 218                 wil_err(wil, "BAR for non-existing CID %d TID %d\n", cid, tid);
 219                 goto out;
 220         }
 221         if (seq_less(seq, r->head_seq_num)) {
 222                 wil_err(wil, "BAR Seq 0x%03x preceding head 0x%03x\n",
 223                         seq, r->head_seq_num);
 224                 goto out;
 225         }
 226         wil_dbg_txrx(wil, "BAR: CID %d TID %d Seq 0x%03x head 0x%03x\n",
 227                      cid, tid, seq, r->head_seq_num);
 228         wil_release_reorder_frames(wil, r, seq);
 229
 230 out:
 231         spin_unlock(&sta->tid_rx_lock);
 232 }
 233
 234 struct wil_tid_ampdu_rx *wil_tid_ampdu_rx_alloc(struct wil6210_priv *wil,
 235                                                 int size, u16 ssn)
 236 {
 237         struct wil_tid_ampdu_rx *r = kzalloc(sizeof(*r), GFP_KERNEL);
 238
 239         if (!r)
 240                 return NULL;
 241
 242         r->reorder_buf =
 243                 kcalloc(size, sizeof(struct sk_buff *), GFP_KERNEL);
 244         r->reorder_time =
 245                 kcalloc(size, sizeof(unsigned long), GFP_KERNEL);
 246         if (!r->reorder_buf || !r->reorder_time) {
 247                 kfree(r->reorder_buf);
 248                 kfree(r->reorder_time);
 249                 kfree(r);
 250                 return NULL;
 251         }
 252
 253         r->ssn = ssn;
 254         r->head_seq_num = ssn;
 255         r->buf_size = size;
 256         r->stored_mpdu_num = 0;
 257         r->first_time = true;
 258         return r;
 259 }
 260
 261 void wil_tid_ampdu_rx_free(struct wil6210_priv *wil,
 262                            struct wil_tid_ampdu_rx *r)
 263 {
 264         if (!r)
 265                 return;
 266         wil_release_reorder_frames(wil, r, r->head_seq_num + r->buf_size);
 267         kfree(r->reorder_buf);
 268         kfree(r->reorder_time);
 269         kfree(r);
 270 }
 271
 272 /* ADDBA processing */
 273 static u16 wil_agg_size(struct wil6210_priv *wil, u16 req_agg_wsize)
 274 {
 275         u16 max_agg_size = min_t(u16, WIL_MAX_AGG_WSIZE, WIL_MAX_AMPDU_SIZE /
 276                                  (mtu_max + WIL_MAX_MPDU_OVERHEAD));
 277
 278         if (!req_agg_wsize)
 279                 return max_agg_size;
 280
 281         return min(max_agg_size, req_agg_wsize);
 282 }
 283
 284 /* Block Ack - Rx side (recipient */
 285 int wil_addba_rx_request(struct wil6210_priv *wil, u8 cidxtid,
 286                          u8 dialog_token, __le16 ba_param_set,
 287                          __le16 ba_timeout, __le16 ba_seq_ctrl)
 288 {
 289         struct wil_back_rx *req = kzalloc(sizeof(*req), GFP_KERNEL);
 290
 291         if (!req)
 292                 return -ENOMEM;
 293
 294         req->cidxtid = cidxtid;
 295         req->dialog_token = dialog_token;
 296         req->ba_param_set = le16_to_cpu(ba_param_set);
 297         req->ba_timeout = le16_to_cpu(ba_timeout);
 298         req->ba_seq_ctrl = le16_to_cpu(ba_seq_ctrl);
 299
 300         mutex_lock(&wil->back_rx_mutex);
 301         list_add_tail(&req->list, &wil->back_rx_pending);
 302         mutex_unlock(&wil->back_rx_mutex);
 303
 304         queue_work(wil->wq_service, &wil->back_rx_worker);
 305
 306         return 0;
 307 }
 308
 309 static void wil_back_rx_handle(struct wil6210_priv *wil,
 310                                struct wil_back_rx *req)
 311 __acquires(&sta->tid_rx_lock) __releases(&sta->tid_rx_lock)
 312 {
 313         struct wil_sta_info *sta;
 314         u8 cid, tid;
 315         u16 agg_wsize = 0;
 316         /* bit 0: A-MSDU supported
 317          * bit 1: policy (should be 0 for us)
 318          * bits 2..5: TID
 319          * bits 6..15: buffer size
 320          */
 321         u16 req_agg_wsize = WIL_GET_BITS(req->ba_param_set, 6, 15);
 322         bool agg_amsdu = !!(req->ba_param_set & BIT(0));
 323         int ba_policy = req->ba_param_set & BIT(1);
 324         u16 agg_timeout = req->ba_timeout;
 325         u16 status = WLAN_STATUS_SUCCESS;
 326         u16 ssn = req->ba_seq_ctrl >> 4;
 327         struct wil_tid_ampdu_rx *r;
 328         int rc;
 329
 330         might_sleep();
 331         parse_cidxtid(req->cidxtid, &cid, &tid);
 332
 333         /* sanity checks */
 334         if (cid >= WIL6210_MAX_CID) {
 335                 wil_err(wil, "BACK: invalid CID %d\n", cid);
 336                 return;
 337         }
 338
 339         sta = &wil->sta[cid];
 340         if (sta->status != wil_sta_connected) {
 341                 wil_err(wil, "BACK: CID %d not connected\n", cid);
 342                 return;
 343         }
 344
 345         wil_dbg_wmi(wil,
 346                     "ADDBA request for CID %d %pM TID %d size %d timeout %d AMSDU%s policy %d token %d SSN 0x%03x\n",
 347                     cid, sta->addr, tid, req_agg_wsize, req->ba_timeout,
 348                     agg_amsdu ? "+" : "-", !!ba_policy, req->dialog_token, ssn);
 349
 350         /* apply policies */
 351         if (ba_policy) {
 352                 wil_err(wil, "BACK requested unsupported ba_policy == 1\n");
 353                 status = WLAN_STATUS_INVALID_QOS_PARAM;
 354         }
 355         if (status == WLAN_STATUS_SUCCESS)
 356                 agg_wsize = wil_agg_size(wil, req_agg_wsize);
 357
 358         rc = wmi_addba_rx_resp(wil, cid, tid, req->dialog_token, status,
 359                                agg_amsdu, agg_wsize, agg_timeout);
 360         if (rc || (status != WLAN_STATUS_SUCCESS))
 361                 return;
 362
 363         /* apply */
 364         r = wil_tid_ampdu_rx_alloc(wil, agg_wsize, ssn);
 365         spin_lock_bh(&sta->tid_rx_lock);
 366         wil_tid_ampdu_rx_free(wil, sta->tid_rx[tid]);
 367         sta->tid_rx[tid] = r;
 368         spin_unlock_bh(&sta->tid_rx_lock);
 369 }
 370
 371 void wil_back_rx_flush(struct wil6210_priv *wil)
 372 {
 373         struct wil_back_rx *evt, *t;
 374
 375         wil_dbg_misc(wil, "%s()\n", __func__);
 376
 377         mutex_lock(&wil->back_rx_mutex);
 378
 379         list_for_each_entry_safe(evt, t, &wil->back_rx_pending, list) {
 380                 list_del(&evt->list);
 381                 kfree(evt);
 382         }
 383
 384         mutex_unlock(&wil->back_rx_mutex);
 385 }
 386
 387 /* Retrieve next ADDBA request from the pending list */
 388 static struct list_head *next_back_rx(struct wil6210_priv *wil)
 389 {
 390         struct list_head *ret = NULL;
 391
 392         mutex_lock(&wil->back_rx_mutex);
 393
 394         if (!list_empty(&wil->back_rx_pending)) {
 395                 ret = wil->back_rx_pending.next;
 396                 list_del(ret);
 397         }
 398
 399         mutex_unlock(&wil->back_rx_mutex);
 400
 401         return ret;
 402 }
 403
 404 void wil_back_rx_worker(struct work_struct *work)
 405 {
 406         struct wil6210_priv *wil = container_of(work, struct wil6210_priv,
 407                                                 back_rx_worker);
 408         struct wil_back_rx *evt;
 409         struct list_head *lh;
 410
 411         while ((lh = next_back_rx(wil)) != NULL) {
 412                 evt = list_entry(lh, struct wil_back_rx, list);
 413
 414                 wil_back_rx_handle(wil, evt);
 415                 kfree(evt);
 416         }
 417 }
 418
 419 /* BACK - Tx (originator) side */
 420 static void wil_back_tx_handle(struct wil6210_priv *wil,
 421                                struct wil_back_tx *req)
 422 {
 423         struct vring_tx_data *txdata = &wil->vring_tx_data[req->ringid];
 424         int rc;
 425
 426         if (txdata->addba_in_progress) {
 427                 wil_dbg_misc(wil, "ADDBA for vring[%d] already in progress\n",
 428                              req->ringid);
 429                 return;
 430         }
 431         if (txdata->agg_wsize) {
 432                 wil_dbg_misc(wil,
 433                              "ADDBA for vring[%d] already established wsize %d\n",
 434                              req->ringid, txdata->agg_wsize);
 435                 return;
 436         }
 437         txdata->addba_in_progress = true;
 438         rc = wmi_addba(wil, req->ringid, req->agg_wsize, req->agg_timeout);
 439         if (rc)
 440                 txdata->addba_in_progress = false;
 441 }
 442
 443 static struct list_head *next_back_tx(struct wil6210_priv *wil)
 444 {
 445         struct list_head *ret = NULL;
 446
 447         mutex_lock(&wil->back_tx_mutex);
 448
 449         if (!list_empty(&wil->back_tx_pending)) {
 450                 ret = wil->back_tx_pending.next;
 451                 list_del(ret);
 452         }
 453
 454         mutex_unlock(&wil->back_tx_mutex);
 455
 456         return ret;
 457 }
 458
 459 void wil_back_tx_worker(struct work_struct *work)
 460 {
 461         struct wil6210_priv *wil = container_of(work, struct wil6210_priv,
 462                                                  back_tx_worker);
 463         struct wil_back_tx *evt;
 464         struct list_head *lh;
 465
 466         while ((lh = next_back_tx(wil)) != NULL) {
 467                 evt = list_entry(lh, struct wil_back_tx, list);
 468
 469                 wil_back_tx_handle(wil, evt);
 470                 kfree(evt);
 471         }
 472 }
 473
 474 void wil_back_tx_flush(struct wil6210_priv *wil)
 475 {
 476         struct wil_back_tx *evt, *t;
 477
 478         wil_dbg_misc(wil, "%s()\n", __func__);
 479
 480         mutex_lock(&wil->back_tx_mutex);
 481
 482         list_for_each_entry_safe(evt, t, &wil->back_tx_pending, list) {
 483                 list_del(&evt->list);
 484                 kfree(evt);
 485         }
 486
 487         mutex_unlock(&wil->back_tx_mutex);
 488 }
 489
 490 int wil_addba_tx_request(struct wil6210_priv *wil, u8 ringid, u16 wsize)
 491 {
 492         struct wil_back_tx *req = kzalloc(sizeof(*req), GFP_KERNEL);
 493
 494         if (!req)
 495                 return -ENOMEM;
 496
 497         req->ringid = ringid;
 498         req->agg_wsize = wil_agg_size(wil, wsize);
 499         req->agg_timeout = 0;
 500
 501         mutex_lock(&wil->back_tx_mutex);
 502         list_add_tail(&req->list, &wil->back_tx_pending);
 503         mutex_unlock(&wil->back_tx_mutex);
 504
 505         queue_work(wil->wq_service, &wil->back_tx_worker);
 506
 507         return 0;
 508 }