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 } 506