1 /* 2 * Copyright (c) 2005-2011 Atheros Communications Inc. 3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18 #include <linux/etherdevice.h> 19 #include "htt.h" 20 #include "mac.h" 21 #include "hif.h" 22 #include "txrx.h" 23 #include "debug.h" 24 25 void __ath10k_htt_tx_dec_pending(struct ath10k_htt *htt, bool limit_mgmt_desc) 26 { 27 if (limit_mgmt_desc) 28 htt->num_pending_mgmt_tx--; 29 30 htt->num_pending_tx--; 31 if (htt->num_pending_tx == htt->max_num_pending_tx - 1) 32 ath10k_mac_tx_unlock(htt->ar, ATH10K_TX_PAUSE_Q_FULL); 33 } 34 35 static void ath10k_htt_tx_dec_pending(struct ath10k_htt *htt, 36 bool limit_mgmt_desc) 37 { 38 spin_lock_bh(&htt->tx_lock); 39 __ath10k_htt_tx_dec_pending(htt, limit_mgmt_desc); 40 spin_unlock_bh(&htt->tx_lock); 41 } 42 43 static int ath10k_htt_tx_inc_pending(struct ath10k_htt *htt, 44 bool limit_mgmt_desc, bool is_probe_resp) 45 { 46 struct ath10k *ar = htt->ar; 47 int ret = 0; 48 49 spin_lock_bh(&htt->tx_lock); 50 51 if (htt->num_pending_tx >= htt->max_num_pending_tx) { 52 ret = -EBUSY; 53 goto exit; 54 } 55 56 if (limit_mgmt_desc) { 57 if (is_probe_resp && (htt->num_pending_mgmt_tx > 58 ar->hw_params.max_probe_resp_desc_thres)) { 59 ret = -EBUSY; 60 goto exit; 61 } 62 htt->num_pending_mgmt_tx++; 63 } 64 65 htt->num_pending_tx++; 66 if (htt->num_pending_tx == htt->max_num_pending_tx) 67 ath10k_mac_tx_lock(htt->ar, ATH10K_TX_PAUSE_Q_FULL); 68 69 exit: 70 spin_unlock_bh(&htt->tx_lock); 71 return ret; 72 } 73 74 int ath10k_htt_tx_alloc_msdu_id(struct ath10k_htt *htt, struct sk_buff *skb) 75 { 76 struct ath10k *ar = htt->ar; 77 int ret; 78 79 lockdep_assert_held(&htt->tx_lock); 80 81 ret = idr_alloc(&htt->pending_tx, skb, 0, 82 htt->max_num_pending_tx, GFP_ATOMIC); 83 84 ath10k_dbg(ar, ATH10K_DBG_HTT, "htt tx alloc msdu_id %d\n", ret); 85 86 return ret; 87 } 88 89 void ath10k_htt_tx_free_msdu_id(struct ath10k_htt *htt, u16 msdu_id) 90 { 91 struct ath10k *ar = htt->ar; 92 93 lockdep_assert_held(&htt->tx_lock); 94 95 ath10k_dbg(ar, ATH10K_DBG_HTT, "htt tx free msdu_id %hu\n", msdu_id); 96 97 idr_remove(&htt->pending_tx, msdu_id); 98 } 99 100 int ath10k_htt_tx_alloc(struct ath10k_htt *htt) 101 { 102 struct ath10k *ar = htt->ar; 103 int ret, size; 104 105 ath10k_dbg(ar, ATH10K_DBG_BOOT, "htt tx max num pending tx %d\n", 106 htt->max_num_pending_tx); 107 108 spin_lock_init(&htt->tx_lock); 109 idr_init(&htt->pending_tx); 110 111 size = htt->max_num_pending_tx * sizeof(struct ath10k_htt_txbuf); 112 htt->txbuf.vaddr = dma_alloc_coherent(ar->dev, size, 113 &htt->txbuf.paddr, 114 GFP_KERNEL); 115 if (!htt->txbuf.vaddr) { 116 ath10k_err(ar, "failed to alloc tx buffer\n"); 117 ret = -ENOMEM; 118 goto free_idr_pending_tx; 119 } 120 121 if (!ar->hw_params.continuous_frag_desc) 122 goto skip_frag_desc_alloc; 123 124 size = htt->max_num_pending_tx * sizeof(struct htt_msdu_ext_desc); 125 htt->frag_desc.vaddr = dma_alloc_coherent(ar->dev, size, 126 &htt->frag_desc.paddr, 127 GFP_KERNEL); 128 if (!htt->frag_desc.vaddr) { 129 ath10k_warn(ar, "failed to alloc fragment desc memory\n"); 130 ret = -ENOMEM; 131 goto free_txbuf; 132 } 133 134 skip_frag_desc_alloc: 135 return 0; 136 137 free_txbuf: 138 size = htt->max_num_pending_tx * 139 sizeof(struct ath10k_htt_txbuf); 140 dma_free_coherent(htt->ar->dev, size, htt->txbuf.vaddr, 141 htt->txbuf.paddr); 142 free_idr_pending_tx: 143 idr_destroy(&htt->pending_tx); 144 return ret; 145 } 146 147 static int ath10k_htt_tx_clean_up_pending(int msdu_id, void *skb, void *ctx) 148 { 149 struct ath10k *ar = ctx; 150 struct ath10k_htt *htt = &ar->htt; 151 struct htt_tx_done tx_done = {0}; 152 153 ath10k_dbg(ar, ATH10K_DBG_HTT, "force cleanup msdu_id %hu\n", msdu_id); 154 155 tx_done.discard = 1; 156 tx_done.msdu_id = msdu_id; 157 158 ath10k_txrx_tx_unref(htt, &tx_done); 159 160 return 0; 161 } 162 163 void ath10k_htt_tx_free(struct ath10k_htt *htt) 164 { 165 int size; 166 167 idr_for_each(&htt->pending_tx, ath10k_htt_tx_clean_up_pending, htt->ar); 168 idr_destroy(&htt->pending_tx); 169 170 if (htt->txbuf.vaddr) { 171 size = htt->max_num_pending_tx * 172 sizeof(struct ath10k_htt_txbuf); 173 dma_free_coherent(htt->ar->dev, size, htt->txbuf.vaddr, 174 htt->txbuf.paddr); 175 } 176 177 if (htt->frag_desc.vaddr) { 178 size = htt->max_num_pending_tx * 179 sizeof(struct htt_msdu_ext_desc); 180 dma_free_coherent(htt->ar->dev, size, htt->frag_desc.vaddr, 181 htt->frag_desc.paddr); 182 } 183 } 184 185 void ath10k_htt_htc_tx_complete(struct ath10k *ar, struct sk_buff *skb) 186 { 187 dev_kfree_skb_any(skb); 188 } 189 190 void ath10k_htt_hif_tx_complete(struct ath10k *ar, struct sk_buff *skb) 191 { 192 dev_kfree_skb_any(skb); 193 } 194 EXPORT_SYMBOL(ath10k_htt_hif_tx_complete); 195 196 int ath10k_htt_h2t_ver_req_msg(struct ath10k_htt *htt) 197 { 198 struct ath10k *ar = htt->ar; 199 struct sk_buff *skb; 200 struct htt_cmd *cmd; 201 int len = 0; 202 int ret; 203 204 len += sizeof(cmd->hdr); 205 len += sizeof(cmd->ver_req); 206 207 skb = ath10k_htc_alloc_skb(ar, len); 208 if (!skb) 209 return -ENOMEM; 210 211 skb_put(skb, len); 212 cmd = (struct htt_cmd *)skb->data; 213 cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_VERSION_REQ; 214 215 ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb); 216 if (ret) { 217 dev_kfree_skb_any(skb); 218 return ret; 219 } 220 221 return 0; 222 } 223 224 int ath10k_htt_h2t_stats_req(struct ath10k_htt *htt, u8 mask, u64 cookie) 225 { 226 struct ath10k *ar = htt->ar; 227 struct htt_stats_req *req; 228 struct sk_buff *skb; 229 struct htt_cmd *cmd; 230 int len = 0, ret; 231 232 len += sizeof(cmd->hdr); 233 len += sizeof(cmd->stats_req); 234 235 skb = ath10k_htc_alloc_skb(ar, len); 236 if (!skb) 237 return -ENOMEM; 238 239 skb_put(skb, len); 240 cmd = (struct htt_cmd *)skb->data; 241 cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_STATS_REQ; 242 243 req = &cmd->stats_req; 244 245 memset(req, 0, sizeof(*req)); 246 247 /* currently we support only max 8 bit masks so no need to worry 248 * about endian support */ 249 req->upload_types[0] = mask; 250 req->reset_types[0] = mask; 251 req->stat_type = HTT_STATS_REQ_CFG_STAT_TYPE_INVALID; 252 req->cookie_lsb = cpu_to_le32(cookie & 0xffffffff); 253 req->cookie_msb = cpu_to_le32((cookie & 0xffffffff00000000ULL) >> 32); 254 255 ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb); 256 if (ret) { 257 ath10k_warn(ar, "failed to send htt type stats request: %d", 258 ret); 259 dev_kfree_skb_any(skb); 260 return ret; 261 } 262 263 return 0; 264 } 265 266 int ath10k_htt_send_frag_desc_bank_cfg(struct ath10k_htt *htt) 267 { 268 struct ath10k *ar = htt->ar; 269 struct sk_buff *skb; 270 struct htt_cmd *cmd; 271 int ret, size; 272 273 if (!ar->hw_params.continuous_frag_desc) 274 return 0; 275 276 if (!htt->frag_desc.paddr) { 277 ath10k_warn(ar, "invalid frag desc memory\n"); 278 return -EINVAL; 279 } 280 281 size = sizeof(cmd->hdr) + sizeof(cmd->frag_desc_bank_cfg); 282 skb = ath10k_htc_alloc_skb(ar, size); 283 if (!skb) 284 return -ENOMEM; 285 286 skb_put(skb, size); 287 cmd = (struct htt_cmd *)skb->data; 288 cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_FRAG_DESC_BANK_CFG; 289 cmd->frag_desc_bank_cfg.info = 0; 290 cmd->frag_desc_bank_cfg.num_banks = 1; 291 cmd->frag_desc_bank_cfg.desc_size = sizeof(struct htt_msdu_ext_desc); 292 cmd->frag_desc_bank_cfg.bank_base_addrs[0] = 293 __cpu_to_le32(htt->frag_desc.paddr); 294 cmd->frag_desc_bank_cfg.bank_id[0].bank_min_id = 0; 295 cmd->frag_desc_bank_cfg.bank_id[0].bank_max_id = 296 __cpu_to_le16(htt->max_num_pending_tx - 1); 297 298 ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb); 299 if (ret) { 300 ath10k_warn(ar, "failed to send frag desc bank cfg request: %d\n", 301 ret); 302 dev_kfree_skb_any(skb); 303 return ret; 304 } 305 306 return 0; 307 } 308 309 int ath10k_htt_send_rx_ring_cfg_ll(struct ath10k_htt *htt) 310 { 311 struct ath10k *ar = htt->ar; 312 struct sk_buff *skb; 313 struct htt_cmd *cmd; 314 struct htt_rx_ring_setup_ring *ring; 315 const int num_rx_ring = 1; 316 u16 flags; 317 u32 fw_idx; 318 int len; 319 int ret; 320 321 /* 322 * the HW expects the buffer to be an integral number of 4-byte 323 * "words" 324 */ 325 BUILD_BUG_ON(!IS_ALIGNED(HTT_RX_BUF_SIZE, 4)); 326 BUILD_BUG_ON((HTT_RX_BUF_SIZE & HTT_MAX_CACHE_LINE_SIZE_MASK) != 0); 327 328 len = sizeof(cmd->hdr) + sizeof(cmd->rx_setup.hdr) 329 + (sizeof(*ring) * num_rx_ring); 330 skb = ath10k_htc_alloc_skb(ar, len); 331 if (!skb) 332 return -ENOMEM; 333 334 skb_put(skb, len); 335 336 cmd = (struct htt_cmd *)skb->data; 337 ring = &cmd->rx_setup.rings[0]; 338 339 cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_RX_RING_CFG; 340 cmd->rx_setup.hdr.num_rings = 1; 341 342 /* FIXME: do we need all of this? */ 343 flags = 0; 344 flags |= HTT_RX_RING_FLAGS_MAC80211_HDR; 345 flags |= HTT_RX_RING_FLAGS_MSDU_PAYLOAD; 346 flags |= HTT_RX_RING_FLAGS_PPDU_START; 347 flags |= HTT_RX_RING_FLAGS_PPDU_END; 348 flags |= HTT_RX_RING_FLAGS_MPDU_START; 349 flags |= HTT_RX_RING_FLAGS_MPDU_END; 350 flags |= HTT_RX_RING_FLAGS_MSDU_START; 351 flags |= HTT_RX_RING_FLAGS_MSDU_END; 352 flags |= HTT_RX_RING_FLAGS_RX_ATTENTION; 353 flags |= HTT_RX_RING_FLAGS_FRAG_INFO; 354 flags |= HTT_RX_RING_FLAGS_UNICAST_RX; 355 flags |= HTT_RX_RING_FLAGS_MULTICAST_RX; 356 flags |= HTT_RX_RING_FLAGS_CTRL_RX; 357 flags |= HTT_RX_RING_FLAGS_MGMT_RX; 358 flags |= HTT_RX_RING_FLAGS_NULL_RX; 359 flags |= HTT_RX_RING_FLAGS_PHY_DATA_RX; 360 361 fw_idx = __le32_to_cpu(*htt->rx_ring.alloc_idx.vaddr); 362 363 ring->fw_idx_shadow_reg_paddr = 364 __cpu_to_le32(htt->rx_ring.alloc_idx.paddr); 365 ring->rx_ring_base_paddr = __cpu_to_le32(htt->rx_ring.base_paddr); 366 ring->rx_ring_len = __cpu_to_le16(htt->rx_ring.size); 367 ring->rx_ring_bufsize = __cpu_to_le16(HTT_RX_BUF_SIZE); 368 ring->flags = __cpu_to_le16(flags); 369 ring->fw_idx_init_val = __cpu_to_le16(fw_idx); 370 371 #define desc_offset(x) (offsetof(struct htt_rx_desc, x) / 4) 372 373 ring->mac80211_hdr_offset = __cpu_to_le16(desc_offset(rx_hdr_status)); 374 ring->msdu_payload_offset = __cpu_to_le16(desc_offset(msdu_payload)); 375 ring->ppdu_start_offset = __cpu_to_le16(desc_offset(ppdu_start)); 376 ring->ppdu_end_offset = __cpu_to_le16(desc_offset(ppdu_end)); 377 ring->mpdu_start_offset = __cpu_to_le16(desc_offset(mpdu_start)); 378 ring->mpdu_end_offset = __cpu_to_le16(desc_offset(mpdu_end)); 379 ring->msdu_start_offset = __cpu_to_le16(desc_offset(msdu_start)); 380 ring->msdu_end_offset = __cpu_to_le16(desc_offset(msdu_end)); 381 ring->rx_attention_offset = __cpu_to_le16(desc_offset(attention)); 382 ring->frag_info_offset = __cpu_to_le16(desc_offset(frag_info)); 383 384 #undef desc_offset 385 386 ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb); 387 if (ret) { 388 dev_kfree_skb_any(skb); 389 return ret; 390 } 391 392 return 0; 393 } 394 395 int ath10k_htt_h2t_aggr_cfg_msg(struct ath10k_htt *htt, 396 u8 max_subfrms_ampdu, 397 u8 max_subfrms_amsdu) 398 { 399 struct ath10k *ar = htt->ar; 400 struct htt_aggr_conf *aggr_conf; 401 struct sk_buff *skb; 402 struct htt_cmd *cmd; 403 int len; 404 int ret; 405 406 /* Firmware defaults are: amsdu = 3 and ampdu = 64 */ 407 408 if (max_subfrms_ampdu == 0 || max_subfrms_ampdu > 64) 409 return -EINVAL; 410 411 if (max_subfrms_amsdu == 0 || max_subfrms_amsdu > 31) 412 return -EINVAL; 413 414 len = sizeof(cmd->hdr); 415 len += sizeof(cmd->aggr_conf); 416 417 skb = ath10k_htc_alloc_skb(ar, len); 418 if (!skb) 419 return -ENOMEM; 420 421 skb_put(skb, len); 422 cmd = (struct htt_cmd *)skb->data; 423 cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_AGGR_CFG; 424 425 aggr_conf = &cmd->aggr_conf; 426 aggr_conf->max_num_ampdu_subframes = max_subfrms_ampdu; 427 aggr_conf->max_num_amsdu_subframes = max_subfrms_amsdu; 428 429 ath10k_dbg(ar, ATH10K_DBG_HTT, "htt h2t aggr cfg msg amsdu %d ampdu %d", 430 aggr_conf->max_num_amsdu_subframes, 431 aggr_conf->max_num_ampdu_subframes); 432 433 ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb); 434 if (ret) { 435 dev_kfree_skb_any(skb); 436 return ret; 437 } 438 439 return 0; 440 } 441 442 static u8 ath10k_htt_tx_get_vdev_id(struct ath10k *ar, struct sk_buff *skb) 443 { 444 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 445 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb); 446 struct ath10k_vif *arvif = (void *)cb->vif->drv_priv; 447 448 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) 449 return ar->scan.vdev_id; 450 else if (cb->vif) 451 return arvif->vdev_id; 452 else if (ar->monitor_started) 453 return ar->monitor_vdev_id; 454 else 455 return 0; 456 } 457 458 static u8 ath10k_htt_tx_get_tid(struct sk_buff *skb, bool is_eth) 459 { 460 struct ieee80211_hdr *hdr = (void *)skb->data; 461 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb); 462 463 if (!is_eth && ieee80211_is_mgmt(hdr->frame_control)) 464 return HTT_DATA_TX_EXT_TID_MGMT; 465 else if (cb->flags & ATH10K_SKB_F_QOS) 466 return skb->priority % IEEE80211_QOS_CTL_TID_MASK; 467 else 468 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST; 469 } 470 471 int ath10k_htt_mgmt_tx(struct ath10k_htt *htt, struct sk_buff *msdu) 472 { 473 struct ath10k *ar = htt->ar; 474 struct device *dev = ar->dev; 475 struct sk_buff *txdesc = NULL; 476 struct htt_cmd *cmd; 477 struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(msdu); 478 u8 vdev_id = ath10k_htt_tx_get_vdev_id(ar, msdu); 479 int len = 0; 480 int msdu_id = -1; 481 int res; 482 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)msdu->data; 483 bool limit_mgmt_desc = false; 484 bool is_probe_resp = false; 485 486 if (ar->hw_params.max_probe_resp_desc_thres) { 487 limit_mgmt_desc = true; 488 489 if (ieee80211_is_probe_resp(hdr->frame_control)) 490 is_probe_resp = true; 491 } 492 493 res = ath10k_htt_tx_inc_pending(htt, limit_mgmt_desc, is_probe_resp); 494 495 if (res) 496 goto err; 497 498 len += sizeof(cmd->hdr); 499 len += sizeof(cmd->mgmt_tx); 500 501 spin_lock_bh(&htt->tx_lock); 502 res = ath10k_htt_tx_alloc_msdu_id(htt, msdu); 503 spin_unlock_bh(&htt->tx_lock); 504 if (res < 0) 505 goto err_tx_dec; 506 507 msdu_id = res; 508 509 if ((ieee80211_is_action(hdr->frame_control) || 510 ieee80211_is_deauth(hdr->frame_control) || 511 ieee80211_is_disassoc(hdr->frame_control)) && 512 ieee80211_has_protected(hdr->frame_control)) { 513 skb_put(msdu, IEEE80211_CCMP_MIC_LEN); 514 } 515 516 txdesc = ath10k_htc_alloc_skb(ar, len); 517 if (!txdesc) { 518 res = -ENOMEM; 519 goto err_free_msdu_id; 520 } 521 522 skb_cb->paddr = dma_map_single(dev, msdu->data, msdu->len, 523 DMA_TO_DEVICE); 524 res = dma_mapping_error(dev, skb_cb->paddr); 525 if (res) { 526 res = -EIO; 527 goto err_free_txdesc; 528 } 529 530 skb_put(txdesc, len); 531 cmd = (struct htt_cmd *)txdesc->data; 532 memset(cmd, 0, len); 533 534 cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_MGMT_TX; 535 cmd->mgmt_tx.msdu_paddr = __cpu_to_le32(ATH10K_SKB_CB(msdu)->paddr); 536 cmd->mgmt_tx.len = __cpu_to_le32(msdu->len); 537 cmd->mgmt_tx.desc_id = __cpu_to_le32(msdu_id); 538 cmd->mgmt_tx.vdev_id = __cpu_to_le32(vdev_id); 539 memcpy(cmd->mgmt_tx.hdr, msdu->data, 540 min_t(int, msdu->len, HTT_MGMT_FRM_HDR_DOWNLOAD_LEN)); 541 542 res = ath10k_htc_send(&htt->ar->htc, htt->eid, txdesc); 543 if (res) 544 goto err_unmap_msdu; 545 546 return 0; 547 548 err_unmap_msdu: 549 dma_unmap_single(dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE); 550 err_free_txdesc: 551 dev_kfree_skb_any(txdesc); 552 err_free_msdu_id: 553 spin_lock_bh(&htt->tx_lock); 554 ath10k_htt_tx_free_msdu_id(htt, msdu_id); 555 spin_unlock_bh(&htt->tx_lock); 556 err_tx_dec: 557 ath10k_htt_tx_dec_pending(htt, limit_mgmt_desc); 558 err: 559 return res; 560 } 561 562 int ath10k_htt_tx(struct ath10k_htt *htt, enum ath10k_hw_txrx_mode txmode, 563 struct sk_buff *msdu) 564 { 565 struct ath10k *ar = htt->ar; 566 struct device *dev = ar->dev; 567 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)msdu->data; 568 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(msdu); 569 struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(msdu); 570 struct ath10k_hif_sg_item sg_items[2]; 571 struct ath10k_htt_txbuf *txbuf; 572 struct htt_data_tx_desc_frag *frags; 573 bool is_eth = (txmode == ATH10K_HW_TXRX_ETHERNET); 574 u8 vdev_id = ath10k_htt_tx_get_vdev_id(ar, msdu); 575 u8 tid = ath10k_htt_tx_get_tid(msdu, is_eth); 576 int prefetch_len; 577 int res; 578 u8 flags0 = 0; 579 u16 msdu_id, flags1 = 0; 580 u16 freq = 0; 581 u32 frags_paddr = 0; 582 u32 txbuf_paddr; 583 struct htt_msdu_ext_desc *ext_desc = NULL; 584 bool limit_mgmt_desc = false; 585 bool is_probe_resp = false; 586 587 if (unlikely(ieee80211_is_mgmt(hdr->frame_control)) && 588 ar->hw_params.max_probe_resp_desc_thres) { 589 limit_mgmt_desc = true; 590 591 if (ieee80211_is_probe_resp(hdr->frame_control)) 592 is_probe_resp = true; 593 } 594 595 res = ath10k_htt_tx_inc_pending(htt, limit_mgmt_desc, is_probe_resp); 596 if (res) 597 goto err; 598 599 spin_lock_bh(&htt->tx_lock); 600 res = ath10k_htt_tx_alloc_msdu_id(htt, msdu); 601 spin_unlock_bh(&htt->tx_lock); 602 if (res < 0) 603 goto err_tx_dec; 604 605 msdu_id = res; 606 607 prefetch_len = min(htt->prefetch_len, msdu->len); 608 prefetch_len = roundup(prefetch_len, 4); 609 610 txbuf = &htt->txbuf.vaddr[msdu_id]; 611 txbuf_paddr = htt->txbuf.paddr + 612 (sizeof(struct ath10k_htt_txbuf) * msdu_id); 613 614 if ((ieee80211_is_action(hdr->frame_control) || 615 ieee80211_is_deauth(hdr->frame_control) || 616 ieee80211_is_disassoc(hdr->frame_control)) && 617 ieee80211_has_protected(hdr->frame_control)) { 618 skb_put(msdu, IEEE80211_CCMP_MIC_LEN); 619 } else if (!(skb_cb->flags & ATH10K_SKB_F_NO_HWCRYPT) && 620 txmode == ATH10K_HW_TXRX_RAW && 621 ieee80211_has_protected(hdr->frame_control)) { 622 skb_put(msdu, IEEE80211_CCMP_MIC_LEN); 623 } 624 625 skb_cb->paddr = dma_map_single(dev, msdu->data, msdu->len, 626 DMA_TO_DEVICE); 627 res = dma_mapping_error(dev, skb_cb->paddr); 628 if (res) { 629 res = -EIO; 630 goto err_free_msdu_id; 631 } 632 633 if (unlikely(info->flags & IEEE80211_TX_CTL_TX_OFFCHAN)) 634 freq = ar->scan.roc_freq; 635 636 switch (txmode) { 637 case ATH10K_HW_TXRX_RAW: 638 case ATH10K_HW_TXRX_NATIVE_WIFI: 639 flags0 |= HTT_DATA_TX_DESC_FLAGS0_MAC_HDR_PRESENT; 640 /* pass through */ 641 case ATH10K_HW_TXRX_ETHERNET: 642 if (ar->hw_params.continuous_frag_desc) { 643 memset(&htt->frag_desc.vaddr[msdu_id], 0, 644 sizeof(struct htt_msdu_ext_desc)); 645 frags = (struct htt_data_tx_desc_frag *) 646 &htt->frag_desc.vaddr[msdu_id].frags; 647 ext_desc = &htt->frag_desc.vaddr[msdu_id]; 648 frags[0].tword_addr.paddr_lo = 649 __cpu_to_le32(skb_cb->paddr); 650 frags[0].tword_addr.paddr_hi = 0; 651 frags[0].tword_addr.len_16 = __cpu_to_le16(msdu->len); 652 653 frags_paddr = htt->frag_desc.paddr + 654 (sizeof(struct htt_msdu_ext_desc) * msdu_id); 655 } else { 656 frags = txbuf->frags; 657 frags[0].dword_addr.paddr = 658 __cpu_to_le32(skb_cb->paddr); 659 frags[0].dword_addr.len = __cpu_to_le32(msdu->len); 660 frags[1].dword_addr.paddr = 0; 661 frags[1].dword_addr.len = 0; 662 663 frags_paddr = txbuf_paddr; 664 } 665 flags0 |= SM(txmode, HTT_DATA_TX_DESC_FLAGS0_PKT_TYPE); 666 break; 667 case ATH10K_HW_TXRX_MGMT: 668 flags0 |= SM(ATH10K_HW_TXRX_MGMT, 669 HTT_DATA_TX_DESC_FLAGS0_PKT_TYPE); 670 flags0 |= HTT_DATA_TX_DESC_FLAGS0_MAC_HDR_PRESENT; 671 672 frags_paddr = skb_cb->paddr; 673 break; 674 } 675 676 /* Normally all commands go through HTC which manages tx credits for 677 * each endpoint and notifies when tx is completed. 678 * 679 * HTT endpoint is creditless so there's no need to care about HTC 680 * flags. In that case it is trivial to fill the HTC header here. 681 * 682 * MSDU transmission is considered completed upon HTT event. This 683 * implies no relevant resources can be freed until after the event is 684 * received. That's why HTC tx completion handler itself is ignored by 685 * setting NULL to transfer_context for all sg items. 686 * 687 * There is simply no point in pushing HTT TX_FRM through HTC tx path 688 * as it's a waste of resources. By bypassing HTC it is possible to 689 * avoid extra memory allocations, compress data structures and thus 690 * improve performance. */ 691 692 txbuf->htc_hdr.eid = htt->eid; 693 txbuf->htc_hdr.len = __cpu_to_le16(sizeof(txbuf->cmd_hdr) + 694 sizeof(txbuf->cmd_tx) + 695 prefetch_len); 696 txbuf->htc_hdr.flags = 0; 697 698 if (skb_cb->flags & ATH10K_SKB_F_NO_HWCRYPT) 699 flags0 |= HTT_DATA_TX_DESC_FLAGS0_NO_ENCRYPT; 700 701 flags1 |= SM((u16)vdev_id, HTT_DATA_TX_DESC_FLAGS1_VDEV_ID); 702 flags1 |= SM((u16)tid, HTT_DATA_TX_DESC_FLAGS1_EXT_TID); 703 if (msdu->ip_summed == CHECKSUM_PARTIAL && 704 !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) { 705 flags1 |= HTT_DATA_TX_DESC_FLAGS1_CKSUM_L3_OFFLOAD; 706 flags1 |= HTT_DATA_TX_DESC_FLAGS1_CKSUM_L4_OFFLOAD; 707 if (ar->hw_params.continuous_frag_desc) 708 ext_desc->flags |= HTT_MSDU_CHECKSUM_ENABLE; 709 } 710 711 /* Prevent firmware from sending up tx inspection requests. There's 712 * nothing ath10k can do with frames requested for inspection so force 713 * it to simply rely a regular tx completion with discard status. 714 */ 715 flags1 |= HTT_DATA_TX_DESC_FLAGS1_POSTPONED; 716 717 txbuf->cmd_hdr.msg_type = HTT_H2T_MSG_TYPE_TX_FRM; 718 txbuf->cmd_tx.flags0 = flags0; 719 txbuf->cmd_tx.flags1 = __cpu_to_le16(flags1); 720 txbuf->cmd_tx.len = __cpu_to_le16(msdu->len); 721 txbuf->cmd_tx.id = __cpu_to_le16(msdu_id); 722 txbuf->cmd_tx.frags_paddr = __cpu_to_le32(frags_paddr); 723 if (ath10k_mac_tx_frm_has_freq(ar)) { 724 txbuf->cmd_tx.offchan_tx.peerid = 725 __cpu_to_le16(HTT_INVALID_PEERID); 726 txbuf->cmd_tx.offchan_tx.freq = 727 __cpu_to_le16(freq); 728 } else { 729 txbuf->cmd_tx.peerid = 730 __cpu_to_le32(HTT_INVALID_PEERID); 731 } 732 733 trace_ath10k_htt_tx(ar, msdu_id, msdu->len, vdev_id, tid); 734 ath10k_dbg(ar, ATH10K_DBG_HTT, 735 "htt tx flags0 %hhu flags1 %hu len %d id %hu frags_paddr %08x, msdu_paddr %08x vdev %hhu tid %hhu freq %hu\n", 736 flags0, flags1, msdu->len, msdu_id, frags_paddr, 737 (u32)skb_cb->paddr, vdev_id, tid, freq); 738 ath10k_dbg_dump(ar, ATH10K_DBG_HTT_DUMP, NULL, "htt tx msdu: ", 739 msdu->data, msdu->len); 740 trace_ath10k_tx_hdr(ar, msdu->data, msdu->len); 741 trace_ath10k_tx_payload(ar, msdu->data, msdu->len); 742 743 sg_items[0].transfer_id = 0; 744 sg_items[0].transfer_context = NULL; 745 sg_items[0].vaddr = &txbuf->htc_hdr; 746 sg_items[0].paddr = txbuf_paddr + 747 sizeof(txbuf->frags); 748 sg_items[0].len = sizeof(txbuf->htc_hdr) + 749 sizeof(txbuf->cmd_hdr) + 750 sizeof(txbuf->cmd_tx); 751 752 sg_items[1].transfer_id = 0; 753 sg_items[1].transfer_context = NULL; 754 sg_items[1].vaddr = msdu->data; 755 sg_items[1].paddr = skb_cb->paddr; 756 sg_items[1].len = prefetch_len; 757 758 res = ath10k_hif_tx_sg(htt->ar, 759 htt->ar->htc.endpoint[htt->eid].ul_pipe_id, 760 sg_items, ARRAY_SIZE(sg_items)); 761 if (res) 762 goto err_unmap_msdu; 763 764 return 0; 765 766 err_unmap_msdu: 767 dma_unmap_single(dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE); 768 err_free_msdu_id: 769 spin_lock_bh(&htt->tx_lock); 770 ath10k_htt_tx_free_msdu_id(htt, msdu_id); 771 spin_unlock_bh(&htt->tx_lock); 772 err_tx_dec: 773 ath10k_htt_tx_dec_pending(htt, limit_mgmt_desc); 774 err: 775 return res; 776 } 777