drivers/net/wireless/mediatek/mt76/usb.c

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