htt_tx.c 16.0 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 25 26 27 28
/*
 * 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"

void __ath10k_htt_tx_dec_pending(struct ath10k_htt *htt)
{
	htt->num_pending_tx--;
	if (htt->num_pending_tx == htt->max_num_pending_tx - 1)
M
Michal Kazior 已提交
29
		ath10k_mac_tx_unlock(htt->ar, ATH10K_TX_PAUSE_Q_FULL);
30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
}

static void ath10k_htt_tx_dec_pending(struct ath10k_htt *htt)
{
	spin_lock_bh(&htt->tx_lock);
	__ath10k_htt_tx_dec_pending(htt);
	spin_unlock_bh(&htt->tx_lock);
}

static int ath10k_htt_tx_inc_pending(struct ath10k_htt *htt)
{
	int ret = 0;

	spin_lock_bh(&htt->tx_lock);

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

	htt->num_pending_tx++;
	if (htt->num_pending_tx == htt->max_num_pending_tx)
M
Michal Kazior 已提交
52
		ath10k_mac_tx_lock(htt->ar, ATH10K_TX_PAUSE_Q_FULL);
53 54 55 56 57 58

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

M
Michal Kazior 已提交
59
int ath10k_htt_tx_alloc_msdu_id(struct ath10k_htt *htt, struct sk_buff *skb)
60
{
61
	struct ath10k *ar = htt->ar;
M
Michal Kazior 已提交
62
	int ret;
63 64 65

	lockdep_assert_held(&htt->tx_lock);

M
Michal Kazior 已提交
66 67 68
	ret = idr_alloc(&htt->pending_tx, skb, 0, 0x10000, GFP_ATOMIC);

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

M
Michal Kazior 已提交
70
	return ret;
71 72 73 74
}

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

77 78
	lockdep_assert_held(&htt->tx_lock);

79
	ath10k_dbg(ar, ATH10K_DBG_HTT, "htt tx free msdu_id %hu\n", msdu_id);
M
Michal Kazior 已提交
80 81

	idr_remove(&htt->pending_tx, msdu_id);
82 83
}

M
Michal Kazior 已提交
84
int ath10k_htt_tx_alloc(struct ath10k_htt *htt)
85
{
86 87 88
	struct ath10k *ar = htt->ar;

	ath10k_dbg(ar, ATH10K_DBG_BOOT, "htt tx max num pending tx %d\n",
89 90
		   htt->max_num_pending_tx);

M
Michal Kazior 已提交
91 92
	spin_lock_init(&htt->tx_lock);
	idr_init(&htt->pending_tx);
93

94 95 96
	htt->tx_pool = dma_pool_create("ath10k htt tx pool", htt->ar->dev,
				       sizeof(struct ath10k_htt_txbuf), 4, 0);
	if (!htt->tx_pool) {
M
Michal Kazior 已提交
97
		idr_destroy(&htt->pending_tx);
98 99 100
		return -ENOMEM;
	}

101 102 103
	return 0;
}

M
Michal Kazior 已提交
104
static int ath10k_htt_tx_clean_up_pending(int msdu_id, void *skb, void *ctx)
105
{
M
Michal Kazior 已提交
106 107
	struct ath10k *ar = ctx;
	struct ath10k_htt *htt = &ar->htt;
108
	struct htt_tx_done tx_done = {0};
109

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

M
Michal Kazior 已提交
112 113
	tx_done.discard = 1;
	tx_done.msdu_id = msdu_id;
114

M
Michal Kazior 已提交
115 116
	spin_lock_bh(&htt->tx_lock);
	ath10k_txrx_tx_unref(htt, &tx_done);
117
	spin_unlock_bh(&htt->tx_lock);
M
Michal Kazior 已提交
118 119

	return 0;
120 121
}

M
Michal Kazior 已提交
122
void ath10k_htt_tx_free(struct ath10k_htt *htt)
123
{
M
Michal Kazior 已提交
124 125
	idr_for_each(&htt->pending_tx, ath10k_htt_tx_clean_up_pending, htt->ar);
	idr_destroy(&htt->pending_tx);
126
	dma_pool_destroy(htt->tx_pool);
127 128 129 130
}

void ath10k_htt_htc_tx_complete(struct ath10k *ar, struct sk_buff *skb)
{
131
	dev_kfree_skb_any(skb);
132 133 134 135
}

int ath10k_htt_h2t_ver_req_msg(struct ath10k_htt *htt)
{
136
	struct ath10k *ar = htt->ar;
137 138 139 140 141 142 143 144
	struct sk_buff *skb;
	struct htt_cmd *cmd;
	int len = 0;
	int ret;

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

145
	skb = ath10k_htc_alloc_skb(ar, len);
146 147 148 149 150 151 152
	if (!skb)
		return -ENOMEM;

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

153
	ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb);
154 155 156 157 158 159 160 161
	if (ret) {
		dev_kfree_skb_any(skb);
		return ret;
	}

	return 0;
}

162 163
int ath10k_htt_h2t_stats_req(struct ath10k_htt *htt, u8 mask, u64 cookie)
{
164
	struct ath10k *ar = htt->ar;
165 166 167 168 169 170 171 172
	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);

173
	skb = ath10k_htc_alloc_skb(ar, len);
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
	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) {
195 196
		ath10k_warn(ar, "failed to send htt type stats request: %d",
			    ret);
197 198 199 200 201 202 203
		dev_kfree_skb_any(skb);
		return ret;
	}

	return 0;
}

204 205
int ath10k_htt_send_rx_ring_cfg_ll(struct ath10k_htt *htt)
{
206
	struct ath10k *ar = htt->ar;
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
	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);
225
	skb = ath10k_htc_alloc_skb(ar, len);
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 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 276 277 278 279 280
	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

281
	ret = ath10k_htc_send(&htt->ar->htc, htt->eid, skb);
282 283 284 285 286 287 288 289
	if (ret) {
		dev_kfree_skb_any(skb);
		return ret;
	}

	return 0;
}

290 291 292 293
int ath10k_htt_h2t_aggr_cfg_msg(struct ath10k_htt *htt,
				u8 max_subfrms_ampdu,
				u8 max_subfrms_amsdu)
{
294
	struct ath10k *ar = htt->ar;
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
	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);

312
	skb = ath10k_htc_alloc_skb(ar, len);
313 314 315 316 317 318 319 320 321 322 323
	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;

324
	ath10k_dbg(ar, ATH10K_DBG_HTT, "htt h2t aggr cfg msg amsdu %d ampdu %d",
325 326 327 328 329 330 331 332 333 334 335 336
		   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;
}

337 338
int ath10k_htt_mgmt_tx(struct ath10k_htt *htt, struct sk_buff *msdu)
{
339 340
	struct ath10k *ar = htt->ar;
	struct device *dev = ar->dev;
341 342
	struct sk_buff *txdesc = NULL;
	struct htt_cmd *cmd;
343
	struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(msdu);
344
	u8 vdev_id = skb_cb->vdev_id;
345 346 347 348 349 350
	int len = 0;
	int msdu_id = -1;
	int res;

	res = ath10k_htt_tx_inc_pending(htt);
	if (res)
M
Michal Kazior 已提交
351
		goto err;
352 353 354 355 356

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

	spin_lock_bh(&htt->tx_lock);
M
Michal Kazior 已提交
357
	res = ath10k_htt_tx_alloc_msdu_id(htt, msdu);
M
Michal Kazior 已提交
358
	if (res < 0) {
359
		spin_unlock_bh(&htt->tx_lock);
M
Michal Kazior 已提交
360
		goto err_tx_dec;
361
	}
M
Michal Kazior 已提交
362
	msdu_id = res;
363 364
	spin_unlock_bh(&htt->tx_lock);

365
	txdesc = ath10k_htc_alloc_skb(ar, len);
M
Michal Kazior 已提交
366 367 368 369 370
	if (!txdesc) {
		res = -ENOMEM;
		goto err_free_msdu_id;
	}

371 372 373
	skb_cb->paddr = dma_map_single(dev, msdu->data, msdu->len,
				       DMA_TO_DEVICE);
	res = dma_mapping_error(dev, skb_cb->paddr);
374
	if (res)
M
Michal Kazior 已提交
375
		goto err_free_txdesc;
376 377 378 379 380 381 382 383 384 385 386

	skb_put(txdesc, len);
	cmd = (struct htt_cmd *)txdesc->data;
	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));

387
	skb_cb->htt.txbuf = NULL;
388

389
	res = ath10k_htc_send(&htt->ar->htc, htt->eid, txdesc);
390
	if (res)
M
Michal Kazior 已提交
391
		goto err_unmap_msdu;
392 393 394

	return 0;

M
Michal Kazior 已提交
395
err_unmap_msdu:
396
	dma_unmap_single(dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE);
M
Michal Kazior 已提交
397 398 399 400 401 402 403
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:
404
	ath10k_htt_tx_dec_pending(htt);
M
Michal Kazior 已提交
405
err:
406 407 408 409 410
	return res;
}

int ath10k_htt_tx(struct ath10k_htt *htt, struct sk_buff *msdu)
{
411 412
	struct ath10k *ar = htt->ar;
	struct device *dev = ar->dev;
413
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)msdu->data;
414
	struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(msdu);
415 416 417 418 419
	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;
420
	int res;
421 422
	u8 flags0 = 0;
	u16 msdu_id, flags1 = 0;
423 424
	dma_addr_t paddr = 0;
	u32 frags_paddr = 0;
425 426 427

	res = ath10k_htt_tx_inc_pending(htt);
	if (res)
M
Michal Kazior 已提交
428 429 430
		goto err;

	spin_lock_bh(&htt->tx_lock);
M
Michal Kazior 已提交
431
	res = ath10k_htt_tx_alloc_msdu_id(htt, msdu);
M
Michal Kazior 已提交
432 433 434 435 436 437
	if (res < 0) {
		spin_unlock_bh(&htt->tx_lock);
		goto err_tx_dec;
	}
	msdu_id = res;
	spin_unlock_bh(&htt->tx_lock);
438 439 440 441

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

442 443
	skb_cb->htt.txbuf = dma_pool_alloc(htt->tx_pool, GFP_ATOMIC,
					   &paddr);
J
Julia Lawall 已提交
444 445
	if (!skb_cb->htt.txbuf) {
		res = -ENOMEM;
446
		goto err_free_msdu_id;
J
Julia Lawall 已提交
447
	}
448
	skb_cb->htt.txbuf_paddr = paddr;
449

450 451 452 453 454 455
	if ((ieee80211_is_action(hdr->frame_control) ||
	     ieee80211_is_deauth(hdr->frame_control) ||
	     ieee80211_is_disassoc(hdr->frame_control)) &&
	     ieee80211_has_protected(hdr->frame_control))
		skb_put(msdu, IEEE80211_CCMP_MIC_LEN);

456 457 458
	skb_cb->paddr = dma_map_single(dev, msdu->data, msdu->len,
				       DMA_TO_DEVICE);
	res = dma_mapping_error(dev, skb_cb->paddr);
459
	if (res)
460
		goto err_free_txbuf;
461

462 463 464 465 466 467
	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:
468
		frags = skb_cb->htt.txbuf->frags;
469

470 471 472 473 474
		frags[0].paddr = __cpu_to_le32(skb_cb->paddr);
		frags[0].len = __cpu_to_le32(msdu->len);
		frags[1].paddr = 0;
		frags[1].len = 0;

475
		flags0 |= SM(skb_cb->txmode, HTT_DATA_TX_DESC_FLAGS0_PKT_TYPE);
476

477
		frags_paddr = skb_cb->htt.txbuf_paddr;
478 479
		break;
	case ATH10K_HW_TXRX_MGMT:
480 481
		flags0 |= SM(ATH10K_HW_TXRX_MGMT,
			     HTT_DATA_TX_DESC_FLAGS0_PKT_TYPE);
482
		flags0 |= HTT_DATA_TX_DESC_FLAGS0_MAC_HDR_PRESENT;
483

484
		frags_paddr = skb_cb->paddr;
485
		break;
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
	}

	/* 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;
510

511
	if (!skb_cb->is_protected)
512
		flags0 |= HTT_DATA_TX_DESC_FLAGS0_NO_ENCRYPT;
M
Michal Kazior 已提交
513

514 515
	flags1 |= SM((u16)vdev_id, HTT_DATA_TX_DESC_FLAGS1_VDEV_ID);
	flags1 |= SM((u16)tid, HTT_DATA_TX_DESC_FLAGS1_EXT_TID);
516 517 518 519
	if (msdu->ip_summed == CHECKSUM_PARTIAL) {
		flags1 |= HTT_DATA_TX_DESC_FLAGS1_CKSUM_L3_OFFLOAD;
		flags1 |= HTT_DATA_TX_DESC_FLAGS1_CKSUM_L4_OFFLOAD;
	}
520

521 522 523 524 525 526
	/* 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;

527 528 529 530 531 532
	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 已提交
533 534
	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);
535

536
	trace_ath10k_htt_tx(ar, msdu_id, msdu->len, vdev_id, tid);
537
	ath10k_dbg(ar, ATH10K_DBG_HTT,
M
Michal Kazior 已提交
538
		   "htt tx flags0 %hhu flags1 %hu len %d id %hu frags_paddr %08x, msdu_paddr %08x vdev %hhu tid %hhu freq %hu\n",
539
		   flags0, flags1, msdu->len, msdu_id, frags_paddr,
M
Michal Kazior 已提交
540
		   (u32)skb_cb->paddr, vdev_id, tid, skb_cb->htt.freq);
541
	ath10k_dbg_dump(ar, ATH10K_DBG_HTT_DUMP, NULL, "htt tx msdu: ",
542
			msdu->data, msdu->len);
543 544
	trace_ath10k_tx_hdr(ar, msdu->data, msdu->len);
	trace_ath10k_tx_payload(ar, msdu->data, msdu->len);
545

546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
	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));
564
	if (res)
565
		goto err_unmap_msdu;
566 567

	return 0;
M
Michal Kazior 已提交
568 569

err_unmap_msdu:
570
	dma_unmap_single(dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE);
571 572 573 574
err_free_txbuf:
	dma_pool_free(htt->tx_pool,
		      skb_cb->htt.txbuf,
		      skb_cb->htt.txbuf_paddr);
M
Michal Kazior 已提交
575 576 577 578 579
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:
580
	ath10k_htt_tx_dec_pending(htt);
M
Michal Kazior 已提交
581
err:
582 583
	return res;
}