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                 memcpy(skb_put(skb, hdr_len), 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         memcpy(skb_put(skb, copy), 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(MT76_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                 put_page(e->p);
 164                 e->p = new_p;
 165         }
 166 }
 167
 168 static struct mt7601u_dma_buf_rx *
 169 mt7601u_rx_get_pending_entry(struct mt7601u_dev *dev)
 170 {
 171         struct mt7601u_rx_queue *q = &dev->rx_q;
 172         struct mt7601u_dma_buf_rx *buf = NULL;
 173         unsigned long flags;
 174
 175         spin_lock_irqsave(&dev->rx_lock, flags);
 176
 177         if (!q->pending)
 178                 goto out;
 179
 180         buf = &q->e[q->start];
 181         q->pending--;
 182         q->start = (q->start + 1) % q->entries;
 183 out:
 184         spin_unlock_irqrestore(&dev->rx_lock, flags);
 185
 186         return buf;
 187 }
 188
 189 static void mt7601u_complete_rx(struct urb *urb)
 190 {
 191         struct mt7601u_dev *dev = urb->context;
 192         struct mt7601u_rx_queue *q = &dev->rx_q;
 193         unsigned long flags;
 194
 195         /* do no schedule rx tasklet if urb has been unlinked
 196          * or the device has been removed
 197          */
 198         switch (urb->status) {
 199         case -ECONNRESET:
 200         case -ESHUTDOWN:
 201         case -ENOENT:
 202                 return;
 203         default:
 204                 dev_err_ratelimited(dev->dev, "rx urb failed: %d\n",
 205                                     urb->status);
 206                 /* fall through */
 207         case 0:
 208                 break;
 209         }
 210
 211         spin_lock_irqsave(&dev->rx_lock, flags);
 212         if (WARN_ONCE(q->e[q->end].urb != urb, "RX urb mismatch"))
 213                 goto out;
 214
 215         q->end = (q->end + 1) % q->entries;
 216         q->pending++;
 217         tasklet_schedule(&dev->rx_tasklet);
 218 out:
 219         spin_unlock_irqrestore(&dev->rx_lock, flags);
 220 }
 221
 222 static void mt7601u_rx_tasklet(unsigned long data)
 223 {
 224         struct mt7601u_dev *dev = (struct mt7601u_dev *) data;
 225         struct mt7601u_dma_buf_rx *e;
 226
 227         while ((e = mt7601u_rx_get_pending_entry(dev))) {
 228                 if (e->urb->status)
 229                         continue;
 230
 231                 mt7601u_rx_process_entry(dev, e);
 232                 mt7601u_submit_rx_buf(dev, e, GFP_ATOMIC);
 233         }
 234 }
 235
 236 static void mt7601u_complete_tx(struct urb *urb)
 237 {
 238         struct mt7601u_tx_queue *q = urb->context;
 239         struct mt7601u_dev *dev = q->dev;
 240         struct sk_buff *skb;
 241         unsigned long flags;
 242
 243         switch (urb->status) {
 244         case -ECONNRESET:
 245         case -ESHUTDOWN:
 246         case -ENOENT:
 247                 return;
 248         default:
 249                 dev_err_ratelimited(dev->dev, "tx urb failed: %d\n",
 250                                     urb->status);
 251                 /* fall through */
 252         case 0:
 253                 break;
 254         }
 255
 256         spin_lock_irqsave(&dev->tx_lock, flags);
 257         if (WARN_ONCE(q->e[q->start].urb != urb, "TX urb mismatch"))
 258                 goto out;
 259
 260         skb = q->e[q->start].skb;
 261         q->e[q->start].skb = NULL;
 262         trace_mt_tx_dma_done(dev, skb);
 263
 264         __skb_queue_tail(&dev->tx_skb_done, skb);
 265         tasklet_schedule(&dev->tx_tasklet);
 266
 267         if (q->used == q->entries - q->entries / 8)
 268                 ieee80211_wake_queue(dev->hw, skb_get_queue_mapping(skb));
 269
 270         q->start = (q->start + 1) % q->entries;
 271         q->used--;
 272 out:
 273         spin_unlock_irqrestore(&dev->tx_lock, flags);
 274 }
 275
 276 static void mt7601u_tx_tasklet(unsigned long data)
 277 {
 278         struct mt7601u_dev *dev = (struct mt7601u_dev *) data;
 279         struct sk_buff_head skbs;
 280         unsigned long flags;
 281
 282         __skb_queue_head_init(&skbs);
 283
 284         spin_lock_irqsave(&dev->tx_lock, flags);
 285
 286         set_bit(MT7601U_STATE_MORE_STATS, &dev->state);
 287         if (!test_and_set_bit(MT7601U_STATE_READING_STATS, &dev->state))
 288                 queue_delayed_work(dev->stat_wq, &dev->stat_work,
 289                                    msecs_to_jiffies(10));
 290
 291         skb_queue_splice_init(&dev->tx_skb_done, &skbs);
 292
 293         spin_unlock_irqrestore(&dev->tx_lock, flags);
 294
 295         while (!skb_queue_empty(&skbs)) {
 296                 struct sk_buff *skb = __skb_dequeue(&skbs);
 297
 298                 mt7601u_tx_status(dev, skb);
 299         }
 300 }
 301
 302 static int mt7601u_dma_submit_tx(struct mt7601u_dev *dev,
 303                                  struct sk_buff *skb, u8 ep)
 304 {
 305         struct usb_device *usb_dev = mt7601u_to_usb_dev(dev);
 306         unsigned snd_pipe = usb_sndbulkpipe(usb_dev, dev->out_eps[ep]);
 307         struct mt7601u_dma_buf_tx *e;
 308         struct mt7601u_tx_queue *q = &dev->tx_q[ep];
 309         unsigned long flags;
 310         int ret;
 311
 312         spin_lock_irqsave(&dev->tx_lock, flags);
 313
 314         if (WARN_ON(q->entries <= q->used)) {
 315                 ret = -ENOSPC;
 316                 goto out;
 317         }
 318
 319         e = &q->e[q->end];
 320         usb_fill_bulk_urb(e->urb, usb_dev, snd_pipe, skb->data, skb->len,
 321                           mt7601u_complete_tx, q);
 322         ret = usb_submit_urb(e->urb, GFP_ATOMIC);
 323         if (ret) {
 324                 /* Special-handle ENODEV from TX urb submission because it will
 325                  * often be the first ENODEV we see after device is removed.
 326                  */
 327                 if (ret == -ENODEV)
 328                         set_bit(MT7601U_STATE_REMOVED, &dev->state);
 329                 else
 330                         dev_err(dev->dev, "Error: TX urb submit failed:%d\n",
 331                                 ret);
 332                 goto out;
 333         }
 334
 335         q->end = (q->end + 1) % q->entries;
 336         q->used++;
 337         e->skb = skb;
 338
 339         if (q->used >= q->entries)
 340                 ieee80211_stop_queue(dev->hw, skb_get_queue_mapping(skb));
 341 out:
 342         spin_unlock_irqrestore(&dev->tx_lock, flags);
 343
 344         return ret;
 345 }
 346
 347 /* Map hardware Q to USB endpoint number */
 348 static u8 q2ep(u8 qid)
 349 {
 350         /* TODO: take management packets to queue 5 */
 351         return qid + 1;
 352 }
 353
 354 /* Map USB endpoint number to Q id in the DMA engine */
 355 static enum mt76_qsel ep2dmaq(u8 ep)
 356 {
 357         if (ep == 5)
 358                 return MT_QSEL_MGMT;
 359         return MT_QSEL_EDCA;
 360 }
 361
 362 int mt7601u_dma_enqueue_tx(struct mt7601u_dev *dev, struct sk_buff *skb,
 363                            struct mt76_wcid *wcid, int hw_q)
 364 {
 365         u8 ep = q2ep(hw_q);
 366         u32 dma_flags;
 367         int ret;
 368
 369         dma_flags = MT_TXD_PKT_INFO_80211;
 370         if (wcid->hw_key_idx == 0xff)
 371                 dma_flags |= MT_TXD_PKT_INFO_WIV;
 372
 373         ret = mt7601u_dma_skb_wrap_pkt(skb, ep2dmaq(ep), dma_flags);
 374         if (ret)
 375                 return ret;
 376
 377         ret = mt7601u_dma_submit_tx(dev, skb, ep);
 378         if (ret) {
 379                 ieee80211_free_txskb(dev->hw, skb);
 380                 return ret;
 381         }
 382
 383         return 0;
 384 }
 385
 386 static void mt7601u_kill_rx(struct mt7601u_dev *dev)
 387 {
 388         int i;
 389
 390         for (i = 0; i < dev->rx_q.entries; i++)
 391                 usb_poison_urb(dev->rx_q.e[i].urb);
 392 }
 393
 394 static int mt7601u_submit_rx_buf(struct mt7601u_dev *dev,
 395                                  struct mt7601u_dma_buf_rx *e, gfp_t gfp)
 396 {
 397         struct usb_device *usb_dev = mt7601u_to_usb_dev(dev);
 398         u8 *buf = page_address(e->p);
 399         unsigned pipe;
 400         int ret;
 401
 402         pipe = usb_rcvbulkpipe(usb_dev, dev->in_eps[MT_EP_IN_PKT_RX]);
 403
 404         usb_fill_bulk_urb(e->urb, usb_dev, pipe, buf, MT_RX_URB_SIZE,
 405                           mt7601u_complete_rx, dev);
 406
 407         trace_mt_submit_urb(dev, e->urb);
 408         ret = usb_submit_urb(e->urb, gfp);
 409         if (ret)
 410                 dev_err(dev->dev, "Error: submit RX URB failed:%d\n", ret);
 411
 412         return ret;
 413 }
 414
 415 static int mt7601u_submit_rx(struct mt7601u_dev *dev)
 416 {
 417         int i, ret;
 418
 419         for (i = 0; i < dev->rx_q.entries; i++) {
 420                 ret = mt7601u_submit_rx_buf(dev, &dev->rx_q.e[i], GFP_KERNEL);
 421                 if (ret)
 422                         return ret;
 423         }
 424
 425         return 0;
 426 }
 427
 428 static void mt7601u_free_rx(struct mt7601u_dev *dev)
 429 {
 430         int i;
 431
 432         for (i = 0; i < dev->rx_q.entries; i++) {
 433                 __free_pages(dev->rx_q.e[i].p, MT_RX_ORDER);
 434                 usb_free_urb(dev->rx_q.e[i].urb);
 435         }
 436 }
 437
 438 static int mt7601u_alloc_rx(struct mt7601u_dev *dev)
 439 {
 440         int i;
 441
 442         memset(&dev->rx_q, 0, sizeof(dev->rx_q));
 443         dev->rx_q.dev = dev;
 444         dev->rx_q.entries = N_RX_ENTRIES;
 445
 446         for (i = 0; i < N_RX_ENTRIES; i++) {
 447                 dev->rx_q.e[i].urb = usb_alloc_urb(0, GFP_KERNEL);
 448                 dev->rx_q.e[i].p = dev_alloc_pages(MT_RX_ORDER);
 449
 450                 if (!dev->rx_q.e[i].urb || !dev->rx_q.e[i].p)
 451                         return -ENOMEM;
 452         }
 453
 454         return 0;
 455 }
 456
 457 static void mt7601u_free_tx_queue(struct mt7601u_tx_queue *q)
 458 {
 459         int i;
 460
 461         for (i = 0; i < q->entries; i++)  {
 462                 usb_poison_urb(q->e[i].urb);
 463                 if (q->e[i].skb)
 464                         mt7601u_tx_status(q->dev, q->e[i].skb);
 465                 usb_free_urb(q->e[i].urb);
 466         }
 467 }
 468
 469 static void mt7601u_free_tx(struct mt7601u_dev *dev)
 470 {
 471         int i;
 472
 473         for (i = 0; i < __MT_EP_OUT_MAX; i++)
 474                 mt7601u_free_tx_queue(&dev->tx_q[i]);
 475 }
 476
 477 static int mt7601u_alloc_tx_queue(struct mt7601u_dev *dev,
 478                                   struct mt7601u_tx_queue *q)
 479 {
 480         int i;
 481
 482         q->dev = dev;
 483         q->entries = N_TX_ENTRIES;
 484
 485         for (i = 0; i < N_TX_ENTRIES; i++) {
 486                 q->e[i].urb = usb_alloc_urb(0, GFP_KERNEL);
 487                 if (!q->e[i].urb)
 488                         return -ENOMEM;
 489         }
 490
 491         return 0;
 492 }
 493
 494 static int mt7601u_alloc_tx(struct mt7601u_dev *dev)
 495 {
 496         int i;
 497
 498         dev->tx_q = devm_kcalloc(dev->dev, __MT_EP_OUT_MAX,
 499                                  sizeof(*dev->tx_q), GFP_KERNEL);
 500
 501         for (i = 0; i < __MT_EP_OUT_MAX; i++)
 502                 if (mt7601u_alloc_tx_queue(dev, &dev->tx_q[i]))
 503                         return -ENOMEM;
 504
 505         return 0;
 506 }
 507
 508 int mt7601u_dma_init(struct mt7601u_dev *dev)
 509 {
 510         int ret = -ENOMEM;
 511
 512         tasklet_init(&dev->tx_tasklet, mt7601u_tx_tasklet, (unsigned long) dev);
 513         tasklet_init(&dev->rx_tasklet, mt7601u_rx_tasklet, (unsigned long) dev);
 514
 515         ret = mt7601u_alloc_tx(dev);
 516         if (ret)
 517                 goto err;
 518         ret = mt7601u_alloc_rx(dev);
 519         if (ret)
 520                 goto err;
 521
 522         ret = mt7601u_submit_rx(dev);
 523         if (ret)
 524                 goto err;
 525
 526         return 0;
 527 err:
 528         mt7601u_dma_cleanup(dev);
 529         return ret;
 530 }
 531
 532 void mt7601u_dma_cleanup(struct mt7601u_dev *dev)
 533 {
 534         mt7601u_kill_rx(dev);
 535
 536         tasklet_kill(&dev->rx_tasklet);
 537
 538         mt7601u_free_rx(dev);
 539         mt7601u_free_tx(dev);
 540
 541         tasklet_kill(&dev->tx_tasklet);
 542 }