1 /* 2 * Copyright (C) 2018 Lorenzo Bianconi <lorenzo.bianconi83@gmail.com> 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 <linux/module.h> 18 #include "mt76.h" 19 #include "usb_trace.h" 20 #include "dma.h" 21 22 #define MT_VEND_REQ_MAX_RETRY 10 23 #define MT_VEND_REQ_TOUT_MS 300 24 25 static bool disable_usb_sg; 26 module_param_named(disable_usb_sg, disable_usb_sg, bool, 0644); 27 MODULE_PARM_DESC(disable_usb_sg, "Disable usb scatter-gather support"); 28 29 /* should be called with usb_ctrl_mtx locked */ 30 static int __mt76u_vendor_request(struct mt76_dev *dev, u8 req, 31 u8 req_type, u16 val, u16 offset, 32 void *buf, size_t len) 33 { 34 struct usb_device *udev = to_usb_device(dev->dev); 35 unsigned int pipe; 36 int i, ret; 37 38 pipe = (req_type & USB_DIR_IN) ? usb_rcvctrlpipe(udev, 0) 39 : usb_sndctrlpipe(udev, 0); 40 for (i = 0; i < MT_VEND_REQ_MAX_RETRY; i++) { 41 if (test_bit(MT76_REMOVED, &dev->state)) 42 return -EIO; 43 44 ret = usb_control_msg(udev, pipe, req, req_type, val, 45 offset, buf, len, MT_VEND_REQ_TOUT_MS); 46 if (ret == -ENODEV) 47 set_bit(MT76_REMOVED, &dev->state); 48 if (ret >= 0 || ret == -ENODEV) 49 return ret; 50 usleep_range(5000, 10000); 51 } 52 53 dev_err(dev->dev, "vendor request req:%02x off:%04x failed:%d\n", 54 req, offset, ret); 55 return ret; 56 } 57 58 int mt76u_vendor_request(struct mt76_dev *dev, u8 req, 59 u8 req_type, u16 val, u16 offset, 60 void *buf, size_t len) 61 { 62 int ret; 63 64 mutex_lock(&dev->usb.usb_ctrl_mtx); 65 ret = __mt76u_vendor_request(dev, req, req_type, 66 val, offset, buf, len); 67 trace_usb_reg_wr(dev, offset, val); 68 mutex_unlock(&dev->usb.usb_ctrl_mtx); 69 70 return ret; 71 } 72 EXPORT_SYMBOL_GPL(mt76u_vendor_request); 73 74 /* should be called with usb_ctrl_mtx locked */ 75 static u32 __mt76u_rr(struct mt76_dev *dev, u32 addr) 76 { 77 struct mt76_usb *usb = &dev->usb; 78 u32 data = ~0; 79 u16 offset; 80 int ret; 81 u8 req; 82 83 switch (addr & MT_VEND_TYPE_MASK) { 84 case MT_VEND_TYPE_EEPROM: 85 req = MT_VEND_READ_EEPROM; 86 break; 87 case MT_VEND_TYPE_CFG: 88 req = MT_VEND_READ_CFG; 89 break; 90 default: 91 req = MT_VEND_MULTI_READ; 92 break; 93 } 94 offset = addr & ~MT_VEND_TYPE_MASK; 95 96 ret = __mt76u_vendor_request(dev, req, 97 USB_DIR_IN | USB_TYPE_VENDOR, 98 0, offset, usb->data, sizeof(__le32)); 99 if (ret == sizeof(__le32)) 100 data = get_unaligned_le32(usb->data); 101 trace_usb_reg_rr(dev, addr, data); 102 103 return data; 104 } 105 106 static u32 mt76u_rr(struct mt76_dev *dev, u32 addr) 107 { 108 u32 ret; 109 110 mutex_lock(&dev->usb.usb_ctrl_mtx); 111 ret = __mt76u_rr(dev, addr); 112 mutex_unlock(&dev->usb.usb_ctrl_mtx); 113 114 return ret; 115 } 116 117 /* should be called with usb_ctrl_mtx locked */ 118 static void __mt76u_wr(struct mt76_dev *dev, u32 addr, u32 val) 119 { 120 struct mt76_usb *usb = &dev->usb; 121 u16 offset; 122 u8 req; 123 124 switch (addr & MT_VEND_TYPE_MASK) { 125 case MT_VEND_TYPE_CFG: 126 req = MT_VEND_WRITE_CFG; 127 break; 128 default: 129 req = MT_VEND_MULTI_WRITE; 130 break; 131 } 132 offset = addr & ~MT_VEND_TYPE_MASK; 133 134 put_unaligned_le32(val, usb->data); 135 __mt76u_vendor_request(dev, req, 136 USB_DIR_OUT | USB_TYPE_VENDOR, 0, 137 offset, usb->data, sizeof(__le32)); 138 trace_usb_reg_wr(dev, addr, val); 139 } 140 141 static void mt76u_wr(struct mt76_dev *dev, u32 addr, u32 val) 142 { 143 mutex_lock(&dev->usb.usb_ctrl_mtx); 144 __mt76u_wr(dev, addr, val); 145 mutex_unlock(&dev->usb.usb_ctrl_mtx); 146 } 147 148 static u32 mt76u_rmw(struct mt76_dev *dev, u32 addr, 149 u32 mask, u32 val) 150 { 151 mutex_lock(&dev->usb.usb_ctrl_mtx); 152 val |= __mt76u_rr(dev, addr) & ~mask; 153 __mt76u_wr(dev, addr, val); 154 mutex_unlock(&dev->usb.usb_ctrl_mtx); 155 156 return val; 157 } 158 159 static void mt76u_copy(struct mt76_dev *dev, u32 offset, 160 const void *data, int len) 161 { 162 struct mt76_usb *usb = &dev->usb; 163 const u32 *val = data; 164 int i, ret; 165 166 mutex_lock(&usb->usb_ctrl_mtx); 167 for (i = 0; i < (len / 4); i++) { 168 put_unaligned_le32(val[i], usb->data); 169 ret = __mt76u_vendor_request(dev, MT_VEND_MULTI_WRITE, 170 USB_DIR_OUT | USB_TYPE_VENDOR, 171 0, offset + i * 4, usb->data, 172 sizeof(__le32)); 173 if (ret < 0) 174 break; 175 } 176 mutex_unlock(&usb->usb_ctrl_mtx); 177 } 178 179 void mt76u_single_wr(struct mt76_dev *dev, const u8 req, 180 const u16 offset, const u32 val) 181 { 182 mutex_lock(&dev->usb.usb_ctrl_mtx); 183 __mt76u_vendor_request(dev, req, 184 USB_DIR_OUT | USB_TYPE_VENDOR, 185 val & 0xffff, offset, NULL, 0); 186 __mt76u_vendor_request(dev, req, 187 USB_DIR_OUT | USB_TYPE_VENDOR, 188 val >> 16, offset + 2, NULL, 0); 189 mutex_unlock(&dev->usb.usb_ctrl_mtx); 190 } 191 EXPORT_SYMBOL_GPL(mt76u_single_wr); 192 193 static int 194 mt76u_req_wr_rp(struct mt76_dev *dev, u32 base, 195 const struct mt76_reg_pair *data, int len) 196 { 197 struct mt76_usb *usb = &dev->usb; 198 199 mutex_lock(&usb->usb_ctrl_mtx); 200 while (len > 0) { 201 __mt76u_wr(dev, base + data->reg, data->value); 202 len--; 203 data++; 204 } 205 mutex_unlock(&usb->usb_ctrl_mtx); 206 207 return 0; 208 } 209 210 static int 211 mt76u_wr_rp(struct mt76_dev *dev, u32 base, 212 const struct mt76_reg_pair *data, int n) 213 { 214 if (test_bit(MT76_STATE_MCU_RUNNING, &dev->state)) 215 return dev->mcu_ops->mcu_wr_rp(dev, base, data, n); 216 else 217 return mt76u_req_wr_rp(dev, base, data, n); 218 } 219 220 static int 221 mt76u_req_rd_rp(struct mt76_dev *dev, u32 base, struct mt76_reg_pair *data, 222 int len) 223 { 224 struct mt76_usb *usb = &dev->usb; 225 226 mutex_lock(&usb->usb_ctrl_mtx); 227 while (len > 0) { 228 data->value = __mt76u_rr(dev, base + data->reg); 229 len--; 230 data++; 231 } 232 mutex_unlock(&usb->usb_ctrl_mtx); 233 234 return 0; 235 } 236 237 static int 238 mt76u_rd_rp(struct mt76_dev *dev, u32 base, 239 struct mt76_reg_pair *data, int n) 240 { 241 if (test_bit(MT76_STATE_MCU_RUNNING, &dev->state)) 242 return dev->mcu_ops->mcu_rd_rp(dev, base, data, n); 243 else 244 return mt76u_req_rd_rp(dev, base, data, n); 245 } 246 247 static bool mt76u_check_sg(struct mt76_dev *dev) 248 { 249 struct usb_device *udev = to_usb_device(dev->dev); 250 251 return (!disable_usb_sg && udev->bus->sg_tablesize > 0 && 252 (udev->bus->no_sg_constraint || 253 udev->speed == USB_SPEED_WIRELESS)); 254 } 255 256 static int 257 mt76u_set_endpoints(struct usb_interface *intf, 258 struct mt76_usb *usb) 259 { 260 struct usb_host_interface *intf_desc = intf->cur_altsetting; 261 struct usb_endpoint_descriptor *ep_desc; 262 int i, in_ep = 0, out_ep = 0; 263 264 for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) { 265 ep_desc = &intf_desc->endpoint[i].desc; 266 267 if (usb_endpoint_is_bulk_in(ep_desc) && 268 in_ep < __MT_EP_IN_MAX) { 269 usb->in_ep[in_ep] = usb_endpoint_num(ep_desc); 270 usb->in_max_packet = usb_endpoint_maxp(ep_desc); 271 in_ep++; 272 } else if (usb_endpoint_is_bulk_out(ep_desc) && 273 out_ep < __MT_EP_OUT_MAX) { 274 usb->out_ep[out_ep] = usb_endpoint_num(ep_desc); 275 usb->out_max_packet = usb_endpoint_maxp(ep_desc); 276 out_ep++; 277 } 278 } 279 280 if (in_ep != __MT_EP_IN_MAX || out_ep != __MT_EP_OUT_MAX) 281 return -EINVAL; 282 return 0; 283 } 284 285 static int 286 mt76u_fill_rx_sg(struct mt76_dev *dev, struct mt76_queue *q, struct urb *urb, 287 int nsgs, gfp_t gfp) 288 { 289 int i; 290 291 for (i = 0; i < nsgs; i++) { 292 struct page *page; 293 void *data; 294 int offset; 295 296 data = page_frag_alloc(&q->rx_page, q->buf_size, gfp); 297 if (!data) 298 break; 299 300 page = virt_to_head_page(data); 301 offset = data - page_address(page); 302 sg_set_page(&urb->sg[i], page, q->buf_size, offset); 303 } 304 305 if (i < nsgs) { 306 int j; 307 308 for (j = nsgs; j < urb->num_sgs; j++) 309 skb_free_frag(sg_virt(&urb->sg[j])); 310 urb->num_sgs = i; 311 } 312 313 urb->num_sgs = max_t(int, i, urb->num_sgs); 314 urb->transfer_buffer_length = urb->num_sgs * q->buf_size, 315 sg_init_marker(urb->sg, urb->num_sgs); 316 317 return i ? : -ENOMEM; 318 } 319 320 static int 321 mt76u_refill_rx(struct mt76_dev *dev, struct urb *urb, int nsgs, gfp_t gfp) 322 { 323 struct mt76_queue *q = &dev->q_rx[MT_RXQ_MAIN]; 324 325 if (dev->usb.sg_en) { 326 return mt76u_fill_rx_sg(dev, q, urb, nsgs, gfp); 327 } else { 328 urb->transfer_buffer_length = q->buf_size; 329 urb->transfer_buffer = page_frag_alloc(&q->rx_page, 330 q->buf_size, gfp); 331 return urb->transfer_buffer ? 0 : -ENOMEM; 332 } 333 } 334 335 static int 336 mt76u_urb_alloc(struct mt76_dev *dev, struct mt76_queue_entry *e) 337 { 338 unsigned int size = sizeof(struct urb); 339 340 if (dev->usb.sg_en) 341 size += MT_SG_MAX_SIZE * sizeof(struct scatterlist); 342 343 e->urb = kzalloc(size, GFP_KERNEL); 344 if (!e->urb) 345 return -ENOMEM; 346 347 usb_init_urb(e->urb); 348 349 if (dev->usb.sg_en) 350 e->urb->sg = (struct scatterlist *)(e->urb + 1); 351 352 return 0; 353 } 354 355 static int 356 mt76u_rx_urb_alloc(struct mt76_dev *dev, struct mt76_queue_entry *e) 357 { 358 int err; 359 360 err = mt76u_urb_alloc(dev, e); 361 if (err) 362 return err; 363 364 return mt76u_refill_rx(dev, e->urb, MT_SG_MAX_SIZE, GFP_KERNEL); 365 } 366 367 static void mt76u_urb_free(struct urb *urb) 368 { 369 int i; 370 371 for (i = 0; i < urb->num_sgs; i++) 372 skb_free_frag(sg_virt(&urb->sg[i])); 373 374 if (urb->transfer_buffer) 375 skb_free_frag(urb->transfer_buffer); 376 377 usb_free_urb(urb); 378 } 379 380 static void 381 mt76u_fill_bulk_urb(struct mt76_dev *dev, int dir, int index, 382 struct urb *urb, usb_complete_t complete_fn, 383 void *context) 384 { 385 struct usb_device *udev = to_usb_device(dev->dev); 386 unsigned int pipe; 387 388 if (dir == USB_DIR_IN) 389 pipe = usb_rcvbulkpipe(udev, dev->usb.in_ep[index]); 390 else 391 pipe = usb_sndbulkpipe(udev, dev->usb.out_ep[index]); 392 393 urb->dev = udev; 394 urb->pipe = pipe; 395 urb->complete = complete_fn; 396 urb->context = context; 397 } 398 399 static inline struct urb * 400 mt76u_get_next_rx_entry(struct mt76_dev *dev) 401 { 402 struct mt76_queue *q = &dev->q_rx[MT_RXQ_MAIN]; 403 struct urb *urb = NULL; 404 unsigned long flags; 405 406 spin_lock_irqsave(&q->lock, flags); 407 if (q->queued > 0) { 408 urb = q->entry[q->head].urb; 409 q->head = (q->head + 1) % q->ndesc; 410 q->queued--; 411 } 412 spin_unlock_irqrestore(&q->lock, flags); 413 414 return urb; 415 } 416 417 static int mt76u_get_rx_entry_len(u8 *data, u32 data_len) 418 { 419 u16 dma_len, min_len; 420 421 dma_len = get_unaligned_le16(data); 422 min_len = MT_DMA_HDR_LEN + MT_RX_RXWI_LEN + 423 MT_FCE_INFO_LEN; 424 425 if (data_len < min_len || !dma_len || 426 dma_len + MT_DMA_HDR_LEN > data_len || 427 (dma_len & 0x3)) 428 return -EINVAL; 429 return dma_len; 430 } 431 432 static int 433 mt76u_process_rx_entry(struct mt76_dev *dev, struct urb *urb) 434 { 435 struct mt76_queue *q = &dev->q_rx[MT_RXQ_MAIN]; 436 u8 *data = urb->num_sgs ? sg_virt(&urb->sg[0]) : urb->transfer_buffer; 437 int data_len = urb->num_sgs ? urb->sg[0].length : urb->actual_length; 438 int len, nsgs = 1; 439 struct sk_buff *skb; 440 441 if (!test_bit(MT76_STATE_INITIALIZED, &dev->state)) 442 return 0; 443 444 len = mt76u_get_rx_entry_len(data, urb->actual_length); 445 if (len < 0) 446 return 0; 447 448 data_len = min_t(int, len, data_len - MT_DMA_HDR_LEN); 449 if (MT_DMA_HDR_LEN + data_len > SKB_WITH_OVERHEAD(q->buf_size)) { 450 dev_err_ratelimited(dev->dev, "rx data too big %d\n", data_len); 451 return 0; 452 } 453 454 skb = build_skb(data, q->buf_size); 455 if (!skb) 456 return 0; 457 458 skb_reserve(skb, MT_DMA_HDR_LEN); 459 __skb_put(skb, data_len); 460 len -= data_len; 461 462 while (len > 0 && nsgs < urb->num_sgs) { 463 data_len = min_t(int, len, urb->sg[nsgs].length); 464 skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, 465 sg_page(&urb->sg[nsgs]), 466 urb->sg[nsgs].offset, 467 data_len, q->buf_size); 468 len -= data_len; 469 nsgs++; 470 } 471 dev->drv->rx_skb(dev, MT_RXQ_MAIN, skb); 472 473 return nsgs; 474 } 475 476 static void mt76u_complete_rx(struct urb *urb) 477 { 478 struct mt76_dev *dev = urb->context; 479 struct mt76_queue *q = &dev->q_rx[MT_RXQ_MAIN]; 480 unsigned long flags; 481 482 trace_rx_urb(dev, urb); 483 484 switch (urb->status) { 485 case -ECONNRESET: 486 case -ESHUTDOWN: 487 case -ENOENT: 488 return; 489 default: 490 dev_err_ratelimited(dev->dev, "rx urb failed: %d\n", 491 urb->status); 492 /* fall through */ 493 case 0: 494 break; 495 } 496 497 spin_lock_irqsave(&q->lock, flags); 498 if (WARN_ONCE(q->entry[q->tail].urb != urb, "rx urb mismatch")) 499 goto out; 500 501 q->tail = (q->tail + 1) % q->ndesc; 502 q->queued++; 503 tasklet_schedule(&dev->usb.rx_tasklet); 504 out: 505 spin_unlock_irqrestore(&q->lock, flags); 506 } 507 508 static int 509 mt76u_submit_rx_buf(struct mt76_dev *dev, struct urb *urb) 510 { 511 mt76u_fill_bulk_urb(dev, USB_DIR_IN, MT_EP_IN_PKT_RX, urb, 512 mt76u_complete_rx, dev); 513 trace_submit_urb(dev, urb); 514 515 return usb_submit_urb(urb, GFP_ATOMIC); 516 } 517 518 static void mt76u_rx_tasklet(unsigned long data) 519 { 520 struct mt76_dev *dev = (struct mt76_dev *)data; 521 struct urb *urb; 522 int err, count; 523 524 rcu_read_lock(); 525 526 while (true) { 527 urb = mt76u_get_next_rx_entry(dev); 528 if (!urb) 529 break; 530 531 count = mt76u_process_rx_entry(dev, urb); 532 if (count > 0) { 533 err = mt76u_refill_rx(dev, urb, count, GFP_ATOMIC); 534 if (err < 0) 535 break; 536 } 537 mt76u_submit_rx_buf(dev, urb); 538 } 539 mt76_rx_poll_complete(dev, MT_RXQ_MAIN, NULL); 540 541 rcu_read_unlock(); 542 } 543 544 static int mt76u_submit_rx_buffers(struct mt76_dev *dev) 545 { 546 struct mt76_queue *q = &dev->q_rx[MT_RXQ_MAIN]; 547 unsigned long flags; 548 int i, err = 0; 549 550 spin_lock_irqsave(&q->lock, flags); 551 for (i = 0; i < q->ndesc; i++) { 552 err = mt76u_submit_rx_buf(dev, q->entry[i].urb); 553 if (err < 0) 554 break; 555 } 556 q->head = q->tail = 0; 557 q->queued = 0; 558 spin_unlock_irqrestore(&q->lock, flags); 559 560 return err; 561 } 562 563 static int mt76u_alloc_rx(struct mt76_dev *dev) 564 { 565 struct mt76_usb *usb = &dev->usb; 566 struct mt76_queue *q = &dev->q_rx[MT_RXQ_MAIN]; 567 int i, err; 568 569 usb->mcu.data = devm_kmalloc(dev->dev, MCU_RESP_URB_SIZE, GFP_KERNEL); 570 if (!usb->mcu.data) 571 return -ENOMEM; 572 573 spin_lock_init(&q->lock); 574 q->entry = devm_kcalloc(dev->dev, 575 MT_NUM_RX_ENTRIES, sizeof(*q->entry), 576 GFP_KERNEL); 577 if (!q->entry) 578 return -ENOMEM; 579 580 q->buf_size = dev->usb.sg_en ? MT_RX_BUF_SIZE : PAGE_SIZE; 581 q->ndesc = MT_NUM_RX_ENTRIES; 582 for (i = 0; i < q->ndesc; i++) { 583 err = mt76u_rx_urb_alloc(dev, &q->entry[i]); 584 if (err < 0) 585 return err; 586 } 587 588 return mt76u_submit_rx_buffers(dev); 589 } 590 591 static void mt76u_free_rx(struct mt76_dev *dev) 592 { 593 struct mt76_queue *q = &dev->q_rx[MT_RXQ_MAIN]; 594 struct page *page; 595 int i; 596 597 for (i = 0; i < q->ndesc; i++) 598 mt76u_urb_free(q->entry[i].urb); 599 600 if (!q->rx_page.va) 601 return; 602 603 page = virt_to_page(q->rx_page.va); 604 __page_frag_cache_drain(page, q->rx_page.pagecnt_bias); 605 memset(&q->rx_page, 0, sizeof(q->rx_page)); 606 } 607 608 void mt76u_stop_rx(struct mt76_dev *dev) 609 { 610 struct mt76_queue *q = &dev->q_rx[MT_RXQ_MAIN]; 611 int i; 612 613 for (i = 0; i < q->ndesc; i++) 614 usb_poison_urb(q->entry[i].urb); 615 616 tasklet_kill(&dev->usb.rx_tasklet); 617 } 618 EXPORT_SYMBOL_GPL(mt76u_stop_rx); 619 620 int mt76u_resume_rx(struct mt76_dev *dev) 621 { 622 struct mt76_queue *q = &dev->q_rx[MT_RXQ_MAIN]; 623 int i; 624 625 for (i = 0; i < q->ndesc; i++) 626 usb_unpoison_urb(q->entry[i].urb); 627 628 return mt76u_submit_rx_buffers(dev); 629 } 630 EXPORT_SYMBOL_GPL(mt76u_resume_rx); 631 632 static void mt76u_tx_tasklet(unsigned long data) 633 { 634 struct mt76_dev *dev = (struct mt76_dev *)data; 635 struct mt76_queue_entry entry; 636 struct mt76_sw_queue *sq; 637 struct mt76_queue *q; 638 bool wake; 639 int i; 640 641 for (i = 0; i < IEEE80211_NUM_ACS; i++) { 642 u32 n_dequeued = 0, n_sw_dequeued = 0; 643 644 sq = &dev->q_tx[i]; 645 q = sq->q; 646 647 while (q->queued > n_dequeued) { 648 if (!q->entry[q->head].done) 649 break; 650 651 if (q->entry[q->head].schedule) { 652 q->entry[q->head].schedule = false; 653 n_sw_dequeued++; 654 } 655 656 entry = q->entry[q->head]; 657 q->entry[q->head].done = false; 658 q->head = (q->head + 1) % q->ndesc; 659 n_dequeued++; 660 661 dev->drv->tx_complete_skb(dev, i, &entry); 662 } 663 664 spin_lock_bh(&q->lock); 665 666 sq->swq_queued -= n_sw_dequeued; 667 q->queued -= n_dequeued; 668 669 wake = q->stopped && q->queued < q->ndesc - 8; 670 if (wake) 671 q->stopped = false; 672 673 if (!q->queued) 674 wake_up(&dev->tx_wait); 675 676 spin_unlock_bh(&q->lock); 677 678 mt76_txq_schedule(dev, i); 679 680 if (!test_and_set_bit(MT76_READING_STATS, &dev->state)) 681 ieee80211_queue_delayed_work(dev->hw, 682 &dev->usb.stat_work, 683 msecs_to_jiffies(10)); 684 685 if (wake) 686 ieee80211_wake_queue(dev->hw, i); 687 } 688 } 689 690 static void mt76u_tx_status_data(struct work_struct *work) 691 { 692 struct mt76_usb *usb; 693 struct mt76_dev *dev; 694 u8 update = 1; 695 u16 count = 0; 696 697 usb = container_of(work, struct mt76_usb, stat_work.work); 698 dev = container_of(usb, struct mt76_dev, usb); 699 700 while (true) { 701 if (test_bit(MT76_REMOVED, &dev->state)) 702 break; 703 704 if (!dev->drv->tx_status_data(dev, &update)) 705 break; 706 count++; 707 } 708 709 if (count && test_bit(MT76_STATE_RUNNING, &dev->state)) 710 ieee80211_queue_delayed_work(dev->hw, &usb->stat_work, 711 msecs_to_jiffies(10)); 712 else 713 clear_bit(MT76_READING_STATS, &dev->state); 714 } 715 716 static void mt76u_complete_tx(struct urb *urb) 717 { 718 struct mt76_dev *dev = dev_get_drvdata(&urb->dev->dev); 719 struct mt76_queue_entry *e = urb->context; 720 721 if (mt76u_urb_error(urb)) 722 dev_err(dev->dev, "tx urb failed: %d\n", urb->status); 723 e->done = true; 724 725 tasklet_schedule(&dev->tx_tasklet); 726 } 727 728 static int 729 mt76u_tx_setup_buffers(struct mt76_dev *dev, struct sk_buff *skb, 730 struct urb *urb) 731 { 732 urb->transfer_buffer_length = skb->len; 733 734 if (!dev->usb.sg_en) { 735 urb->transfer_buffer = skb->data; 736 return 0; 737 } else { 738 sg_init_table(urb->sg, MT_SG_MAX_SIZE); 739 urb->num_sgs = skb_to_sgvec(skb, urb->sg, 0, skb->len); 740 if (urb->num_sgs == 0) 741 return -ENOMEM; 742 return urb->num_sgs; 743 } 744 } 745 746 static int 747 mt76u_tx_queue_skb(struct mt76_dev *dev, enum mt76_txq_id qid, 748 struct sk_buff *skb, struct mt76_wcid *wcid, 749 struct ieee80211_sta *sta) 750 { 751 struct mt76_queue *q = dev->q_tx[qid].q; 752 struct mt76_tx_info tx_info = { 753 .skb = skb, 754 }; 755 u16 idx = q->tail; 756 int err; 757 758 if (q->queued == q->ndesc) 759 return -ENOSPC; 760 761 skb->prev = skb->next = NULL; 762 err = dev->drv->tx_prepare_skb(dev, NULL, qid, wcid, sta, &tx_info); 763 if (err < 0) 764 return err; 765 766 err = mt76u_tx_setup_buffers(dev, tx_info.skb, q->entry[idx].urb); 767 if (err < 0) 768 return err; 769 770 mt76u_fill_bulk_urb(dev, USB_DIR_OUT, q2ep(q->hw_idx), 771 q->entry[idx].urb, mt76u_complete_tx, 772 &q->entry[idx]); 773 774 q->tail = (q->tail + 1) % q->ndesc; 775 q->entry[idx].skb = tx_info.skb; 776 q->queued++; 777 778 return idx; 779 } 780 781 static void mt76u_tx_kick(struct mt76_dev *dev, struct mt76_queue *q) 782 { 783 struct urb *urb; 784 int err; 785 786 while (q->first != q->tail) { 787 urb = q->entry[q->first].urb; 788 789 trace_submit_urb(dev, urb); 790 err = usb_submit_urb(urb, GFP_ATOMIC); 791 if (err < 0) { 792 if (err == -ENODEV) 793 set_bit(MT76_REMOVED, &dev->state); 794 else 795 dev_err(dev->dev, "tx urb submit failed:%d\n", 796 err); 797 break; 798 } 799 q->first = (q->first + 1) % q->ndesc; 800 } 801 } 802 803 static int mt76u_alloc_tx(struct mt76_dev *dev) 804 { 805 struct mt76_queue *q; 806 int i, j, err; 807 808 for (i = 0; i <= MT_TXQ_PSD; i++) { 809 INIT_LIST_HEAD(&dev->q_tx[i].swq); 810 811 if (i >= IEEE80211_NUM_ACS) { 812 dev->q_tx[i].q = dev->q_tx[0].q; 813 continue; 814 } 815 816 q = devm_kzalloc(dev->dev, sizeof(*q), GFP_KERNEL); 817 if (!q) 818 return -ENOMEM; 819 820 spin_lock_init(&q->lock); 821 q->hw_idx = mt76_ac_to_hwq(i); 822 dev->q_tx[i].q = q; 823 824 q->entry = devm_kcalloc(dev->dev, 825 MT_NUM_TX_ENTRIES, sizeof(*q->entry), 826 GFP_KERNEL); 827 if (!q->entry) 828 return -ENOMEM; 829 830 q->ndesc = MT_NUM_TX_ENTRIES; 831 for (j = 0; j < q->ndesc; j++) { 832 err = mt76u_urb_alloc(dev, &q->entry[j]); 833 if (err < 0) 834 return err; 835 } 836 } 837 return 0; 838 } 839 840 static void mt76u_free_tx(struct mt76_dev *dev) 841 { 842 struct mt76_queue *q; 843 int i, j; 844 845 for (i = 0; i < IEEE80211_NUM_ACS; i++) { 846 q = dev->q_tx[i].q; 847 for (j = 0; j < q->ndesc; j++) 848 usb_free_urb(q->entry[j].urb); 849 } 850 } 851 852 void mt76u_stop_tx(struct mt76_dev *dev) 853 { 854 struct mt76_queue_entry entry; 855 struct mt76_queue *q; 856 int i, j, ret; 857 858 ret = wait_event_timeout(dev->tx_wait, !mt76_has_tx_pending(dev), HZ/5); 859 if (!ret) { 860 dev_err(dev->dev, "timed out waiting for pending tx\n"); 861 862 for (i = 0; i < IEEE80211_NUM_ACS; i++) { 863 q = dev->q_tx[i].q; 864 for (j = 0; j < q->ndesc; j++) 865 usb_kill_urb(q->entry[j].urb); 866 } 867 868 tasklet_kill(&dev->tx_tasklet); 869 870 /* On device removal we maight queue skb's, but mt76u_tx_kick() 871 * will fail to submit urb, cleanup those skb's manually. 872 */ 873 for (i = 0; i < IEEE80211_NUM_ACS; i++) { 874 q = dev->q_tx[i].q; 875 876 /* Assure we are in sync with killed tasklet. */ 877 spin_lock_bh(&q->lock); 878 while (q->queued) { 879 entry = q->entry[q->head]; 880 q->head = (q->head + 1) % q->ndesc; 881 q->queued--; 882 883 dev->drv->tx_complete_skb(dev, i, &entry); 884 } 885 spin_unlock_bh(&q->lock); 886 } 887 } 888 889 cancel_delayed_work_sync(&dev->usb.stat_work); 890 clear_bit(MT76_READING_STATS, &dev->state); 891 892 mt76_tx_status_check(dev, NULL, true); 893 } 894 EXPORT_SYMBOL_GPL(mt76u_stop_tx); 895 896 void mt76u_queues_deinit(struct mt76_dev *dev) 897 { 898 mt76u_stop_rx(dev); 899 mt76u_stop_tx(dev); 900 901 mt76u_free_rx(dev); 902 mt76u_free_tx(dev); 903 } 904 EXPORT_SYMBOL_GPL(mt76u_queues_deinit); 905 906 int mt76u_alloc_queues(struct mt76_dev *dev) 907 { 908 int err; 909 910 err = mt76u_alloc_rx(dev); 911 if (err < 0) 912 return err; 913 914 return mt76u_alloc_tx(dev); 915 } 916 EXPORT_SYMBOL_GPL(mt76u_alloc_queues); 917 918 static const struct mt76_queue_ops usb_queue_ops = { 919 .tx_queue_skb = mt76u_tx_queue_skb, 920 .kick = mt76u_tx_kick, 921 }; 922 923 int mt76u_init(struct mt76_dev *dev, 924 struct usb_interface *intf) 925 { 926 static const struct mt76_bus_ops mt76u_ops = { 927 .rr = mt76u_rr, 928 .wr = mt76u_wr, 929 .rmw = mt76u_rmw, 930 .copy = mt76u_copy, 931 .wr_rp = mt76u_wr_rp, 932 .rd_rp = mt76u_rd_rp, 933 .type = MT76_BUS_USB, 934 }; 935 struct mt76_usb *usb = &dev->usb; 936 937 tasklet_init(&usb->rx_tasklet, mt76u_rx_tasklet, (unsigned long)dev); 938 tasklet_init(&dev->tx_tasklet, mt76u_tx_tasklet, (unsigned long)dev); 939 INIT_DELAYED_WORK(&usb->stat_work, mt76u_tx_status_data); 940 skb_queue_head_init(&dev->rx_skb[MT_RXQ_MAIN]); 941 942 mutex_init(&usb->mcu.mutex); 943 944 mutex_init(&usb->usb_ctrl_mtx); 945 dev->bus = &mt76u_ops; 946 dev->queue_ops = &usb_queue_ops; 947 948 usb->sg_en = mt76u_check_sg(dev); 949 950 return mt76u_set_endpoints(intf, usb); 951 } 952 EXPORT_SYMBOL_GPL(mt76u_init); 953 954 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi83@gmail.com>"); 955 MODULE_LICENSE("Dual BSD/GPL"); 956