htt_tx.c 19.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * Copyright (c) 2005-2011 Atheros Communications Inc.
 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <linux/etherdevice.h>
#include "htt.h"
#include "mac.h"
#include "hif.h"
#include "txrx.h"
#include "debug.h"

25
void __ath10k_htt_tx_dec_pending(struct ath10k_htt *htt, bool limit_mgmt_desc)
26
{
27 28 29
	if (limit_mgmt_desc)
		htt->num_pending_mgmt_tx--;

30 31
	htt->num_pending_tx--;
	if (htt->num_pending_tx == htt->max_num_pending_tx - 1)
M
Michal Kazior 已提交
32
		ath10k_mac_tx_unlock(htt->ar, ATH10K_TX_PAUSE_Q_FULL);
33 34
}

35 36
static void ath10k_htt_tx_dec_pending(struct ath10k_htt *htt,
				      bool limit_mgmt_desc)
37 38
{
	spin_lock_bh(&htt->tx_lock);
39
	__ath10k_htt_tx_dec_pending(htt, limit_mgmt_desc);
40 41 42
	spin_unlock_bh(&htt->tx_lock);
}

43 44
static int ath10k_htt_tx_inc_pending(struct ath10k_htt *htt,
				     bool limit_mgmt_desc, bool is_probe_resp)
45
{
46
	struct ath10k *ar = htt->ar;
47 48 49 50 51 52 53 54 55
	int ret = 0;

	spin_lock_bh(&htt->tx_lock);

	if (htt->num_pending_tx >= htt->max_num_pending_tx) {
		ret = -EBUSY;
		goto exit;
	}

56 57 58 59 60 61 62 63 64
	if (limit_mgmt_desc) {
		if (is_probe_resp && (htt->num_pending_mgmt_tx >
		    ar->hw_params.max_probe_resp_desc_thres)) {
			ret = -EBUSY;
			goto exit;
		}
		htt->num_pending_mgmt_tx++;
	}

65 66
	htt->num_pending_tx++;
	if (htt->num_pending_tx == htt->max_num_pending_tx)
M
Michal Kazior 已提交
67
		ath10k_mac_tx_lock(htt->ar, ATH10K_TX_PAUSE_Q_FULL);
68 69 70 71 72 73

exit:
	spin_unlock_bh(&htt->tx_lock);
	return ret;
}

M
Michal Kazior 已提交
74
int ath10k_htt_tx_alloc_msdu_id(struct ath10k_htt *htt, struct sk_buff *skb)
75
{
76
	struct ath10k *ar = htt->ar;
M
Michal Kazior 已提交
77
	int ret;
78 79 80

	lockdep_assert_held(&htt->tx_lock);

81 82
	ret = idr_alloc(&htt->pending_tx, skb, 0,
			htt->max_num_pending_tx, GFP_ATOMIC);
M
Michal Kazior 已提交
83 84

	ath10k_dbg(ar, ATH10K_DBG_HTT, "htt tx alloc msdu_id %d\n", ret);
85

M
Michal Kazior 已提交
86
	return ret;
87 88 89 90
}

void ath10k_htt_tx_free_msdu_id(struct ath10k_htt *htt, u16 msdu_id)
{
91 92
	struct ath10k *ar = htt->ar;

93 94
	lockdep_assert_held(&htt->tx_lock);

95
	ath10k_dbg(ar, ATH10K_DBG_HTT, "htt tx free msdu_id %hu\n", msdu_id);
M
Michal Kazior 已提交
96 97

	idr_remove(&htt->pending_tx, msdu_id);
98 99
}

M
Michal Kazior 已提交
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 107
		   htt->max_num_pending_tx);

M
Michal Kazior 已提交
108 109
	spin_lock_init(&htt->tx_lock);
	idr_init(&htt->pending_tx);
110

111 112 113
	htt->tx_pool = dma_pool_create("ath10k htt tx pool", htt->ar->dev,
				       sizeof(struct ath10k_htt_txbuf), 4, 0);
	if (!htt->tx_pool) {
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
		ret = -ENOMEM;
		goto free_idr_pending_tx;
	}

	if (!ar->hw_params.continuous_frag_desc)
		goto skip_frag_desc_alloc;

	size = htt->max_num_pending_tx * sizeof(struct htt_msdu_ext_desc);
	htt->frag_desc.vaddr = dma_alloc_coherent(ar->dev, size,
						  &htt->frag_desc.paddr,
						  GFP_DMA);
	if (!htt->frag_desc.vaddr) {
		ath10k_warn(ar, "failed to alloc fragment desc memory\n");
		ret = -ENOMEM;
		goto free_tx_pool;
129 130
	}

131
skip_frag_desc_alloc:
132
	return 0;
133 134 135 136 137 138

free_tx_pool:
	dma_pool_destroy(htt->tx_pool);
free_idr_pending_tx:
	idr_destroy(&htt->pending_tx);
	return ret;
139 140
}

M
Michal Kazior 已提交
141
static int ath10k_htt_tx_clean_up_pending(int msdu_id, void *skb, void *ctx)
142
{
M
Michal Kazior 已提交
143 144
	struct ath10k *ar = ctx;
	struct ath10k_htt *htt = &ar->htt;
145
	struct htt_tx_done tx_done = {0};
146

M
Michal Kazior 已提交
147
	ath10k_dbg(ar, ATH10K_DBG_HTT, "force cleanup msdu_id %hu\n", msdu_id);
148

M
Michal Kazior 已提交
149 150
	tx_done.discard = 1;
	tx_done.msdu_id = msdu_id;
151

M
Michal Kazior 已提交
152 153 154
	ath10k_txrx_tx_unref(htt, &tx_done);

	return 0;
155 156
}

M
Michal Kazior 已提交
157
void ath10k_htt_tx_free(struct ath10k_htt *htt)
158
{
159 160
	int size;

M
Michal Kazior 已提交
161 162
	idr_for_each(&htt->pending_tx, ath10k_htt_tx_clean_up_pending, htt->ar);
	idr_destroy(&htt->pending_tx);
163
	dma_pool_destroy(htt->tx_pool);
164 165 166 167 168 169 170

	if (htt->frag_desc.vaddr) {
		size = htt->max_num_pending_tx *
				  sizeof(struct htt_msdu_ext_desc);
		dma_free_coherent(htt->ar->dev, size, htt->frag_desc.vaddr,
				  htt->frag_desc.paddr);
	}
171 172 173 174
}

void ath10k_htt_htc_tx_complete(struct ath10k *ar, struct sk_buff *skb)
{
175
	dev_kfree_skb_any(skb);
176 177 178 179
}

int ath10k_htt_h2t_ver_req_msg(struct ath10k_htt *htt)
{
180
	struct ath10k *ar = htt->ar;
181 182 183 184 185 186 187 188
	struct sk_buff *skb;
	struct htt_cmd *cmd;
	int len = 0;
	int ret;

	len += sizeof(cmd->hdr);
	len += sizeof(cmd->ver_req);

189
	skb = ath10k_htc_alloc_skb(ar, len);
190 191 192 193 194 195 196
	if (!skb)
		return -ENOMEM;

	skb_put(skb, len);
	cmd = (struct htt_cmd *)skb->data;
	cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_VERSION_REQ;

197
	ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb);
198 199 200 201 202 203 204 205
	if (ret) {
		dev_kfree_skb_any(skb);
		return ret;
	}

	return 0;
}

206 207
int ath10k_htt_h2t_stats_req(struct ath10k_htt *htt, u8 mask, u64 cookie)
{
208
	struct ath10k *ar = htt->ar;
209 210 211 212 213 214 215 216
	struct htt_stats_req *req;
	struct sk_buff *skb;
	struct htt_cmd *cmd;
	int len = 0, ret;

	len += sizeof(cmd->hdr);
	len += sizeof(cmd->stats_req);

217
	skb = ath10k_htc_alloc_skb(ar, len);
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
	if (!skb)
		return -ENOMEM;

	skb_put(skb, len);
	cmd = (struct htt_cmd *)skb->data;
	cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_STATS_REQ;

	req = &cmd->stats_req;

	memset(req, 0, sizeof(*req));

	/* currently we support only max 8 bit masks so no need to worry
	 * about endian support */
	req->upload_types[0] = mask;
	req->reset_types[0] = mask;
	req->stat_type = HTT_STATS_REQ_CFG_STAT_TYPE_INVALID;
	req->cookie_lsb = cpu_to_le32(cookie & 0xffffffff);
	req->cookie_msb = cpu_to_le32((cookie & 0xffffffff00000000ULL) >> 32);

	ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb);
	if (ret) {
239 240
		ath10k_warn(ar, "failed to send htt type stats request: %d",
			    ret);
241 242 243 244 245 246 247
		dev_kfree_skb_any(skb);
		return ret;
	}

	return 0;
}

248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
int ath10k_htt_send_frag_desc_bank_cfg(struct ath10k_htt *htt)
{
	struct ath10k *ar = htt->ar;
	struct sk_buff *skb;
	struct htt_cmd *cmd;
	int ret, size;

	if (!ar->hw_params.continuous_frag_desc)
		return 0;

	if (!htt->frag_desc.paddr) {
		ath10k_warn(ar, "invalid frag desc memory\n");
		return -EINVAL;
	}

	size = sizeof(cmd->hdr) + sizeof(cmd->frag_desc_bank_cfg);
	skb = ath10k_htc_alloc_skb(ar, size);
	if (!skb)
		return -ENOMEM;

	skb_put(skb, size);
	cmd = (struct htt_cmd *)skb->data;
	cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_FRAG_DESC_BANK_CFG;
	cmd->frag_desc_bank_cfg.info = 0;
	cmd->frag_desc_bank_cfg.num_banks = 1;
	cmd->frag_desc_bank_cfg.desc_size = sizeof(struct htt_msdu_ext_desc);
	cmd->frag_desc_bank_cfg.bank_base_addrs[0] =
				__cpu_to_le32(htt->frag_desc.paddr);
276
	cmd->frag_desc_bank_cfg.bank_id[0].bank_min_id = 0;
277 278 279 280 281 282 283 284 285 286 287 288 289 290
	cmd->frag_desc_bank_cfg.bank_id[0].bank_max_id =
				__cpu_to_le16(htt->max_num_pending_tx - 1);

	ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb);
	if (ret) {
		ath10k_warn(ar, "failed to send frag desc bank cfg request: %d\n",
			    ret);
		dev_kfree_skb_any(skb);
		return ret;
	}

	return 0;
}

291 292
int ath10k_htt_send_rx_ring_cfg_ll(struct ath10k_htt *htt)
{
293
	struct ath10k *ar = htt->ar;
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
	struct sk_buff *skb;
	struct htt_cmd *cmd;
	struct htt_rx_ring_setup_ring *ring;
	const int num_rx_ring = 1;
	u16 flags;
	u32 fw_idx;
	int len;
	int ret;

	/*
	 * the HW expects the buffer to be an integral number of 4-byte
	 * "words"
	 */
	BUILD_BUG_ON(!IS_ALIGNED(HTT_RX_BUF_SIZE, 4));
	BUILD_BUG_ON((HTT_RX_BUF_SIZE & HTT_MAX_CACHE_LINE_SIZE_MASK) != 0);

	len = sizeof(cmd->hdr) + sizeof(cmd->rx_setup.hdr)
	    + (sizeof(*ring) * num_rx_ring);
312
	skb = ath10k_htc_alloc_skb(ar, len);
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
	if (!skb)
		return -ENOMEM;

	skb_put(skb, len);

	cmd = (struct htt_cmd *)skb->data;
	ring = &cmd->rx_setup.rings[0];

	cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_RX_RING_CFG;
	cmd->rx_setup.hdr.num_rings = 1;

	/* FIXME: do we need all of this? */
	flags = 0;
	flags |= HTT_RX_RING_FLAGS_MAC80211_HDR;
	flags |= HTT_RX_RING_FLAGS_MSDU_PAYLOAD;
	flags |= HTT_RX_RING_FLAGS_PPDU_START;
	flags |= HTT_RX_RING_FLAGS_PPDU_END;
	flags |= HTT_RX_RING_FLAGS_MPDU_START;
	flags |= HTT_RX_RING_FLAGS_MPDU_END;
	flags |= HTT_RX_RING_FLAGS_MSDU_START;
	flags |= HTT_RX_RING_FLAGS_MSDU_END;
	flags |= HTT_RX_RING_FLAGS_RX_ATTENTION;
	flags |= HTT_RX_RING_FLAGS_FRAG_INFO;
	flags |= HTT_RX_RING_FLAGS_UNICAST_RX;
	flags |= HTT_RX_RING_FLAGS_MULTICAST_RX;
	flags |= HTT_RX_RING_FLAGS_CTRL_RX;
	flags |= HTT_RX_RING_FLAGS_MGMT_RX;
	flags |= HTT_RX_RING_FLAGS_NULL_RX;
	flags |= HTT_RX_RING_FLAGS_PHY_DATA_RX;

	fw_idx = __le32_to_cpu(*htt->rx_ring.alloc_idx.vaddr);

	ring->fw_idx_shadow_reg_paddr =
		__cpu_to_le32(htt->rx_ring.alloc_idx.paddr);
	ring->rx_ring_base_paddr = __cpu_to_le32(htt->rx_ring.base_paddr);
	ring->rx_ring_len = __cpu_to_le16(htt->rx_ring.size);
	ring->rx_ring_bufsize = __cpu_to_le16(HTT_RX_BUF_SIZE);
	ring->flags = __cpu_to_le16(flags);
	ring->fw_idx_init_val = __cpu_to_le16(fw_idx);

#define desc_offset(x) (offsetof(struct htt_rx_desc, x) / 4)

	ring->mac80211_hdr_offset = __cpu_to_le16(desc_offset(rx_hdr_status));
	ring->msdu_payload_offset = __cpu_to_le16(desc_offset(msdu_payload));
	ring->ppdu_start_offset = __cpu_to_le16(desc_offset(ppdu_start));
	ring->ppdu_end_offset = __cpu_to_le16(desc_offset(ppdu_end));
	ring->mpdu_start_offset = __cpu_to_le16(desc_offset(mpdu_start));
	ring->mpdu_end_offset = __cpu_to_le16(desc_offset(mpdu_end));
	ring->msdu_start_offset = __cpu_to_le16(desc_offset(msdu_start));
	ring->msdu_end_offset = __cpu_to_le16(desc_offset(msdu_end));
	ring->rx_attention_offset = __cpu_to_le16(desc_offset(attention));
	ring->frag_info_offset = __cpu_to_le16(desc_offset(frag_info));

#undef desc_offset

368
	ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb);
369 370 371 372 373 374 375 376
	if (ret) {
		dev_kfree_skb_any(skb);
		return ret;
	}

	return 0;
}

377 378 379 380
int ath10k_htt_h2t_aggr_cfg_msg(struct ath10k_htt *htt,
				u8 max_subfrms_ampdu,
				u8 max_subfrms_amsdu)
{
381
	struct ath10k *ar = htt->ar;
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
	struct htt_aggr_conf *aggr_conf;
	struct sk_buff *skb;
	struct htt_cmd *cmd;
	int len;
	int ret;

	/* Firmware defaults are: amsdu = 3 and ampdu = 64 */

	if (max_subfrms_ampdu == 0 || max_subfrms_ampdu > 64)
		return -EINVAL;

	if (max_subfrms_amsdu == 0 || max_subfrms_amsdu > 31)
		return -EINVAL;

	len = sizeof(cmd->hdr);
	len += sizeof(cmd->aggr_conf);

399
	skb = ath10k_htc_alloc_skb(ar, len);
400 401 402 403 404 405 406 407 408 409 410
	if (!skb)
		return -ENOMEM;

	skb_put(skb, len);
	cmd = (struct htt_cmd *)skb->data;
	cmd->hdr.msg_type = HTT_H2T_MSG_TYPE_AGGR_CFG;

	aggr_conf = &cmd->aggr_conf;
	aggr_conf->max_num_ampdu_subframes = max_subfrms_ampdu;
	aggr_conf->max_num_amsdu_subframes = max_subfrms_amsdu;

411
	ath10k_dbg(ar, ATH10K_DBG_HTT, "htt h2t aggr cfg msg amsdu %d ampdu %d",
412 413 414 415 416 417 418 419 420 421 422 423
		   aggr_conf->max_num_amsdu_subframes,
		   aggr_conf->max_num_ampdu_subframes);

	ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb);
	if (ret) {
		dev_kfree_skb_any(skb);
		return ret;
	}

	return 0;
}

424 425
int ath10k_htt_mgmt_tx(struct ath10k_htt *htt, struct sk_buff *msdu)
{
426 427
	struct ath10k *ar = htt->ar;
	struct device *dev = ar->dev;
428 429
	struct sk_buff *txdesc = NULL;
	struct htt_cmd *cmd;
430
	struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(msdu);
431
	u8 vdev_id = skb_cb->vdev_id;
432 433 434
	int len = 0;
	int msdu_id = -1;
	int res;
435 436 437 438 439 440 441 442 443 444 445 446
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)msdu->data;
	bool limit_mgmt_desc = false;
	bool is_probe_resp = false;

	if (ar->hw_params.max_probe_resp_desc_thres) {
		limit_mgmt_desc = true;

		if (ieee80211_is_probe_resp(hdr->frame_control))
			is_probe_resp = true;
	}

	res = ath10k_htt_tx_inc_pending(htt, limit_mgmt_desc, is_probe_resp);
447 448

	if (res)
M
Michal Kazior 已提交
449
		goto err;
450 451 452 453 454

	len += sizeof(cmd->hdr);
	len += sizeof(cmd->mgmt_tx);

	spin_lock_bh(&htt->tx_lock);
M
Michal Kazior 已提交
455
	res = ath10k_htt_tx_alloc_msdu_id(htt, msdu);
456
	spin_unlock_bh(&htt->tx_lock);
K
Kalle Valo 已提交
457
	if (res < 0)
M
Michal Kazior 已提交
458
		goto err_tx_dec;
K
Kalle Valo 已提交
459

M
Michal Kazior 已提交
460
	msdu_id = res;
461

462
	txdesc = ath10k_htc_alloc_skb(ar, len);
M
Michal Kazior 已提交
463 464 465 466 467
	if (!txdesc) {
		res = -ENOMEM;
		goto err_free_msdu_id;
	}

468 469 470
	skb_cb->paddr = dma_map_single(dev, msdu->data, msdu->len,
				       DMA_TO_DEVICE);
	res = dma_mapping_error(dev, skb_cb->paddr);
471 472
	if (res) {
		res = -EIO;
M
Michal Kazior 已提交
473
		goto err_free_txdesc;
474
	}
475 476 477

	skb_put(txdesc, len);
	cmd = (struct htt_cmd *)txdesc->data;
478 479
	memset(cmd, 0, len);

480 481 482 483 484 485 486 487
	cmd->hdr.msg_type         = HTT_H2T_MSG_TYPE_MGMT_TX;
	cmd->mgmt_tx.msdu_paddr = __cpu_to_le32(ATH10K_SKB_CB(msdu)->paddr);
	cmd->mgmt_tx.len        = __cpu_to_le32(msdu->len);
	cmd->mgmt_tx.desc_id    = __cpu_to_le32(msdu_id);
	cmd->mgmt_tx.vdev_id    = __cpu_to_le32(vdev_id);
	memcpy(cmd->mgmt_tx.hdr, msdu->data,
	       min_t(int, msdu->len, HTT_MGMT_FRM_HDR_DOWNLOAD_LEN));

488
	skb_cb->htt.txbuf = NULL;
489

490
	res = ath10k_htc_send(&htt->ar->htc, htt->eid, txdesc);
491
	if (res)
M
Michal Kazior 已提交
492
		goto err_unmap_msdu;
493 494 495

	return 0;

M
Michal Kazior 已提交
496
err_unmap_msdu:
497
	dma_unmap_single(dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE);
M
Michal Kazior 已提交
498 499 500 501 502 503 504
err_free_txdesc:
	dev_kfree_skb_any(txdesc);
err_free_msdu_id:
	spin_lock_bh(&htt->tx_lock);
	ath10k_htt_tx_free_msdu_id(htt, msdu_id);
	spin_unlock_bh(&htt->tx_lock);
err_tx_dec:
505
	ath10k_htt_tx_dec_pending(htt, limit_mgmt_desc);
M
Michal Kazior 已提交
506
err:
507 508 509 510 511
	return res;
}

int ath10k_htt_tx(struct ath10k_htt *htt, struct sk_buff *msdu)
{
512 513
	struct ath10k *ar = htt->ar;
	struct device *dev = ar->dev;
514
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)msdu->data;
515
	struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(msdu);
516 517 518 519 520
	struct ath10k_hif_sg_item sg_items[2];
	struct htt_data_tx_desc_frag *frags;
	u8 vdev_id = skb_cb->vdev_id;
	u8 tid = skb_cb->htt.tid;
	int prefetch_len;
521
	int res;
522 523
	u8 flags0 = 0;
	u16 msdu_id, flags1 = 0;
524 525
	dma_addr_t paddr = 0;
	u32 frags_paddr = 0;
526
	struct htt_msdu_ext_desc *ext_desc = NULL;
527 528 529 530 531 532 533 534 535 536
	bool limit_mgmt_desc = false;
	bool is_probe_resp = false;

	if (unlikely(ieee80211_is_mgmt(hdr->frame_control)) &&
	    ar->hw_params.max_probe_resp_desc_thres) {
		limit_mgmt_desc = true;

		if (ieee80211_is_probe_resp(hdr->frame_control))
			is_probe_resp = true;
	}
537

538
	res = ath10k_htt_tx_inc_pending(htt, limit_mgmt_desc, is_probe_resp);
539
	if (res)
M
Michal Kazior 已提交
540 541 542
		goto err;

	spin_lock_bh(&htt->tx_lock);
M
Michal Kazior 已提交
543
	res = ath10k_htt_tx_alloc_msdu_id(htt, msdu);
544
	spin_unlock_bh(&htt->tx_lock);
K
Kalle Valo 已提交
545
	if (res < 0)
M
Michal Kazior 已提交
546
		goto err_tx_dec;
K
Kalle Valo 已提交
547

M
Michal Kazior 已提交
548
	msdu_id = res;
549 550 551 552

	prefetch_len = min(htt->prefetch_len, msdu->len);
	prefetch_len = roundup(prefetch_len, 4);

553 554
	skb_cb->htt.txbuf = dma_pool_alloc(htt->tx_pool, GFP_ATOMIC,
					   &paddr);
J
Julia Lawall 已提交
555 556
	if (!skb_cb->htt.txbuf) {
		res = -ENOMEM;
557
		goto err_free_msdu_id;
J
Julia Lawall 已提交
558
	}
559
	skb_cb->htt.txbuf_paddr = paddr;
560

561 562 563
	if ((ieee80211_is_action(hdr->frame_control) ||
	     ieee80211_is_deauth(hdr->frame_control) ||
	     ieee80211_is_disassoc(hdr->frame_control)) &&
564
	     ieee80211_has_protected(hdr->frame_control)) {
565
		skb_put(msdu, IEEE80211_CCMP_MIC_LEN);
566
	} else if (!skb_cb->htt.nohwcrypt &&
567 568
		   skb_cb->txmode == ATH10K_HW_TXRX_RAW &&
		   ieee80211_has_protected(hdr->frame_control)) {
569 570
		skb_put(msdu, IEEE80211_CCMP_MIC_LEN);
	}
571

572 573 574
	skb_cb->paddr = dma_map_single(dev, msdu->data, msdu->len,
				       DMA_TO_DEVICE);
	res = dma_mapping_error(dev, skb_cb->paddr);
575 576
	if (res) {
		res = -EIO;
577
		goto err_free_txbuf;
578
	}
579

580 581 582 583 584 585
	switch (skb_cb->txmode) {
	case ATH10K_HW_TXRX_RAW:
	case ATH10K_HW_TXRX_NATIVE_WIFI:
		flags0 |= HTT_DATA_TX_DESC_FLAGS0_MAC_HDR_PRESENT;
		/* pass through */
	case ATH10K_HW_TXRX_ETHERNET:
586
		if (ar->hw_params.continuous_frag_desc) {
587 588
			memset(&htt->frag_desc.vaddr[msdu_id], 0,
			       sizeof(struct htt_msdu_ext_desc));
589 590
			frags = (struct htt_data_tx_desc_frag *)
				&htt->frag_desc.vaddr[msdu_id].frags;
591
			ext_desc = &htt->frag_desc.vaddr[msdu_id];
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
			frags[0].tword_addr.paddr_lo =
				__cpu_to_le32(skb_cb->paddr);
			frags[0].tword_addr.paddr_hi = 0;
			frags[0].tword_addr.len_16 = __cpu_to_le16(msdu->len);

			frags_paddr =  htt->frag_desc.paddr +
				(sizeof(struct htt_msdu_ext_desc) * msdu_id);
		} else {
			frags = skb_cb->htt.txbuf->frags;
			frags[0].dword_addr.paddr =
				__cpu_to_le32(skb_cb->paddr);
			frags[0].dword_addr.len = __cpu_to_le32(msdu->len);
			frags[1].dword_addr.paddr = 0;
			frags[1].dword_addr.len = 0;

			frags_paddr = skb_cb->htt.txbuf_paddr;
		}
609 610 611
		flags0 |= SM(skb_cb->txmode, HTT_DATA_TX_DESC_FLAGS0_PKT_TYPE);
		break;
	case ATH10K_HW_TXRX_MGMT:
612 613
		flags0 |= SM(ATH10K_HW_TXRX_MGMT,
			     HTT_DATA_TX_DESC_FLAGS0_PKT_TYPE);
614
		flags0 |= HTT_DATA_TX_DESC_FLAGS0_MAC_HDR_PRESENT;
615

616
		frags_paddr = skb_cb->paddr;
617
		break;
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
	}

	/* Normally all commands go through HTC which manages tx credits for
	 * each endpoint and notifies when tx is completed.
	 *
	 * HTT endpoint is creditless so there's no need to care about HTC
	 * flags. In that case it is trivial to fill the HTC header here.
	 *
	 * MSDU transmission is considered completed upon HTT event. This
	 * implies no relevant resources can be freed until after the event is
	 * received. That's why HTC tx completion handler itself is ignored by
	 * setting NULL to transfer_context for all sg items.
	 *
	 * There is simply no point in pushing HTT TX_FRM through HTC tx path
	 * as it's a waste of resources. By bypassing HTC it is possible to
	 * avoid extra memory allocations, compress data structures and thus
	 * improve performance. */

	skb_cb->htt.txbuf->htc_hdr.eid = htt->eid;
	skb_cb->htt.txbuf->htc_hdr.len = __cpu_to_le16(
			sizeof(skb_cb->htt.txbuf->cmd_hdr) +
			sizeof(skb_cb->htt.txbuf->cmd_tx) +
			prefetch_len);
	skb_cb->htt.txbuf->htc_hdr.flags = 0;
642

643 644 645
	if (skb_cb->htt.nohwcrypt)
		flags0 |= HTT_DATA_TX_DESC_FLAGS0_NO_ENCRYPT;

646
	if (!skb_cb->is_protected)
647
		flags0 |= HTT_DATA_TX_DESC_FLAGS0_NO_ENCRYPT;
M
Michal Kazior 已提交
648

649 650
	flags1 |= SM((u16)vdev_id, HTT_DATA_TX_DESC_FLAGS1_VDEV_ID);
	flags1 |= SM((u16)tid, HTT_DATA_TX_DESC_FLAGS1_EXT_TID);
651 652
	if (msdu->ip_summed == CHECKSUM_PARTIAL &&
	    !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
653 654
		flags1 |= HTT_DATA_TX_DESC_FLAGS1_CKSUM_L3_OFFLOAD;
		flags1 |= HTT_DATA_TX_DESC_FLAGS1_CKSUM_L4_OFFLOAD;
655 656
		if (ar->hw_params.continuous_frag_desc)
			ext_desc->flags |= HTT_MSDU_CHECKSUM_ENABLE;
657
	}
658

659 660 661 662 663 664
	/* Prevent firmware from sending up tx inspection requests. There's
	 * nothing ath10k can do with frames requested for inspection so force
	 * it to simply rely a regular tx completion with discard status.
	 */
	flags1 |= HTT_DATA_TX_DESC_FLAGS1_POSTPONED;

665 666 667 668 669 670
	skb_cb->htt.txbuf->cmd_hdr.msg_type = HTT_H2T_MSG_TYPE_TX_FRM;
	skb_cb->htt.txbuf->cmd_tx.flags0 = flags0;
	skb_cb->htt.txbuf->cmd_tx.flags1 = __cpu_to_le16(flags1);
	skb_cb->htt.txbuf->cmd_tx.len = __cpu_to_le16(msdu->len);
	skb_cb->htt.txbuf->cmd_tx.id = __cpu_to_le16(msdu_id);
	skb_cb->htt.txbuf->cmd_tx.frags_paddr = __cpu_to_le32(frags_paddr);
M
Michal Kazior 已提交
671 672
	skb_cb->htt.txbuf->cmd_tx.peerid = __cpu_to_le16(HTT_INVALID_PEERID);
	skb_cb->htt.txbuf->cmd_tx.freq = __cpu_to_le16(skb_cb->htt.freq);
673

674
	trace_ath10k_htt_tx(ar, msdu_id, msdu->len, vdev_id, tid);
675
	ath10k_dbg(ar, ATH10K_DBG_HTT,
M
Michal Kazior 已提交
676
		   "htt tx flags0 %hhu flags1 %hu len %d id %hu frags_paddr %08x, msdu_paddr %08x vdev %hhu tid %hhu freq %hu\n",
677
		   flags0, flags1, msdu->len, msdu_id, frags_paddr,
M
Michal Kazior 已提交
678
		   (u32)skb_cb->paddr, vdev_id, tid, skb_cb->htt.freq);
679
	ath10k_dbg_dump(ar, ATH10K_DBG_HTT_DUMP, NULL, "htt tx msdu: ",
680
			msdu->data, msdu->len);
681 682
	trace_ath10k_tx_hdr(ar, msdu->data, msdu->len);
	trace_ath10k_tx_payload(ar, msdu->data, msdu->len);
683

684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
	sg_items[0].transfer_id = 0;
	sg_items[0].transfer_context = NULL;
	sg_items[0].vaddr = &skb_cb->htt.txbuf->htc_hdr;
	sg_items[0].paddr = skb_cb->htt.txbuf_paddr +
			    sizeof(skb_cb->htt.txbuf->frags);
	sg_items[0].len = sizeof(skb_cb->htt.txbuf->htc_hdr) +
			  sizeof(skb_cb->htt.txbuf->cmd_hdr) +
			  sizeof(skb_cb->htt.txbuf->cmd_tx);

	sg_items[1].transfer_id = 0;
	sg_items[1].transfer_context = NULL;
	sg_items[1].vaddr = msdu->data;
	sg_items[1].paddr = skb_cb->paddr;
	sg_items[1].len = prefetch_len;

	res = ath10k_hif_tx_sg(htt->ar,
			       htt->ar->htc.endpoint[htt->eid].ul_pipe_id,
			       sg_items, ARRAY_SIZE(sg_items));
702
	if (res)
703
		goto err_unmap_msdu;
704 705

	return 0;
M
Michal Kazior 已提交
706 707

err_unmap_msdu:
708
	dma_unmap_single(dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE);
709 710 711 712
err_free_txbuf:
	dma_pool_free(htt->tx_pool,
		      skb_cb->htt.txbuf,
		      skb_cb->htt.txbuf_paddr);
M
Michal Kazior 已提交
713 714 715 716 717
err_free_msdu_id:
	spin_lock_bh(&htt->tx_lock);
	ath10k_htt_tx_free_msdu_id(htt, msdu_id);
	spin_unlock_bh(&htt->tx_lock);
err_tx_dec:
718
	ath10k_htt_tx_dec_pending(htt, limit_mgmt_desc);
M
Michal Kazior 已提交
719
err:
720 721
	return res;
}