drivers/net/wireless/mediatek/mt7601u/dma.c

   1 /*
   2  * Copyright (C) 2015 Jakub Kicinski <kubakici@wp.pl>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2
   6  * as published by the Free Software Foundation
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include "mt7601u.h"
  15 #include "dma.h"
  16 #include "usb.h"
  17 #include "trace.h"
  18
  19 static int mt7601u_submit_rx_buf(struct mt7601u_dev *dev,
  20                                  struct mt7601u_dma_buf_rx *e, gfp_t gfp);
  21
  22 static unsigned int ieee80211_get_hdrlen_from_buf(const u8 *data, unsigned len)
  23 {
  24         const struct ieee80211_hdr *hdr = (const struct ieee80211_hdr *)data;
  25         unsigned int hdrlen;
  26
  27         if (unlikely(len < 10))
  28                 return 0;
  29         hdrlen = ieee80211_hdrlen(hdr->frame_control);
  30         if (unlikely(hdrlen > len))
  31                 return 0;
  32         return hdrlen;
  33 }
  34
  35 static struct sk_buff *
  36 mt7601u_rx_skb_from_seg(struct mt7601u_dev *dev, struct mt7601u_rxwi *rxwi,
  37                         void *data, u32 seg_len, u32 truesize, struct page *p)
  38 {
  39         struct sk_buff *skb;
  40         u32 true_len, hdr_len = 0, copy, frag;
  41
  42         skb = alloc_skb(p ? 128 : seg_len, GFP_ATOMIC);
  43         if (!skb)
  44                 return NULL;
  45
  46         true_len = mt76_mac_process_rx(dev, skb, data, rxwi);
  47         if (!true_len || true_len > seg_len)
  48                 goto bad_frame;
  49
  50         hdr_len = ieee80211_get_hdrlen_from_buf(data, true_len);
  51         if (!hdr_len)
  52                 goto bad_frame;
  53
  54         if (rxwi->rxinfo & cpu_to_le32(MT_RXINFO_L2PAD)) {
  55                 skb_put_data(skb, data, hdr_len);
  56
  57                 data += hdr_len + 2;
  58                 true_len -= hdr_len;
  59                 hdr_len = 0;
  60         }
  61
  62         /* If not doing paged RX allocated skb will always have enough space */
  63         copy = (true_len <= skb_tailroom(skb)) ? true_len : hdr_len + 8;
  64         frag = true_len - copy;
  65
  66         skb_put_data(skb, data, copy);
  67         data += copy;
  68
  69         if (frag) {
  70                 skb_add_rx_frag(skb, 0, p, data - page_address(p),
  71                                 frag, truesize);
  72                 get_page(p);
  73         }
  74
  75         return skb;
  76
  77 bad_frame:
  78         dev_err_ratelimited(dev->dev, "Error: incorrect frame len:%u hdr:%u\n",
  79                             true_len, hdr_len);
  80         dev_kfree_skb(skb);
  81         return NULL;
  82 }
  83
  84 static void mt7601u_rx_process_seg(struct mt7601u_dev *dev, u8 *data,
  85                                    u32 seg_len, struct page *p)
  86 {
  87         struct sk_buff *skb;
  88         struct mt7601u_rxwi *rxwi;
  89         u32 fce_info, truesize = seg_len;
  90
  91         /* DMA_INFO field at the beginning of the segment contains only some of
  92          * the information, we need to read the FCE descriptor from the end.
  93          */
  94         fce_info = get_unaligned_le32(data + seg_len - MT_FCE_INFO_LEN);
  95         seg_len -= MT_FCE_INFO_LEN;
  96
  97         data += MT_DMA_HDR_LEN;
  98         seg_len -= MT_DMA_HDR_LEN;
  99
 100         rxwi = (struct mt7601u_rxwi *) data;
 101         data += sizeof(struct mt7601u_rxwi);
 102         seg_len -= sizeof(struct mt7601u_rxwi);
 103
 104         if (unlikely(rxwi->zero[0] || rxwi->zero[1] || rxwi->zero[2]))
 105                 dev_err_once(dev->dev, "Error: RXWI zero fields are set\n");
 106         if (unlikely(FIELD_GET(MT_RXD_INFO_TYPE, fce_info)))
 107                 dev_err_once(dev->dev, "Error: RX path seen a non-pkt urb\n");
 108
 109         trace_mt_rx(dev, rxwi, fce_info);
 110
 111         skb = mt7601u_rx_skb_from_seg(dev, rxwi, data, seg_len, truesize, p);
 112         if (!skb)
 113                 return;
 114
 115         spin_lock(&dev->mac_lock);
 116         ieee80211_rx(dev->hw, skb);
 117         spin_unlock(&dev->mac_lock);
 118 }
 119
 120 static u16 mt7601u_rx_next_seg_len(u8 *data, u32 data_len)
 121 {
 122         u32 min_seg_len = MT_DMA_HDR_LEN + MT_RX_INFO_LEN +
 123                 sizeof(struct mt7601u_rxwi) + MT_FCE_INFO_LEN;
 124         u16 dma_len = get_unaligned_le16(data);
 125
 126         if (data_len < min_seg_len ||
 127             WARN_ON(!dma_len) ||
 128             WARN_ON(dma_len + MT_DMA_HDRS > data_len) ||
 129             WARN_ON(dma_len & 0x3))
 130                 return 0;
 131
 132         return MT_DMA_HDRS + dma_len;
 133 }
 134
 135 static void
 136 mt7601u_rx_process_entry(struct mt7601u_dev *dev, struct mt7601u_dma_buf_rx *e)
 137 {
 138         u32 seg_len, data_len = e->urb->actual_length;
 139         u8 *data = page_address(e->p);
 140         struct page *new_p = NULL;
 141         int cnt = 0;
 142
 143         if (!test_bit(MT7601U_STATE_INITIALIZED, &dev->state))
 144                 return;
 145
 146         /* Copy if there is very little data in the buffer. */
 147         if (data_len > 512)
 148                 new_p = dev_alloc_pages(MT_RX_ORDER);
 149
 150         while ((seg_len = mt7601u_rx_next_seg_len(data, data_len))) {
 151                 mt7601u_rx_process_seg(dev, data, seg_len, new_p ? e->p : NULL);
 152
 153                 data_len -= seg_len;
 154                 data += seg_len;
 155                 cnt++;
 156         }
 157
 158         if (cnt > 1)
 159                 trace_mt_rx_dma_aggr(dev, cnt, !!new_p);
 160
 161         if (new_p) {
 162                 /* we have one extra ref from the allocator */
 163                 __free_pages(e->p, MT_RX_ORDER);
 164
 165                 e->p = new_p;
 166         }
 167 }
 168
 169 static struct mt7601u_dma_buf_rx *
 170 mt7601u_rx_get_pending_entry(struct mt7601u_dev *dev)
 171 {
 172         struct mt7601u_rx_queue *q = &dev->rx_q;
 173         struct mt7601u_dma_buf_rx *buf = NULL;
 174         unsigned long flags;
 175
 176         spin_lock_irqsave(&dev->rx_lock, flags);
 177
 178         if (!q->pending)
 179                 goto out;
 180
 181         buf = &q->e[q->start];
 182         q->pending--;
 183         q->start = (q->start + 1) % q->entries;
 184 out:
 185         spin_unlock_irqrestore(&dev->rx_lock, flags);
 186
 187         return buf;
 188 }
 189
 190 static void mt7601u_complete_rx(struct urb *urb)
 191 {
 192         struct mt7601u_dev *dev = urb->context;
 193         struct mt7601u_rx_queue *q = &dev->rx_q;
 194         unsigned long flags;
 195
 196         /* do no schedule rx tasklet if urb has been unlinked
 197          * or the device has been removed
 198          */
 199         switch (urb->status) {
 200         case -ECONNRESET:
 201         case -ESHUTDOWN:
 202         case -ENOENT:
 203                 return;
 204         default:
 205                 dev_err_ratelimited(dev->dev, "rx urb failed: %d\n",
 206                                     urb->status);
 207                 /* fall through */
 208         case 0:
 209                 break;
 210         }
 211
 212         spin_lock_irqsave(&dev->rx_lock, flags);
 213         if (WARN_ONCE(q->e[q->end].urb != urb, "RX urb mismatch"))
 214                 goto out;
 215
 216         q->end = (q->end + 1) % q->entries;
 217         q->pending++;
 218         tasklet_schedule(&dev->rx_tasklet);
 219 out:
 220         spin_unlock_irqrestore(&dev->rx_lock, flags);
 221 }
 222
 223 static void mt7601u_rx_tasklet(unsigned long data)
 224 {
 225         struct mt7601u_dev *dev = (struct mt7601u_dev *) data;
 226         struct mt7601u_dma_buf_rx *e;
 227
 228         while ((e = mt7601u_rx_get_pending_entry(dev))) {
 229                 if (e->urb->status)
 230                         continue;
 231
 232                 mt7601u_rx_process_entry(dev, e);
 233                 mt7601u_submit_rx_buf(dev, e, GFP_ATOMIC);
 234         }
 235 }
 236
 237 static void mt7601u_complete_tx(struct urb *urb)
 238 {
 239         struct mt7601u_tx_queue *q = urb->context;
 240         struct mt7601u_dev *dev = q->dev;
 241         struct sk_buff *skb;
 242         unsigned long flags;
 243
 244         switch (urb->status) {
 245         case -ECONNRESET:
 246         case -ESHUTDOWN:
 247         case -ENOENT:
 248                 return;
 249         default:
 250                 dev_err_ratelimited(dev->dev, "tx urb failed: %d\n",
 251                                     urb->status);
 252                 /* fall through */
 253         case 0:
 254                 break;
 255         }
 256
 257         spin_lock_irqsave(&dev->tx_lock, flags);
 258         if (WARN_ONCE(q->e[q->start].urb != urb, "TX urb mismatch"))
 259                 goto out;
 260
 261         skb = q->e[q->start].skb;
 262         q->e[q->start].skb = NULL;
 263         trace_mt_tx_dma_done(dev, skb);
 264
 265         __skb_queue_tail(&dev->tx_skb_done, skb);
 266         tasklet_schedule(&dev->tx_tasklet);
 267
 268         if (q->used == q->entries - q->entries / 8)
 269                 ieee80211_wake_queue(dev->hw, skb_get_queue_mapping(skb));
 270
 271         q->start = (q->start + 1) % q->entries;
 272         q->used--;
 273 out:
 274         spin_unlock_irqrestore(&dev->tx_lock, flags);
 275 }
 276
 277 static void mt7601u_tx_tasklet(unsigned long data)
 278 {
 279         struct mt7601u_dev *dev = (struct mt7601u_dev *) data;
 280         struct sk_buff_head skbs;
 281         unsigned long flags;
 282
 283         __skb_queue_head_init(&skbs);
 284
 285         spin_lock_irqsave(&dev->tx_lock, flags);
 286
 287         set_bit(MT7601U_STATE_MORE_STATS, &dev->state);
 288         if (!test_and_set_bit(MT7601U_STATE_READING_STATS, &dev->state))
 289                 queue_delayed_work(dev->stat_wq, &dev->stat_work,
 290                                    msecs_to_jiffies(10));
 291
 292         skb_queue_splice_init(&dev->tx_skb_done, &skbs);
 293
 294         spin_unlock_irqrestore(&dev->tx_lock, flags);
 295
 296         while (!skb_queue_empty(&skbs)) {
 297                 struct sk_buff *skb = __skb_dequeue(&skbs);
 298
 299                 mt7601u_tx_status(dev, skb);
 300         }
 301 }
 302
 303 static int mt7601u_dma_submit_tx(struct mt7601u_dev *dev,
 304                                  struct sk_buff *skb, u8 ep)
 305 {
 306         struct usb_device *usb_dev = mt7601u_to_usb_dev(dev);
 307         unsigned snd_pipe = usb_sndbulkpipe(usb_dev, dev->out_eps[ep]);
 308         struct mt7601u_dma_buf_tx *e;
 309         struct mt7601u_tx_queue *q = &dev->tx_q[ep];
 310         unsigned long flags;
 311         int ret;
 312
 313         spin_lock_irqsave(&dev->tx_lock, flags);
 314
 315         if (WARN_ON(q->entries <= q->used)) {
 316                 ret = -ENOSPC;
 317                 goto out;
 318         }
 319
 320         e = &q->e[q->end];
 321         e->skb = skb;
 322         usb_fill_bulk_urb(e->urb, usb_dev, snd_pipe, skb->data, skb->len,
 323                           mt7601u_complete_tx, q);
 324         ret = usb_submit_urb(e->urb, GFP_ATOMIC);
 325         if (ret) {
 326                 /* Special-handle ENODEV from TX urb submission because it will
 327                  * often be the first ENODEV we see after device is removed.
 328                  */
 329                 if (ret == -ENODEV)
 330                         set_bit(MT7601U_STATE_REMOVED, &dev->state);
 331                 else
 332                         dev_err(dev->dev, "Error: TX urb submit failed:%d\n",
 333                                 ret);
 334                 goto out;
 335         }
 336
 337         q->end = (q->end + 1) % q->entries;
 338         q->used++;
 339
 340         if (q->used >= q->entries)
 341                 ieee80211_stop_queue(dev->hw, skb_get_queue_mapping(skb));
 342 out:
 343         spin_unlock_irqrestore(&dev->tx_lock, flags);
 344
 345         return ret;
 346 }
 347
 348 /* Map hardware Q to USB endpoint number */
 349 static u8 q2ep(u8 qid)
 350 {
 351         /* TODO: take management packets to queue 5 */
 352         return qid + 1;
 353 }
 354
 355 /* Map USB endpoint number to Q id in the DMA engine */
 356 static enum mt76_qsel ep2dmaq(u8 ep)
 357 {
 358         if (ep == 5)
 359                 return MT_QSEL_MGMT;
 360         return MT_QSEL_EDCA;
 361 }
 362
 363 int mt7601u_dma_enqueue_tx(struct mt7601u_dev *dev, struct sk_buff *skb,
 364                            struct mt76_wcid *wcid, int hw_q)
 365 {
 366         u8 ep = q2ep(hw_q);
 367         u32 dma_flags;
 368         int ret;
 369
 370         dma_flags = MT_TXD_PKT_INFO_80211;
 371         if (wcid->hw_key_idx == 0xff)
 372                 dma_flags |= MT_TXD_PKT_INFO_WIV;
 373
 374         ret = mt7601u_dma_skb_wrap_pkt(skb, ep2dmaq(ep), dma_flags);
 375         if (ret)
 376                 return ret;
 377
 378         ret = mt7601u_dma_submit_tx(dev, skb, ep);
 379         if (ret) {
 380                 ieee80211_free_txskb(dev->hw, skb);
 381                 return ret;
 382         }
 383
 384         return 0;
 385 }
 386
 387 static void mt7601u_kill_rx(struct mt7601u_dev *dev)
 388 {
 389         int i;
 390
 391         for (i = 0; i < dev->rx_q.entries; i++)
 392                 usb_poison_urb(dev->rx_q.e[i].urb);
 393 }
 394
 395 static int mt7601u_submit_rx_buf(struct mt7601u_dev *dev,
 396                                  struct mt7601u_dma_buf_rx *e, gfp_t gfp)
 397 {
 398         struct usb_device *usb_dev = mt7601u_to_usb_dev(dev);
 399         u8 *buf = page_address(e->p);
 400         unsigned pipe;
 401         int ret;
 402
 403         pipe = usb_rcvbulkpipe(usb_dev, dev->in_eps[MT_EP_IN_PKT_RX]);
 404
 405         usb_fill_bulk_urb(e->urb, usb_dev, pipe, buf, MT_RX_URB_SIZE,
 406                           mt7601u_complete_rx, dev);
 407
 408         trace_mt_submit_urb(dev, e->urb);
 409         ret = usb_submit_urb(e->urb, gfp);
 410         if (ret)
 411                 dev_err(dev->dev, "Error: submit RX URB failed:%d\n", ret);
 412
 413         return ret;
 414 }
 415
 416 static int mt7601u_submit_rx(struct mt7601u_dev *dev)
 417 {
 418         int i, ret;
 419
 420         for (i = 0; i < dev->rx_q.entries; i++) {
 421                 ret = mt7601u_submit_rx_buf(dev, &dev->rx_q.e[i], GFP_KERNEL);
 422                 if (ret)
 423                         return ret;
 424         }
 425
 426         return 0;
 427 }
 428
 429 static void mt7601u_free_rx(struct mt7601u_dev *dev)
 430 {
 431         int i;
 432
 433         for (i = 0; i < dev->rx_q.entries; i++) {
 434                 __free_pages(dev->rx_q.e[i].p, MT_RX_ORDER);
 435                 usb_free_urb(dev->rx_q.e[i].urb);
 436         }
 437 }
 438
 439 static int mt7601u_alloc_rx(struct mt7601u_dev *dev)
 440 {
 441         int i;
 442
 443         memset(&dev->rx_q, 0, sizeof(dev->rx_q));
 444         dev->rx_q.dev = dev;
 445         dev->rx_q.entries = N_RX_ENTRIES;
 446
 447         for (i = 0; i < N_RX_ENTRIES; i++) {
 448                 dev->rx_q.e[i].urb = usb_alloc_urb(0, GFP_KERNEL);
 449                 dev->rx_q.e[i].p = dev_alloc_pages(MT_RX_ORDER);
 450
 451                 if (!dev->rx_q.e[i].urb || !dev->rx_q.e[i].p)
 452                         return -ENOMEM;
 453         }
 454
 455         return 0;
 456 }
 457
 458 static void mt7601u_free_tx_queue(struct mt7601u_tx_queue *q)
 459 {
 460         int i;
 461
 462         for (i = 0; i < q->entries; i++)  {
 463                 usb_poison_urb(q->e[i].urb);
 464                 if (q->e[i].skb)
 465                         mt7601u_tx_status(q->dev, q->e[i].skb);
 466                 usb_free_urb(q->e[i].urb);
 467         }
 468 }
 469
 470 static void mt7601u_free_tx(struct mt7601u_dev *dev)
 471 {
 472         int i;
 473
 474         if (!dev->tx_q)
 475                 return;
 476
 477         for (i = 0; i < __MT_EP_OUT_MAX; i++)
 478                 mt7601u_free_tx_queue(&dev->tx_q[i]);
 479 }
 480
 481 static int mt7601u_alloc_tx_queue(struct mt7601u_dev *dev,
 482                                   struct mt7601u_tx_queue *q)
 483 {
 484         int i;
 485
 486         q->dev = dev;
 487         q->entries = N_TX_ENTRIES;
 488
 489         for (i = 0; i < N_TX_ENTRIES; i++) {
 490                 q->e[i].urb = usb_alloc_urb(0, GFP_KERNEL);
 491                 if (!q->e[i].urb)
 492                         return -ENOMEM;
 493         }
 494
 495         return 0;
 496 }
 497
 498 static int mt7601u_alloc_tx(struct mt7601u_dev *dev)
 499 {
 500         int i;
 501
 502         dev->tx_q = devm_kcalloc(dev->dev, __MT_EP_OUT_MAX,
 503                                  sizeof(*dev->tx_q), GFP_KERNEL);
 504         if (!dev->tx_q)
 505                 return -ENOMEM;
 506
 507         for (i = 0; i < __MT_EP_OUT_MAX; i++)
 508                 if (mt7601u_alloc_tx_queue(dev, &dev->tx_q[i]))
 509                         return -ENOMEM;
 510
 511         return 0;
 512 }
 513
 514 int mt7601u_dma_init(struct mt7601u_dev *dev)
 515 {
 516         int ret = -ENOMEM;
 517
 518         tasklet_init(&dev->tx_tasklet, mt7601u_tx_tasklet, (unsigned long) dev);
 519         tasklet_init(&dev->rx_tasklet, mt7601u_rx_tasklet, (unsigned long) dev);
 520
 521         ret = mt7601u_alloc_tx(dev);
 522         if (ret)
 523                 goto err;
 524         ret = mt7601u_alloc_rx(dev);
 525         if (ret)
 526                 goto err;
 527
 528         ret = mt7601u_submit_rx(dev);
 529         if (ret)
 530                 goto err;
 531
 532         return 0;
 533 err:
 534         mt7601u_dma_cleanup(dev);
 535         return ret;
 536 }
 537
 538 void mt7601u_dma_cleanup(struct mt7601u_dev *dev)
 539 {
 540         mt7601u_kill_rx(dev);
 541
 542         tasklet_kill(&dev->rx_tasklet);
 543
 544         mt7601u_free_rx(dev);
 545         mt7601u_free_tx(dev);
 546
 547         tasklet_kill(&dev->tx_tasklet);
 548 }