1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* Copyright(c) 2018-2019 Realtek Corporation 3 */ 4 5 #include <linux/module.h> 6 #include <linux/usb.h> 7 #include <linux/mutex.h> 8 #include "main.h" 9 #include "debug.h" 10 #include "reg.h" 11 #include "tx.h" 12 #include "rx.h" 13 #include "fw.h" 14 #include "ps.h" 15 #include "usb.h" 16 17 static bool rtw_switch_usb_mode = true; 18 module_param_named(switch_usb_mode, rtw_switch_usb_mode, bool, 0644); 19 MODULE_PARM_DESC(switch_usb_mode, 20 "Set to N to disable switching to USB 3 mode to avoid potential interference in the 2.4 GHz band (default: Y)"); 21 22 #define RTW_USB_MAX_RXQ_LEN 512 23 24 struct rtw_usb_txcb { 25 struct rtw_dev *rtwdev; 26 struct sk_buff_head tx_ack_queue; 27 }; 28 29 static void rtw_usb_fill_tx_checksum(struct rtw_usb *rtwusb, 30 struct sk_buff *skb, int agg_num) 31 { 32 struct rtw_tx_desc *tx_desc = (struct rtw_tx_desc *)skb->data; 33 struct rtw_dev *rtwdev = rtwusb->rtwdev; 34 struct rtw_tx_pkt_info pkt_info; 35 36 le32p_replace_bits(&tx_desc->w7, agg_num, RTW_TX_DESC_W7_DMA_TXAGG_NUM); 37 pkt_info.pkt_offset = le32_get_bits(tx_desc->w1, RTW_TX_DESC_W1_PKT_OFFSET); 38 rtw_tx_fill_txdesc_checksum(rtwdev, &pkt_info, skb->data); 39 } 40 41 static void rtw_usb_reg_sec(struct rtw_dev *rtwdev, u32 addr, __le32 *data) 42 { 43 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 44 struct usb_device *udev = rtwusb->udev; 45 bool reg_on_section = false; 46 u16 t_reg = 0x4e0; 47 u8 t_len = 1; 48 int status; 49 50 /* There are three sections: 51 * 1. on (0x00~0xFF; 0x1000~0x10FF): this section is always powered on 52 * 2. off (< 0xFE00, excluding "on" section): this section could be 53 * powered off 54 * 3. local (>= 0xFE00): usb specific registers section 55 */ 56 if (addr <= 0xff || (addr >= 0x1000 && addr <= 0x10ff)) 57 reg_on_section = true; 58 59 if (!reg_on_section) 60 return; 61 62 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 63 RTW_USB_CMD_REQ, RTW_USB_CMD_WRITE, 64 t_reg, 0, data, t_len, 500); 65 66 if (status != t_len && status != -ENODEV) 67 rtw_err(rtwdev, "%s: reg 0x%x, usb write %u fail, status: %d\n", 68 __func__, t_reg, t_len, status); 69 } 70 71 static u32 rtw_usb_read(struct rtw_dev *rtwdev, u32 addr, u16 len) 72 { 73 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 74 struct usb_device *udev = rtwusb->udev; 75 __le32 *data; 76 unsigned long flags; 77 int idx, ret; 78 static int count; 79 80 spin_lock_irqsave(&rtwusb->usb_lock, flags); 81 82 idx = rtwusb->usb_data_index; 83 rtwusb->usb_data_index = (idx + 1) & (RTW_USB_MAX_RXTX_COUNT - 1); 84 85 spin_unlock_irqrestore(&rtwusb->usb_lock, flags); 86 87 data = &rtwusb->usb_data[idx]; 88 89 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 90 RTW_USB_CMD_REQ, RTW_USB_CMD_READ, addr, 91 RTW_USB_VENQT_CMD_IDX, data, len, 1000); 92 if (ret < 0 && ret != -ENODEV && count++ < 4) 93 rtw_err(rtwdev, "read register 0x%x failed with %d\n", 94 addr, ret); 95 96 if (rtwdev->chip->id == RTW_CHIP_TYPE_8822C || 97 rtwdev->chip->id == RTW_CHIP_TYPE_8822B || 98 rtwdev->chip->id == RTW_CHIP_TYPE_8821C) 99 rtw_usb_reg_sec(rtwdev, addr, data); 100 101 return le32_to_cpu(*data); 102 } 103 104 static u8 rtw_usb_read8(struct rtw_dev *rtwdev, u32 addr) 105 { 106 return (u8)rtw_usb_read(rtwdev, addr, 1); 107 } 108 109 static u16 rtw_usb_read16(struct rtw_dev *rtwdev, u32 addr) 110 { 111 return (u16)rtw_usb_read(rtwdev, addr, 2); 112 } 113 114 static u32 rtw_usb_read32(struct rtw_dev *rtwdev, u32 addr) 115 { 116 return (u32)rtw_usb_read(rtwdev, addr, 4); 117 } 118 119 static void rtw_usb_write(struct rtw_dev *rtwdev, u32 addr, u32 val, int len) 120 { 121 struct rtw_usb *rtwusb = (struct rtw_usb *)rtwdev->priv; 122 struct usb_device *udev = rtwusb->udev; 123 unsigned long flags; 124 __le32 *data; 125 int idx, ret; 126 static int count; 127 128 spin_lock_irqsave(&rtwusb->usb_lock, flags); 129 130 idx = rtwusb->usb_data_index; 131 rtwusb->usb_data_index = (idx + 1) & (RTW_USB_MAX_RXTX_COUNT - 1); 132 133 spin_unlock_irqrestore(&rtwusb->usb_lock, flags); 134 135 data = &rtwusb->usb_data[idx]; 136 137 *data = cpu_to_le32(val); 138 139 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 140 RTW_USB_CMD_REQ, RTW_USB_CMD_WRITE, 141 addr, 0, data, len, 30000); 142 if (ret < 0 && ret != -ENODEV && count++ < 4) 143 rtw_err(rtwdev, "write register 0x%x failed with %d\n", 144 addr, ret); 145 146 if (rtwdev->chip->id == RTW_CHIP_TYPE_8822C || 147 rtwdev->chip->id == RTW_CHIP_TYPE_8822B || 148 rtwdev->chip->id == RTW_CHIP_TYPE_8821C) 149 rtw_usb_reg_sec(rtwdev, addr, data); 150 } 151 152 static void rtw_usb_write8(struct rtw_dev *rtwdev, u32 addr, u8 val) 153 { 154 rtw_usb_write(rtwdev, addr, val, 1); 155 } 156 157 static void rtw_usb_write16(struct rtw_dev *rtwdev, u32 addr, u16 val) 158 { 159 rtw_usb_write(rtwdev, addr, val, 2); 160 } 161 162 static void rtw_usb_write32(struct rtw_dev *rtwdev, u32 addr, u32 val) 163 { 164 rtw_usb_write(rtwdev, addr, val, 4); 165 } 166 167 static int dma_mapping_to_ep(enum rtw_dma_mapping dma_mapping) 168 { 169 switch (dma_mapping) { 170 case RTW_DMA_MAPPING_HIGH: 171 return 0; 172 case RTW_DMA_MAPPING_NORMAL: 173 return 1; 174 case RTW_DMA_MAPPING_LOW: 175 return 2; 176 case RTW_DMA_MAPPING_EXTRA: 177 return 3; 178 default: 179 return -EINVAL; 180 } 181 } 182 183 static int rtw_usb_parse(struct rtw_dev *rtwdev, 184 struct usb_interface *interface) 185 { 186 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 187 struct usb_host_interface *host_interface = &interface->altsetting[0]; 188 struct usb_interface_descriptor *interface_desc = &host_interface->desc; 189 struct usb_endpoint_descriptor *endpoint; 190 int num_out_pipes = 0; 191 int i; 192 u8 num; 193 const struct rtw_chip_info *chip = rtwdev->chip; 194 const struct rtw_rqpn *rqpn; 195 196 for (i = 0; i < interface_desc->bNumEndpoints; i++) { 197 endpoint = &host_interface->endpoint[i].desc; 198 num = usb_endpoint_num(endpoint); 199 200 if (usb_endpoint_dir_in(endpoint) && 201 usb_endpoint_xfer_bulk(endpoint)) { 202 if (rtwusb->pipe_in) { 203 rtw_err(rtwdev, "IN pipes overflow\n"); 204 return -EINVAL; 205 } 206 207 rtwusb->pipe_in = num; 208 } 209 210 if (usb_endpoint_dir_in(endpoint) && 211 usb_endpoint_xfer_int(endpoint)) { 212 if (rtwusb->pipe_interrupt) { 213 rtw_err(rtwdev, "INT pipes overflow\n"); 214 return -EINVAL; 215 } 216 217 rtwusb->pipe_interrupt = num; 218 } 219 220 if (usb_endpoint_dir_out(endpoint) && 221 usb_endpoint_xfer_bulk(endpoint)) { 222 if (num_out_pipes >= ARRAY_SIZE(rtwusb->out_ep)) { 223 rtw_err(rtwdev, "OUT pipes overflow\n"); 224 return -EINVAL; 225 } 226 227 rtwusb->out_ep[num_out_pipes++] = num; 228 } 229 } 230 231 rtwdev->hci.bulkout_num = num_out_pipes; 232 233 if (num_out_pipes < 1 || num_out_pipes > 4) { 234 rtw_err(rtwdev, "invalid number of endpoints %d\n", num_out_pipes); 235 return -EINVAL; 236 } 237 238 rqpn = &chip->rqpn_table[num_out_pipes]; 239 240 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID0] = dma_mapping_to_ep(rqpn->dma_map_be); 241 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID1] = dma_mapping_to_ep(rqpn->dma_map_bk); 242 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID2] = dma_mapping_to_ep(rqpn->dma_map_bk); 243 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID3] = dma_mapping_to_ep(rqpn->dma_map_be); 244 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID4] = dma_mapping_to_ep(rqpn->dma_map_vi); 245 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID5] = dma_mapping_to_ep(rqpn->dma_map_vi); 246 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID6] = dma_mapping_to_ep(rqpn->dma_map_vo); 247 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID7] = dma_mapping_to_ep(rqpn->dma_map_vo); 248 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID8] = -EINVAL; 249 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID9] = -EINVAL; 250 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID10] = -EINVAL; 251 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID11] = -EINVAL; 252 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID12] = -EINVAL; 253 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID13] = -EINVAL; 254 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID14] = -EINVAL; 255 rtwusb->qsel_to_ep[TX_DESC_QSEL_TID15] = -EINVAL; 256 rtwusb->qsel_to_ep[TX_DESC_QSEL_BEACON] = dma_mapping_to_ep(rqpn->dma_map_hi); 257 rtwusb->qsel_to_ep[TX_DESC_QSEL_HIGH] = dma_mapping_to_ep(rqpn->dma_map_hi); 258 rtwusb->qsel_to_ep[TX_DESC_QSEL_MGMT] = dma_mapping_to_ep(rqpn->dma_map_mg); 259 rtwusb->qsel_to_ep[TX_DESC_QSEL_H2C] = dma_mapping_to_ep(rqpn->dma_map_hi); 260 261 return 0; 262 } 263 264 static void rtw_usb_write_port_tx_complete(struct urb *urb) 265 { 266 struct rtw_usb_txcb *txcb = urb->context; 267 struct rtw_dev *rtwdev = txcb->rtwdev; 268 struct ieee80211_hw *hw = rtwdev->hw; 269 270 while (true) { 271 struct sk_buff *skb = skb_dequeue(&txcb->tx_ack_queue); 272 struct ieee80211_tx_info *info; 273 struct rtw_usb_tx_data *tx_data; 274 275 if (!skb) 276 break; 277 278 info = IEEE80211_SKB_CB(skb); 279 tx_data = rtw_usb_get_tx_data(skb); 280 281 skb_pull(skb, rtwdev->chip->tx_pkt_desc_sz); 282 283 /* enqueue to wait for tx report */ 284 if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS) { 285 rtw_tx_report_enqueue(rtwdev, skb, tx_data->sn); 286 continue; 287 } 288 289 /* always ACK for others, then they won't be marked as drop */ 290 ieee80211_tx_info_clear_status(info); 291 if (info->flags & IEEE80211_TX_CTL_NO_ACK) 292 info->flags |= IEEE80211_TX_STAT_NOACK_TRANSMITTED; 293 else 294 info->flags |= IEEE80211_TX_STAT_ACK; 295 296 ieee80211_tx_status_irqsafe(hw, skb); 297 } 298 299 kfree(txcb); 300 } 301 302 static int qsel_to_ep(struct rtw_usb *rtwusb, unsigned int qsel) 303 { 304 if (qsel >= ARRAY_SIZE(rtwusb->qsel_to_ep)) 305 return -EINVAL; 306 307 return rtwusb->qsel_to_ep[qsel]; 308 } 309 310 static int rtw_usb_write_port(struct rtw_dev *rtwdev, u8 qsel, struct sk_buff *skb, 311 usb_complete_t cb, void *context) 312 { 313 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 314 struct usb_device *usbd = rtwusb->udev; 315 struct urb *urb; 316 unsigned int pipe; 317 int ret; 318 int ep = qsel_to_ep(rtwusb, qsel); 319 320 if (ep < 0) 321 return ep; 322 323 pipe = usb_sndbulkpipe(usbd, rtwusb->out_ep[ep]); 324 urb = usb_alloc_urb(0, GFP_ATOMIC); 325 if (!urb) 326 return -ENOMEM; 327 328 usb_fill_bulk_urb(urb, usbd, pipe, skb->data, skb->len, cb, context); 329 urb->transfer_flags |= URB_ZERO_PACKET; 330 ret = usb_submit_urb(urb, GFP_ATOMIC); 331 332 usb_free_urb(urb); 333 334 return ret; 335 } 336 337 static bool rtw_usb_tx_agg_skb(struct rtw_usb *rtwusb, struct sk_buff_head *list) 338 { 339 struct rtw_dev *rtwdev = rtwusb->rtwdev; 340 struct rtw_tx_desc *tx_desc; 341 struct rtw_usb_txcb *txcb; 342 struct sk_buff *skb_head; 343 struct sk_buff *skb_iter; 344 int agg_num = 0; 345 unsigned int align_next = 0; 346 u8 qsel; 347 348 if (skb_queue_empty(list)) 349 return false; 350 351 txcb = kmalloc(sizeof(*txcb), GFP_ATOMIC); 352 if (!txcb) 353 return false; 354 355 txcb->rtwdev = rtwdev; 356 skb_queue_head_init(&txcb->tx_ack_queue); 357 358 skb_iter = skb_dequeue(list); 359 360 if (skb_queue_empty(list)) { 361 skb_head = skb_iter; 362 goto queue; 363 } 364 365 skb_head = dev_alloc_skb(RTW_USB_MAX_XMITBUF_SZ); 366 if (!skb_head) { 367 skb_head = skb_iter; 368 goto queue; 369 } 370 371 while (skb_iter) { 372 unsigned long flags; 373 374 skb_put(skb_head, align_next); 375 skb_put_data(skb_head, skb_iter->data, skb_iter->len); 376 377 align_next = ALIGN(skb_iter->len, 8) - skb_iter->len; 378 379 agg_num++; 380 381 skb_queue_tail(&txcb->tx_ack_queue, skb_iter); 382 383 spin_lock_irqsave(&list->lock, flags); 384 385 skb_iter = skb_peek(list); 386 387 if (skb_iter && 388 skb_iter->len + skb_head->len <= RTW_USB_MAX_XMITBUF_SZ && 389 agg_num < rtwdev->chip->usb_tx_agg_desc_num) 390 __skb_unlink(skb_iter, list); 391 else 392 skb_iter = NULL; 393 spin_unlock_irqrestore(&list->lock, flags); 394 } 395 396 if (agg_num > 1) 397 rtw_usb_fill_tx_checksum(rtwusb, skb_head, agg_num); 398 399 queue: 400 skb_queue_tail(&txcb->tx_ack_queue, skb_head); 401 tx_desc = (struct rtw_tx_desc *)skb_head->data; 402 qsel = le32_get_bits(tx_desc->w1, RTW_TX_DESC_W1_QSEL); 403 404 rtw_usb_write_port(rtwdev, qsel, skb_head, rtw_usb_write_port_tx_complete, txcb); 405 406 return true; 407 } 408 409 static void rtw_usb_tx_handler(struct work_struct *work) 410 { 411 struct rtw_usb *rtwusb = container_of(work, struct rtw_usb, tx_work); 412 int i, limit; 413 414 for (i = ARRAY_SIZE(rtwusb->tx_queue) - 1; i >= 0; i--) { 415 for (limit = 0; limit < 200; limit++) { 416 struct sk_buff_head *list = &rtwusb->tx_queue[i]; 417 418 if (!rtw_usb_tx_agg_skb(rtwusb, list)) 419 break; 420 } 421 } 422 } 423 424 static void rtw_usb_tx_queue_purge(struct rtw_usb *rtwusb) 425 { 426 struct rtw_dev *rtwdev = rtwusb->rtwdev; 427 int i; 428 429 for (i = 0; i < ARRAY_SIZE(rtwusb->tx_queue); i++) 430 ieee80211_purge_tx_queue(rtwdev->hw, &rtwusb->tx_queue[i]); 431 } 432 433 static void rtw_usb_write_port_complete(struct urb *urb) 434 { 435 struct sk_buff *skb = urb->context; 436 437 dev_kfree_skb_any(skb); 438 } 439 440 static int rtw_usb_write_data(struct rtw_dev *rtwdev, 441 struct rtw_tx_pkt_info *pkt_info, 442 u8 *buf) 443 { 444 const struct rtw_chip_info *chip = rtwdev->chip; 445 struct sk_buff *skb; 446 unsigned int size; 447 u8 qsel; 448 int ret = 0; 449 450 size = pkt_info->tx_pkt_size; 451 qsel = pkt_info->qsel; 452 453 skb = dev_alloc_skb(chip->tx_pkt_desc_sz + size); 454 if (unlikely(!skb)) 455 return -ENOMEM; 456 457 skb_reserve(skb, chip->tx_pkt_desc_sz); 458 skb_put_data(skb, buf, size); 459 skb_push(skb, chip->tx_pkt_desc_sz); 460 memset(skb->data, 0, chip->tx_pkt_desc_sz); 461 rtw_tx_fill_tx_desc(rtwdev, pkt_info, skb); 462 rtw_tx_fill_txdesc_checksum(rtwdev, pkt_info, skb->data); 463 464 ret = rtw_usb_write_port(rtwdev, qsel, skb, 465 rtw_usb_write_port_complete, skb); 466 if (unlikely(ret)) 467 rtw_err(rtwdev, "failed to do USB write, ret=%d\n", ret); 468 469 return ret; 470 } 471 472 static int rtw_usb_write_data_rsvd_page(struct rtw_dev *rtwdev, u8 *buf, 473 u32 size) 474 { 475 const struct rtw_chip_info *chip = rtwdev->chip; 476 struct rtw_tx_pkt_info pkt_info = {0}; 477 478 pkt_info.tx_pkt_size = size; 479 pkt_info.qsel = TX_DESC_QSEL_BEACON; 480 pkt_info.offset = chip->tx_pkt_desc_sz; 481 pkt_info.ls = true; 482 483 return rtw_usb_write_data(rtwdev, &pkt_info, buf); 484 } 485 486 static int rtw_usb_write_data_h2c(struct rtw_dev *rtwdev, u8 *buf, u32 size) 487 { 488 struct rtw_tx_pkt_info pkt_info = {0}; 489 490 pkt_info.tx_pkt_size = size; 491 pkt_info.qsel = TX_DESC_QSEL_H2C; 492 493 return rtw_usb_write_data(rtwdev, &pkt_info, buf); 494 } 495 496 static u8 rtw_usb_tx_queue_mapping_to_qsel(struct sk_buff *skb) 497 { 498 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 499 __le16 fc = hdr->frame_control; 500 u8 qsel; 501 502 if (unlikely(ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc))) 503 qsel = TX_DESC_QSEL_MGMT; 504 else if (is_broadcast_ether_addr(hdr->addr1) || 505 is_multicast_ether_addr(hdr->addr1)) 506 qsel = TX_DESC_QSEL_HIGH; 507 else if (skb_get_queue_mapping(skb) <= IEEE80211_AC_BK) 508 qsel = skb->priority; 509 else 510 qsel = TX_DESC_QSEL_BEACON; 511 512 return qsel; 513 } 514 515 static int rtw_usb_tx_write(struct rtw_dev *rtwdev, 516 struct rtw_tx_pkt_info *pkt_info, 517 struct sk_buff *skb) 518 { 519 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 520 const struct rtw_chip_info *chip = rtwdev->chip; 521 struct rtw_usb_tx_data *tx_data; 522 u8 *pkt_desc; 523 int ep; 524 525 pkt_info->qsel = rtw_usb_tx_queue_mapping_to_qsel(skb); 526 pkt_desc = skb_push(skb, chip->tx_pkt_desc_sz); 527 memset(pkt_desc, 0, chip->tx_pkt_desc_sz); 528 ep = qsel_to_ep(rtwusb, pkt_info->qsel); 529 rtw_tx_fill_tx_desc(rtwdev, pkt_info, skb); 530 rtw_tx_fill_txdesc_checksum(rtwdev, pkt_info, skb->data); 531 tx_data = rtw_usb_get_tx_data(skb); 532 tx_data->sn = pkt_info->sn; 533 534 skb_queue_tail(&rtwusb->tx_queue[ep], skb); 535 536 return 0; 537 } 538 539 static void rtw_usb_tx_kick_off(struct rtw_dev *rtwdev) 540 { 541 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 542 543 queue_work(rtwusb->txwq, &rtwusb->tx_work); 544 } 545 546 static void rtw_usb_rx_handler(struct work_struct *work) 547 { 548 struct rtw_usb *rtwusb = container_of(work, struct rtw_usb, rx_work); 549 struct rtw_dev *rtwdev = rtwusb->rtwdev; 550 const struct rtw_chip_info *chip = rtwdev->chip; 551 u32 pkt_desc_sz = chip->rx_pkt_desc_sz; 552 struct ieee80211_rx_status rx_status; 553 u32 pkt_offset, next_pkt, urb_len; 554 struct rtw_rx_pkt_stat pkt_stat; 555 struct sk_buff *next_skb; 556 struct sk_buff *skb; 557 u8 *rx_desc; 558 int limit; 559 560 for (limit = 0; limit < 200; limit++) { 561 skb = skb_dequeue(&rtwusb->rx_queue); 562 if (!skb) 563 break; 564 565 if (skb_queue_len(&rtwusb->rx_queue) >= RTW_USB_MAX_RXQ_LEN) { 566 dev_dbg_ratelimited(rtwdev->dev, "failed to get rx_queue, overflow\n"); 567 dev_kfree_skb_any(skb); 568 continue; 569 } 570 571 urb_len = skb->len; 572 573 do { 574 rx_desc = skb->data; 575 rtw_rx_query_rx_desc(rtwdev, rx_desc, &pkt_stat, 576 &rx_status); 577 pkt_offset = pkt_desc_sz + pkt_stat.drv_info_sz + 578 pkt_stat.shift; 579 580 next_pkt = round_up(pkt_stat.pkt_len + pkt_offset, 8); 581 582 if (urb_len >= next_pkt + pkt_desc_sz) 583 next_skb = skb_clone(skb, GFP_KERNEL); 584 else 585 next_skb = NULL; 586 587 if (pkt_stat.is_c2h) { 588 skb_trim(skb, pkt_stat.pkt_len + pkt_offset); 589 rtw_fw_c2h_cmd_rx_irqsafe(rtwdev, pkt_offset, skb); 590 } else { 591 skb_pull(skb, pkt_offset); 592 skb_trim(skb, pkt_stat.pkt_len); 593 rtw_update_rx_freq_for_invalid(rtwdev, skb, 594 &rx_status, 595 &pkt_stat); 596 rtw_rx_stats(rtwdev, pkt_stat.vif, skb); 597 memcpy(skb->cb, &rx_status, sizeof(rx_status)); 598 ieee80211_rx_irqsafe(rtwdev->hw, skb); 599 } 600 601 skb = next_skb; 602 if (skb) 603 skb_pull(skb, next_pkt); 604 605 urb_len -= next_pkt; 606 } while (skb); 607 } 608 } 609 610 static void rtw_usb_read_port_complete(struct urb *urb); 611 612 static void rtw_usb_rx_resubmit(struct rtw_usb *rtwusb, struct rx_usb_ctrl_block *rxcb) 613 { 614 struct rtw_dev *rtwdev = rtwusb->rtwdev; 615 int error; 616 617 rxcb->rx_skb = alloc_skb(RTW_USB_MAX_RECVBUF_SZ, GFP_ATOMIC); 618 if (!rxcb->rx_skb) 619 return; 620 621 usb_fill_bulk_urb(rxcb->rx_urb, rtwusb->udev, 622 usb_rcvbulkpipe(rtwusb->udev, rtwusb->pipe_in), 623 rxcb->rx_skb->data, RTW_USB_MAX_RECVBUF_SZ, 624 rtw_usb_read_port_complete, rxcb); 625 626 error = usb_submit_urb(rxcb->rx_urb, GFP_ATOMIC); 627 if (error) { 628 kfree_skb(rxcb->rx_skb); 629 if (error != -ENODEV) 630 rtw_err(rtwdev, "Err sending rx data urb %d\n", 631 error); 632 } 633 } 634 635 static void rtw_usb_read_port_complete(struct urb *urb) 636 { 637 struct rx_usb_ctrl_block *rxcb = urb->context; 638 struct rtw_dev *rtwdev = rxcb->rtwdev; 639 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 640 struct sk_buff *skb = rxcb->rx_skb; 641 642 if (urb->status == 0) { 643 if (urb->actual_length >= RTW_USB_MAX_RECVBUF_SZ || 644 urb->actual_length < 24) { 645 rtw_err(rtwdev, "failed to get urb length:%d\n", 646 urb->actual_length); 647 if (skb) 648 dev_kfree_skb_any(skb); 649 } else { 650 skb_put(skb, urb->actual_length); 651 skb_queue_tail(&rtwusb->rx_queue, skb); 652 queue_work(rtwusb->rxwq, &rtwusb->rx_work); 653 } 654 rtw_usb_rx_resubmit(rtwusb, rxcb); 655 } else { 656 switch (urb->status) { 657 case -EINVAL: 658 case -EPIPE: 659 case -ENODEV: 660 case -ESHUTDOWN: 661 case -ENOENT: 662 case -EPROTO: 663 case -EILSEQ: 664 case -ETIME: 665 case -ECOMM: 666 case -EOVERFLOW: 667 case -EINPROGRESS: 668 break; 669 default: 670 rtw_err(rtwdev, "status %d\n", urb->status); 671 break; 672 } 673 if (skb) 674 dev_kfree_skb_any(skb); 675 } 676 } 677 678 static void rtw_usb_cancel_rx_bufs(struct rtw_usb *rtwusb) 679 { 680 struct rx_usb_ctrl_block *rxcb; 681 int i; 682 683 for (i = 0; i < RTW_USB_RXCB_NUM; i++) { 684 rxcb = &rtwusb->rx_cb[i]; 685 usb_kill_urb(rxcb->rx_urb); 686 } 687 } 688 689 static void rtw_usb_free_rx_bufs(struct rtw_usb *rtwusb) 690 { 691 struct rx_usb_ctrl_block *rxcb; 692 int i; 693 694 for (i = 0; i < RTW_USB_RXCB_NUM; i++) { 695 rxcb = &rtwusb->rx_cb[i]; 696 usb_kill_urb(rxcb->rx_urb); 697 usb_free_urb(rxcb->rx_urb); 698 } 699 } 700 701 static int rtw_usb_alloc_rx_bufs(struct rtw_usb *rtwusb) 702 { 703 int i; 704 705 for (i = 0; i < RTW_USB_RXCB_NUM; i++) { 706 struct rx_usb_ctrl_block *rxcb = &rtwusb->rx_cb[i]; 707 708 rxcb->rtwdev = rtwusb->rtwdev; 709 rxcb->rx_urb = usb_alloc_urb(0, GFP_KERNEL); 710 if (!rxcb->rx_urb) 711 goto err; 712 } 713 714 return 0; 715 err: 716 rtw_usb_free_rx_bufs(rtwusb); 717 return -ENOMEM; 718 } 719 720 static int rtw_usb_setup(struct rtw_dev *rtwdev) 721 { 722 /* empty function for rtw_hci_ops */ 723 return 0; 724 } 725 726 static int rtw_usb_start(struct rtw_dev *rtwdev) 727 { 728 return 0; 729 } 730 731 static void rtw_usb_stop(struct rtw_dev *rtwdev) 732 { 733 } 734 735 static void rtw_usb_deep_ps(struct rtw_dev *rtwdev, bool enter) 736 { 737 /* empty function for rtw_hci_ops */ 738 } 739 740 static void rtw_usb_link_ps(struct rtw_dev *rtwdev, bool enter) 741 { 742 /* empty function for rtw_hci_ops */ 743 } 744 745 static void rtw_usb_init_burst_pkt_len(struct rtw_dev *rtwdev) 746 { 747 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 748 enum usb_device_speed speed = rtwusb->udev->speed; 749 u8 rxdma, burst_size; 750 751 rxdma = BIT_DMA_BURST_CNT | BIT_DMA_MODE; 752 753 if (speed == USB_SPEED_SUPER) 754 burst_size = BIT_DMA_BURST_SIZE_1024; 755 else if (speed == USB_SPEED_HIGH) 756 burst_size = BIT_DMA_BURST_SIZE_512; 757 else 758 burst_size = BIT_DMA_BURST_SIZE_64; 759 760 u8p_replace_bits(&rxdma, burst_size, BIT_DMA_BURST_SIZE); 761 762 rtw_write8(rtwdev, REG_RXDMA_MODE, rxdma); 763 rtw_write16_set(rtwdev, REG_TXDMA_OFFSET_CHK, BIT_DROP_DATA_EN); 764 } 765 766 static void rtw_usb_interface_cfg(struct rtw_dev *rtwdev) 767 { 768 rtw_usb_init_burst_pkt_len(rtwdev); 769 } 770 771 static void rtw_usb_dynamic_rx_agg_v1(struct rtw_dev *rtwdev, bool enable) 772 { 773 u8 size, timeout; 774 u16 val16; 775 776 rtw_write8_set(rtwdev, REG_TXDMA_PQ_MAP, BIT_RXDMA_AGG_EN); 777 rtw_write8_clr(rtwdev, REG_RXDMA_AGG_PG_TH + 3, BIT(7)); 778 779 if (enable) { 780 size = 0x5; 781 timeout = 0x20; 782 } else { 783 size = 0x0; 784 timeout = 0x1; 785 } 786 val16 = u16_encode_bits(size, BIT_RXDMA_AGG_PG_TH) | 787 u16_encode_bits(timeout, BIT_DMA_AGG_TO_V1); 788 789 rtw_write16(rtwdev, REG_RXDMA_AGG_PG_TH, val16); 790 } 791 792 static void rtw_usb_dynamic_rx_agg_v2(struct rtw_dev *rtwdev, bool enable) 793 { 794 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 795 u8 size, timeout; 796 u16 val16; 797 798 if (!enable) { 799 size = 0x0; 800 timeout = 0x1; 801 } else if (rtwusb->udev->speed == USB_SPEED_SUPER) { 802 size = 0x6; 803 timeout = 0x1a; 804 } else { 805 size = 0x5; 806 timeout = 0x20; 807 } 808 809 val16 = u16_encode_bits(size, BIT_RXDMA_AGG_PG_TH) | 810 u16_encode_bits(timeout, BIT_DMA_AGG_TO_V1); 811 812 rtw_write16(rtwdev, REG_RXDMA_AGG_PG_TH, val16); 813 rtw_write8_set(rtwdev, REG_TXDMA_PQ_MAP, BIT_RXDMA_AGG_EN); 814 } 815 816 static void rtw_usb_dynamic_rx_agg(struct rtw_dev *rtwdev, bool enable) 817 { 818 switch (rtwdev->chip->id) { 819 case RTW_CHIP_TYPE_8822C: 820 case RTW_CHIP_TYPE_8822B: 821 case RTW_CHIP_TYPE_8821C: 822 rtw_usb_dynamic_rx_agg_v1(rtwdev, enable); 823 break; 824 case RTW_CHIP_TYPE_8821A: 825 case RTW_CHIP_TYPE_8812A: 826 rtw_usb_dynamic_rx_agg_v2(rtwdev, enable); 827 break; 828 case RTW_CHIP_TYPE_8723D: 829 /* Doesn't like aggregation. */ 830 break; 831 case RTW_CHIP_TYPE_8703B: 832 /* Likely not found in USB devices. */ 833 break; 834 } 835 } 836 837 static struct rtw_hci_ops rtw_usb_ops = { 838 .tx_write = rtw_usb_tx_write, 839 .tx_kick_off = rtw_usb_tx_kick_off, 840 .setup = rtw_usb_setup, 841 .start = rtw_usb_start, 842 .stop = rtw_usb_stop, 843 .deep_ps = rtw_usb_deep_ps, 844 .link_ps = rtw_usb_link_ps, 845 .interface_cfg = rtw_usb_interface_cfg, 846 .dynamic_rx_agg = rtw_usb_dynamic_rx_agg, 847 848 .write8 = rtw_usb_write8, 849 .write16 = rtw_usb_write16, 850 .write32 = rtw_usb_write32, 851 .read8 = rtw_usb_read8, 852 .read16 = rtw_usb_read16, 853 .read32 = rtw_usb_read32, 854 855 .write_data_rsvd_page = rtw_usb_write_data_rsvd_page, 856 .write_data_h2c = rtw_usb_write_data_h2c, 857 }; 858 859 static int rtw_usb_init_rx(struct rtw_dev *rtwdev) 860 { 861 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 862 863 rtwusb->rxwq = create_singlethread_workqueue("rtw88_usb: rx wq"); 864 if (!rtwusb->rxwq) { 865 rtw_err(rtwdev, "failed to create RX work queue\n"); 866 return -ENOMEM; 867 } 868 869 skb_queue_head_init(&rtwusb->rx_queue); 870 871 INIT_WORK(&rtwusb->rx_work, rtw_usb_rx_handler); 872 873 return 0; 874 } 875 876 static void rtw_usb_setup_rx(struct rtw_dev *rtwdev) 877 { 878 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 879 int i; 880 881 for (i = 0; i < RTW_USB_RXCB_NUM; i++) { 882 struct rx_usb_ctrl_block *rxcb = &rtwusb->rx_cb[i]; 883 884 rtw_usb_rx_resubmit(rtwusb, rxcb); 885 } 886 } 887 888 static void rtw_usb_deinit_rx(struct rtw_dev *rtwdev) 889 { 890 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 891 892 skb_queue_purge(&rtwusb->rx_queue); 893 894 flush_workqueue(rtwusb->rxwq); 895 destroy_workqueue(rtwusb->rxwq); 896 } 897 898 static int rtw_usb_init_tx(struct rtw_dev *rtwdev) 899 { 900 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 901 int i; 902 903 rtwusb->txwq = create_singlethread_workqueue("rtw88_usb: tx wq"); 904 if (!rtwusb->txwq) { 905 rtw_err(rtwdev, "failed to create TX work queue\n"); 906 return -ENOMEM; 907 } 908 909 for (i = 0; i < ARRAY_SIZE(rtwusb->tx_queue); i++) 910 skb_queue_head_init(&rtwusb->tx_queue[i]); 911 912 INIT_WORK(&rtwusb->tx_work, rtw_usb_tx_handler); 913 914 return 0; 915 } 916 917 static void rtw_usb_deinit_tx(struct rtw_dev *rtwdev) 918 { 919 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 920 921 flush_workqueue(rtwusb->txwq); 922 destroy_workqueue(rtwusb->txwq); 923 rtw_usb_tx_queue_purge(rtwusb); 924 } 925 926 static int rtw_usb_intf_init(struct rtw_dev *rtwdev, 927 struct usb_interface *intf) 928 { 929 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 930 struct usb_device *udev = usb_get_dev(interface_to_usbdev(intf)); 931 int ret; 932 933 rtwusb->udev = udev; 934 ret = rtw_usb_parse(rtwdev, intf); 935 if (ret) 936 return ret; 937 938 rtwusb->usb_data = kcalloc(RTW_USB_MAX_RXTX_COUNT, sizeof(u32), 939 GFP_KERNEL); 940 if (!rtwusb->usb_data) 941 return -ENOMEM; 942 943 usb_set_intfdata(intf, rtwdev->hw); 944 945 SET_IEEE80211_DEV(rtwdev->hw, &intf->dev); 946 spin_lock_init(&rtwusb->usb_lock); 947 948 return 0; 949 } 950 951 static void rtw_usb_intf_deinit(struct rtw_dev *rtwdev, 952 struct usb_interface *intf) 953 { 954 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 955 956 usb_put_dev(rtwusb->udev); 957 kfree(rtwusb->usb_data); 958 usb_set_intfdata(intf, NULL); 959 } 960 961 static int rtw_usb_switch_mode_old(struct rtw_dev *rtwdev) 962 { 963 struct rtw_usb *rtwusb = rtw_get_usb_priv(rtwdev); 964 enum usb_device_speed cur_speed = rtwusb->udev->speed; 965 u8 hci_opt; 966 967 if (cur_speed == USB_SPEED_HIGH) { 968 hci_opt = rtw_read8(rtwdev, REG_HCI_OPT_CTRL); 969 970 if ((hci_opt & (BIT(2) | BIT(3))) != BIT(3)) { 971 rtw_write8(rtwdev, REG_HCI_OPT_CTRL, 0x8); 972 rtw_write8(rtwdev, REG_SYS_SDIO_CTRL, 0x2); 973 rtw_write8(rtwdev, REG_ACLK_MON, 0x1); 974 rtw_write8(rtwdev, 0x3d, 0x3); 975 /* usb disconnect */ 976 rtw_write8(rtwdev, REG_SYS_PW_CTRL + 1, 0x80); 977 return 1; 978 } 979 } else if (cur_speed == USB_SPEED_SUPER) { 980 rtw_write8_clr(rtwdev, REG_SYS_SDIO_CTRL, BIT(1)); 981 rtw_write8_clr(rtwdev, REG_ACLK_MON, BIT(0)); 982 } 983 984 return 0; 985 } 986 987 static int rtw_usb_switch_mode_new(struct rtw_dev *rtwdev) 988 { 989 enum usb_device_speed cur_speed; 990 u8 id = rtwdev->chip->id; 991 bool can_switch; 992 u32 pad_ctrl2; 993 994 if (rtw_read8(rtwdev, REG_SYS_CFG2 + 3) == 0x20) 995 cur_speed = USB_SPEED_SUPER; 996 else 997 cur_speed = USB_SPEED_HIGH; 998 999 if (cur_speed == USB_SPEED_SUPER) 1000 return 0; 1001 1002 pad_ctrl2 = rtw_read32(rtwdev, REG_PAD_CTRL2); 1003 1004 can_switch = !!(pad_ctrl2 & (BIT_MASK_USB23_SW_MODE_V1 | 1005 BIT_USB3_USB2_TRANSITION)); 1006 1007 if (!can_switch) { 1008 rtw_dbg(rtwdev, RTW_DBG_USB, 1009 "Switching to USB 3 mode unsupported by the chip\n"); 1010 return 0; 1011 } 1012 1013 /* At this point cur_speed is USB_SPEED_HIGH. If we already tried 1014 * to switch don't try again - it's a USB 2 port. 1015 */ 1016 if (u32_get_bits(pad_ctrl2, BIT_MASK_USB23_SW_MODE_V1) == BIT_USB_MODE_U3) 1017 return 0; 1018 1019 /* Enable IO wrapper timeout */ 1020 if (id == RTW_CHIP_TYPE_8822B || id == RTW_CHIP_TYPE_8821C) 1021 rtw_write8_clr(rtwdev, REG_SW_MDIO + 3, BIT(0)); 1022 1023 u32p_replace_bits(&pad_ctrl2, BIT_USB_MODE_U3, BIT_MASK_USB23_SW_MODE_V1); 1024 pad_ctrl2 |= BIT_RSM_EN_V1; 1025 1026 rtw_write32(rtwdev, REG_PAD_CTRL2, pad_ctrl2); 1027 rtw_write8(rtwdev, REG_PAD_CTRL2 + 1, 4); 1028 1029 rtw_write16_set(rtwdev, REG_SYS_PW_CTRL, BIT_APFM_OFFMAC); 1030 usleep_range(1000, 1001); 1031 rtw_write32_set(rtwdev, REG_PAD_CTRL2, BIT_NO_PDN_CHIPOFF_V1); 1032 1033 return 1; 1034 } 1035 1036 static bool rtw_usb3_chip_old(u8 chip_id) 1037 { 1038 return chip_id == RTW_CHIP_TYPE_8812A; 1039 } 1040 1041 static bool rtw_usb3_chip_new(u8 chip_id) 1042 { 1043 return chip_id == RTW_CHIP_TYPE_8822C || 1044 chip_id == RTW_CHIP_TYPE_8822B; 1045 } 1046 1047 static int rtw_usb_switch_mode(struct rtw_dev *rtwdev) 1048 { 1049 u8 id = rtwdev->chip->id; 1050 1051 if (!rtw_usb3_chip_new(id) && !rtw_usb3_chip_old(id)) 1052 return 0; 1053 1054 if (!rtwdev->efuse.usb_mode_switch) { 1055 rtw_dbg(rtwdev, RTW_DBG_USB, 1056 "Switching to USB 3 mode disabled by chip's efuse\n"); 1057 return 0; 1058 } 1059 1060 if (!rtw_switch_usb_mode) { 1061 rtw_dbg(rtwdev, RTW_DBG_USB, 1062 "Switching to USB 3 mode disabled by module parameter\n"); 1063 return 0; 1064 } 1065 1066 if (rtw_usb3_chip_old(id)) 1067 return rtw_usb_switch_mode_old(rtwdev); 1068 else 1069 return rtw_usb_switch_mode_new(rtwdev); 1070 } 1071 1072 int rtw_usb_probe(struct usb_interface *intf, const struct usb_device_id *id) 1073 { 1074 struct rtw_dev *rtwdev; 1075 struct ieee80211_hw *hw; 1076 struct rtw_usb *rtwusb; 1077 int drv_data_size; 1078 int ret; 1079 1080 drv_data_size = sizeof(struct rtw_dev) + sizeof(struct rtw_usb); 1081 hw = ieee80211_alloc_hw(drv_data_size, &rtw_ops); 1082 if (!hw) 1083 return -ENOMEM; 1084 1085 rtwdev = hw->priv; 1086 rtwdev->hw = hw; 1087 rtwdev->dev = &intf->dev; 1088 rtwdev->chip = (struct rtw_chip_info *)id->driver_info; 1089 rtwdev->hci.ops = &rtw_usb_ops; 1090 rtwdev->hci.type = RTW_HCI_TYPE_USB; 1091 1092 rtwusb = rtw_get_usb_priv(rtwdev); 1093 rtwusb->rtwdev = rtwdev; 1094 1095 ret = rtw_usb_alloc_rx_bufs(rtwusb); 1096 if (ret) 1097 goto err_release_hw; 1098 1099 ret = rtw_core_init(rtwdev); 1100 if (ret) 1101 goto err_free_rx_bufs; 1102 1103 ret = rtw_usb_intf_init(rtwdev, intf); 1104 if (ret) { 1105 rtw_err(rtwdev, "failed to init USB interface\n"); 1106 goto err_deinit_core; 1107 } 1108 1109 ret = rtw_usb_init_tx(rtwdev); 1110 if (ret) { 1111 rtw_err(rtwdev, "failed to init USB TX\n"); 1112 goto err_destroy_usb; 1113 } 1114 1115 ret = rtw_usb_init_rx(rtwdev); 1116 if (ret) { 1117 rtw_err(rtwdev, "failed to init USB RX\n"); 1118 goto err_destroy_txwq; 1119 } 1120 1121 ret = rtw_chip_info_setup(rtwdev); 1122 if (ret) { 1123 rtw_err(rtwdev, "failed to setup chip information\n"); 1124 goto err_destroy_rxwq; 1125 } 1126 1127 ret = rtw_usb_switch_mode(rtwdev); 1128 if (ret) { 1129 /* Not a fail, but we do need to skip rtw_register_hw. */ 1130 rtw_dbg(rtwdev, RTW_DBG_USB, "switching to USB 3 mode\n"); 1131 ret = 0; 1132 goto err_destroy_rxwq; 1133 } 1134 1135 ret = rtw_register_hw(rtwdev, rtwdev->hw); 1136 if (ret) { 1137 rtw_err(rtwdev, "failed to register hw\n"); 1138 goto err_destroy_rxwq; 1139 } 1140 1141 rtw_usb_setup_rx(rtwdev); 1142 1143 return 0; 1144 1145 err_destroy_rxwq: 1146 rtw_usb_deinit_rx(rtwdev); 1147 1148 err_destroy_txwq: 1149 rtw_usb_deinit_tx(rtwdev); 1150 1151 err_destroy_usb: 1152 rtw_usb_intf_deinit(rtwdev, intf); 1153 1154 err_deinit_core: 1155 rtw_core_deinit(rtwdev); 1156 1157 err_free_rx_bufs: 1158 rtw_usb_free_rx_bufs(rtwusb); 1159 1160 err_release_hw: 1161 ieee80211_free_hw(hw); 1162 1163 return ret; 1164 } 1165 EXPORT_SYMBOL(rtw_usb_probe); 1166 1167 void rtw_usb_disconnect(struct usb_interface *intf) 1168 { 1169 struct ieee80211_hw *hw = usb_get_intfdata(intf); 1170 struct rtw_dev *rtwdev; 1171 struct rtw_usb *rtwusb; 1172 1173 if (!hw) 1174 return; 1175 1176 rtwdev = hw->priv; 1177 rtwusb = rtw_get_usb_priv(rtwdev); 1178 1179 rtw_usb_cancel_rx_bufs(rtwusb); 1180 1181 rtw_unregister_hw(rtwdev, hw); 1182 rtw_usb_deinit_tx(rtwdev); 1183 rtw_usb_deinit_rx(rtwdev); 1184 1185 if (rtwusb->udev->state != USB_STATE_NOTATTACHED) 1186 usb_reset_device(rtwusb->udev); 1187 1188 rtw_usb_free_rx_bufs(rtwusb); 1189 1190 rtw_usb_intf_deinit(rtwdev, intf); 1191 rtw_core_deinit(rtwdev); 1192 ieee80211_free_hw(hw); 1193 } 1194 EXPORT_SYMBOL(rtw_usb_disconnect); 1195 1196 MODULE_AUTHOR("Realtek Corporation"); 1197 MODULE_DESCRIPTION("Realtek USB 802.11ac wireless driver"); 1198 MODULE_LICENSE("Dual BSD/GPL"); 1199