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         ieee80211_rx_ni(dev->hw, skb);
 116 }
 117
 118 static u16 mt7601u_rx_next_seg_len(u8 *data, u32 data_len)
 119 {
 120         u32 min_seg_len = MT_DMA_HDR_LEN + MT_RX_INFO_LEN +
 121                 sizeof(struct mt7601u_rxwi) + MT_FCE_INFO_LEN;
 122         u16 dma_len = get_unaligned_le16(data);
 123
 124         if (data_len < min_seg_len ||
 125             WARN_ON(!dma_len) ||
 126             WARN_ON(dma_len + MT_DMA_HDRS > data_len) ||
 127             WARN_ON(dma_len & 0x3))
 128                 return 0;
 129
 130         return MT_DMA_HDRS + dma_len;
 131 }
 132
 133 static void
 134 mt7601u_rx_process_entry(struct mt7601u_dev *dev, struct mt7601u_dma_buf_rx *e)
 135 {
 136         u32 seg_len, data_len = e->urb->actual_length;
 137         u8 *data = page_address(e->p);
 138         struct page *new_p = NULL;
 139         int cnt = 0;
 140
 141         if (!test_bit(MT7601U_STATE_INITIALIZED, &dev->state))
 142                 return;
 143
 144         /* Copy if there is very little data in the buffer. */
 145         if (data_len > 512)
 146                 new_p = dev_alloc_pages(MT_RX_ORDER);
 147
 148         while ((seg_len = mt7601u_rx_next_seg_len(data, data_len))) {
 149                 mt7601u_rx_process_seg(dev, data, seg_len, new_p ? e->p : NULL);
 150
 151                 data_len -= seg_len;
 152                 data += seg_len;
 153                 cnt++;
 154         }
 155
 156         if (cnt > 1)
 157                 trace_mt_rx_dma_aggr(dev, cnt, !!new_p);
 158
 159         if (new_p) {
 160                 /* we have one extra ref from the allocator */
 161                 __free_pages(e->p, MT_RX_ORDER);
 162
 163                 e->p = new_p;
 164         }
 165 }
 166
 167 static struct mt7601u_dma_buf_rx *
 168 mt7601u_rx_get_pending_entry(struct mt7601u_dev *dev)
 169 {
 170         struct mt7601u_rx_queue *q = &dev->rx_q;
 171         struct mt7601u_dma_buf_rx *buf = NULL;
 172         unsigned long flags;
 173
 174         spin_lock_irqsave(&dev->rx_lock, flags);
 175
 176         if (!q->pending)
 177                 goto out;
 178
 179         buf = &q->e[q->start];
 180         q->pending--;
 181         q->start = (q->start + 1) % q->entries;
 182 out:
 183         spin_unlock_irqrestore(&dev->rx_lock, flags);
 184
 185         return buf;
 186 }
 187
 188 static void mt7601u_complete_rx(struct urb *urb)
 189 {
 190         struct mt7601u_dev *dev = urb->context;
 191         struct mt7601u_rx_queue *q = &dev->rx_q;
 192         unsigned long flags;
 193
 194         spin_lock_irqsave(&dev->rx_lock, flags);
 195
 196         if (mt7601u_urb_has_error(urb))
 197                 dev_err(dev->dev, "Error: RX urb failed:%d\n", urb->status);
 198         if (WARN_ONCE(q->e[q->end].urb != urb, "RX urb mismatch"))
 199                 goto out;
 200
 201         q->end = (q->end + 1) % q->entries;
 202         q->pending++;
 203         tasklet_schedule(&dev->rx_tasklet);
 204 out:
 205         spin_unlock_irqrestore(&dev->rx_lock, flags);
 206 }
 207
 208 static void mt7601u_rx_tasklet(unsigned long data)
 209 {
 210         struct mt7601u_dev *dev = (struct mt7601u_dev *) data;
 211         struct mt7601u_dma_buf_rx *e;
 212
 213         while ((e = mt7601u_rx_get_pending_entry(dev))) {
 214                 if (e->urb->status)
 215                         continue;
 216
 217                 mt7601u_rx_process_entry(dev, e);
 218                 mt7601u_submit_rx_buf(dev, e, GFP_ATOMIC);
 219         }
 220 }
 221
 222 static void mt7601u_complete_tx(struct urb *urb)
 223 {
 224         struct mt7601u_tx_queue *q = urb->context;
 225         struct mt7601u_dev *dev = q->dev;
 226         struct sk_buff *skb;
 227         unsigned long flags;
 228
 229         spin_lock_irqsave(&dev->tx_lock, flags);
 230
 231         if (mt7601u_urb_has_error(urb))
 232                 dev_err(dev->dev, "Error: TX urb failed:%d\n", urb->status);
 233         if (WARN_ONCE(q->e[q->start].urb != urb, "TX urb mismatch"))
 234                 goto out;
 235
 236         skb = q->e[q->start].skb;
 237         trace_mt_tx_dma_done(dev, skb);
 238
 239         mt7601u_tx_status(dev, skb);
 240
 241         if (q->used == q->entries - q->entries / 8)
 242                 ieee80211_wake_queue(dev->hw, skb_get_queue_mapping(skb));
 243
 244         q->start = (q->start + 1) % q->entries;
 245         q->used--;
 246
 247         if (urb->status)
 248                 goto out;
 249
 250         set_bit(MT7601U_STATE_MORE_STATS, &dev->state);
 251         if (!test_and_set_bit(MT7601U_STATE_READING_STATS, &dev->state))
 252                 queue_delayed_work(dev->stat_wq, &dev->stat_work,
 253                                    msecs_to_jiffies(10));
 254 out:
 255         spin_unlock_irqrestore(&dev->tx_lock, flags);
 256 }
 257
 258 static int mt7601u_dma_submit_tx(struct mt7601u_dev *dev,
 259                                  struct sk_buff *skb, u8 ep)
 260 {
 261         struct usb_device *usb_dev = mt7601u_to_usb_dev(dev);
 262         unsigned snd_pipe = usb_sndbulkpipe(usb_dev, dev->out_eps[ep]);
 263         struct mt7601u_dma_buf_tx *e;
 264         struct mt7601u_tx_queue *q = &dev->tx_q[ep];
 265         unsigned long flags;
 266         int ret;
 267
 268         spin_lock_irqsave(&dev->tx_lock, flags);
 269
 270         if (WARN_ON(q->entries <= q->used)) {
 271                 ret = -ENOSPC;
 272                 goto out;
 273         }
 274
 275         e = &q->e[q->end];
 276         e->skb = skb;
 277         usb_fill_bulk_urb(e->urb, usb_dev, snd_pipe, skb->data, skb->len,
 278                           mt7601u_complete_tx, q);
 279         ret = usb_submit_urb(e->urb, GFP_ATOMIC);
 280         if (ret) {
 281                 /* Special-handle ENODEV from TX urb submission because it will
 282                  * often be the first ENODEV we see after device is removed.
 283                  */
 284                 if (ret == -ENODEV)
 285                         set_bit(MT7601U_STATE_REMOVED, &dev->state);
 286                 else
 287                         dev_err(dev->dev, "Error: TX urb submit failed:%d\n",
 288                                 ret);
 289                 goto out;
 290         }
 291
 292         q->end = (q->end + 1) % q->entries;
 293         q->used++;
 294
 295         if (q->used >= q->entries)
 296                 ieee80211_stop_queue(dev->hw, skb_get_queue_mapping(skb));
 297 out:
 298         spin_unlock_irqrestore(&dev->tx_lock, flags);
 299
 300         return ret;
 301 }
 302
 303 /* Map hardware Q to USB endpoint number */
 304 static u8 q2ep(u8 qid)
 305 {
 306         /* TODO: take management packets to queue 5 */
 307         return qid + 1;
 308 }
 309
 310 /* Map USB endpoint number to Q id in the DMA engine */
 311 static enum mt76_qsel ep2dmaq(u8 ep)
 312 {
 313         if (ep == 5)
 314                 return MT_QSEL_MGMT;
 315         return MT_QSEL_EDCA;
 316 }
 317
 318 int mt7601u_dma_enqueue_tx(struct mt7601u_dev *dev, struct sk_buff *skb,
 319                            struct mt76_wcid *wcid, int hw_q)
 320 {
 321         u8 ep = q2ep(hw_q);
 322         u32 dma_flags;
 323         int ret;
 324
 325         dma_flags = MT_TXD_PKT_INFO_80211;
 326         if (wcid->hw_key_idx == 0xff)
 327                 dma_flags |= MT_TXD_PKT_INFO_WIV;
 328
 329         ret = mt7601u_dma_skb_wrap_pkt(skb, ep2dmaq(ep), dma_flags);
 330         if (ret)
 331                 return ret;
 332
 333         ret = mt7601u_dma_submit_tx(dev, skb, ep);
 334         if (ret) {
 335                 ieee80211_free_txskb(dev->hw, skb);
 336                 return ret;
 337         }
 338
 339         return 0;
 340 }
 341
 342 static void mt7601u_kill_rx(struct mt7601u_dev *dev)
 343 {
 344         int i;
 345         unsigned long flags;
 346
 347         spin_lock_irqsave(&dev->rx_lock, flags);
 348
 349         for (i = 0; i < dev->rx_q.entries; i++) {
 350                 int next = dev->rx_q.end;
 351
 352                 spin_unlock_irqrestore(&dev->rx_lock, flags);
 353                 usb_poison_urb(dev->rx_q.e[next].urb);
 354                 spin_lock_irqsave(&dev->rx_lock, flags);
 355         }
 356
 357         spin_unlock_irqrestore(&dev->rx_lock, flags);
 358 }
 359
 360 static int mt7601u_submit_rx_buf(struct mt7601u_dev *dev,
 361                                  struct mt7601u_dma_buf_rx *e, gfp_t gfp)
 362 {
 363         struct usb_device *usb_dev = mt7601u_to_usb_dev(dev);
 364         u8 *buf = page_address(e->p);
 365         unsigned pipe;
 366         int ret;
 367
 368         pipe = usb_rcvbulkpipe(usb_dev, dev->in_eps[MT_EP_IN_PKT_RX]);
 369
 370         usb_fill_bulk_urb(e->urb, usb_dev, pipe, buf, MT_RX_URB_SIZE,
 371                           mt7601u_complete_rx, dev);
 372
 373         trace_mt_submit_urb(dev, e->urb);
 374         ret = usb_submit_urb(e->urb, gfp);
 375         if (ret)
 376                 dev_err(dev->dev, "Error: submit RX URB failed:%d\n", ret);
 377
 378         return ret;
 379 }
 380
 381 static int mt7601u_submit_rx(struct mt7601u_dev *dev)
 382 {
 383         int i, ret;
 384
 385         for (i = 0; i < dev->rx_q.entries; i++) {
 386                 ret = mt7601u_submit_rx_buf(dev, &dev->rx_q.e[i], GFP_KERNEL);
 387                 if (ret)
 388                         return ret;
 389         }
 390
 391         return 0;
 392 }
 393
 394 static void mt7601u_free_rx(struct mt7601u_dev *dev)
 395 {
 396         int i;
 397
 398         for (i = 0; i < dev->rx_q.entries; i++) {
 399                 __free_pages(dev->rx_q.e[i].p, MT_RX_ORDER);
 400                 usb_free_urb(dev->rx_q.e[i].urb);
 401         }
 402 }
 403
 404 static int mt7601u_alloc_rx(struct mt7601u_dev *dev)
 405 {
 406         int i;
 407
 408         memset(&dev->rx_q, 0, sizeof(dev->rx_q));
 409         dev->rx_q.dev = dev;
 410         dev->rx_q.entries = N_RX_ENTRIES;
 411
 412         for (i = 0; i < N_RX_ENTRIES; i++) {
 413                 dev->rx_q.e[i].urb = usb_alloc_urb(0, GFP_KERNEL);
 414                 dev->rx_q.e[i].p = dev_alloc_pages(MT_RX_ORDER);
 415
 416                 if (!dev->rx_q.e[i].urb || !dev->rx_q.e[i].p)
 417                         return -ENOMEM;
 418         }
 419
 420         return 0;
 421 }
 422
 423 static void mt7601u_free_tx_queue(struct mt7601u_tx_queue *q)
 424 {
 425         int i;
 426
 427         WARN_ON(q->used);
 428
 429         for (i = 0; i < q->entries; i++)  {
 430                 usb_poison_urb(q->e[i].urb);
 431                 usb_free_urb(q->e[i].urb);
 432         }
 433 }
 434
 435 static void mt7601u_free_tx(struct mt7601u_dev *dev)
 436 {
 437         int i;
 438
 439         for (i = 0; i < __MT_EP_OUT_MAX; i++)
 440                 mt7601u_free_tx_queue(&dev->tx_q[i]);
 441 }
 442
 443 static int mt7601u_alloc_tx_queue(struct mt7601u_dev *dev,
 444                                   struct mt7601u_tx_queue *q)
 445 {
 446         int i;
 447
 448         q->dev = dev;
 449         q->entries = N_TX_ENTRIES;
 450
 451         for (i = 0; i < N_TX_ENTRIES; i++) {
 452                 q->e[i].urb = usb_alloc_urb(0, GFP_KERNEL);
 453                 if (!q->e[i].urb)
 454                         return -ENOMEM;
 455         }
 456
 457         return 0;
 458 }
 459
 460 static int mt7601u_alloc_tx(struct mt7601u_dev *dev)
 461 {
 462         int i;
 463
 464         dev->tx_q = devm_kcalloc(dev->dev, __MT_EP_OUT_MAX,
 465                                  sizeof(*dev->tx_q), GFP_KERNEL);
 466
 467         for (i = 0; i < __MT_EP_OUT_MAX; i++)
 468                 if (mt7601u_alloc_tx_queue(dev, &dev->tx_q[i]))
 469                         return -ENOMEM;
 470
 471         return 0;
 472 }
 473
 474 int mt7601u_dma_init(struct mt7601u_dev *dev)
 475 {
 476         int ret = -ENOMEM;
 477
 478         tasklet_init(&dev->rx_tasklet, mt7601u_rx_tasklet, (unsigned long) dev);
 479
 480         ret = mt7601u_alloc_tx(dev);
 481         if (ret)
 482                 goto err;
 483         ret = mt7601u_alloc_rx(dev);
 484         if (ret)
 485                 goto err;
 486
 487         ret = mt7601u_submit_rx(dev);
 488         if (ret)
 489                 goto err;
 490
 491         return 0;
 492 err:
 493         mt7601u_dma_cleanup(dev);
 494         return ret;
 495 }
 496
 497 void mt7601u_dma_cleanup(struct mt7601u_dev *dev)
 498 {
 499         mt7601u_kill_rx(dev);
 500
 501         tasklet_kill(&dev->rx_tasklet);
 502
 503         mt7601u_free_rx(dev);
 504         mt7601u_free_tx(dev);
 505 }