blob: 78c7c4e722b5bd098b34881c986029b5df926149 [file] [log] [blame]
/*
* Copyright (c) 2011-2018 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by 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.
*/
/*
* This file was originally distributed by Qualcomm Atheros, Inc.
* under proprietary terms before Copyright ownership was assigned
* to the Linux Foundation.
*/
/**
* @file htt_t2h.c
* @brief Provide functions to process target->host HTT messages.
* @details
* This file contains functions related to target->host HTT messages.
* There are two categories of functions:
* 1. A function that receives a HTT message from HTC, and dispatches it
* based on the HTT message type.
* 2. functions that provide the info elements from specific HTT messages.
*/
#include <htc_api.h> /* HTC_PACKET */
#include <htt.h> /* HTT_T2H_MSG_TYPE, etc. */
#include <adf_nbuf.h> /* adf_nbuf_t */
#include <ol_htt_rx_api.h>
#include <ol_htt_tx_api.h>
#include <ol_txrx_htt_api.h> /* htt_tx_status */
#include <htt_internal.h> /* HTT_TX_SCHED, etc. */
#include <pktlog_ac_fmt.h>
#include <wdi_event.h>
#include <ol_htt_tx_api.h>
#include <ol_txrx_stats.h>
#include <wdi_event_api.h>
#include <ol_txrx_ctrl_api.h>
#include <ol_txrx_peer_find.h>
#include <ol_ctrl_txrx_api.h>
/*--- target->host HTT message dispatch function ----------------------------*/
#ifndef DEBUG_CREDIT
#define DEBUG_CREDIT 0
#endif
static u_int8_t *
htt_t2h_mac_addr_deswizzle(u_int8_t *tgt_mac_addr, u_int8_t *buffer)
{
#ifdef BIG_ENDIAN_HOST
/*
* The host endianness is opposite of the target endianness.
* To make u_int32_t elements come out correctly, the target->host
* upload has swizzled the bytes in each u_int32_t element of the
* message.
* For byte-array message fields like the MAC address, this
* upload swizzling puts the bytes in the wrong order, and needs
* to be undone.
*/
buffer[0] = tgt_mac_addr[3];
buffer[1] = tgt_mac_addr[2];
buffer[2] = tgt_mac_addr[1];
buffer[3] = tgt_mac_addr[0];
buffer[4] = tgt_mac_addr[7];
buffer[5] = tgt_mac_addr[6];
return buffer;
#else
/*
* The host endianness matches the target endianness -
* we can use the mac addr directly from the message buffer.
*/
return tgt_mac_addr;
#endif
}
#if defined(CONFIG_HL_SUPPORT)
#define HTT_RX_FRAG_SET_LAST_MSDU(pdev, msg) /* no-op */
#define HTT_FAIL_NOTIFY_BREAK_CHECK(status) \
((status) == htt_tx_status_fail_notify)
#else
static void HTT_RX_FRAG_SET_LAST_MSDU(
struct htt_pdev_t *pdev, adf_nbuf_t msg)
{
u_int32_t *msg_word;
unsigned num_msdu_bytes;
adf_nbuf_t msdu;
struct htt_host_rx_desc_base *rx_desc;
int start_idx;
u_int8_t *p_fw_msdu_rx_desc = 0;
msg_word = (u_int32_t *) adf_nbuf_data(msg);
num_msdu_bytes = HTT_RX_FRAG_IND_FW_RX_DESC_BYTES_GET(*(msg_word +
HTT_RX_FRAG_IND_HDR_PREFIX_SIZE32));
/*
* 1 word for the message header,
* 1 word to specify the number of MSDU bytes,
* 1 word for every 4 MSDU bytes (round up),
* 1 word for the MPDU range header
*/
pdev->rx_mpdu_range_offset_words = 3 + ((num_msdu_bytes + 3) >> 2);
pdev->rx_ind_msdu_byte_idx = 0;
p_fw_msdu_rx_desc = ((u_int8_t *)(msg_word) +
HTT_ENDIAN_BYTE_IDX_SWAP(HTT_RX_FRAG_IND_FW_DESC_BYTE_OFFSET));
/*
* Fix for EV126710, in which BSOD occurs due to last_msdu bit
* not set while the next pointer is deliberately set to NULL
* before calling ol_rx_pn_check_base()
*
* For fragment frames, the HW may not have set the last_msdu bit
* in the rx descriptor, but the SW expects this flag to be set,
* since each fragment is in a separate MPDU. Thus, set the flag here,
* just in case the HW didn't.
*/
start_idx = pdev->rx_ring.sw_rd_idx.msdu_payld;
msdu = pdev->rx_ring.buf.netbufs_ring[start_idx];
adf_nbuf_set_pktlen(msdu, HTT_RX_BUF_SIZE);
adf_nbuf_unmap(pdev->osdev, msdu, ADF_OS_DMA_FROM_DEVICE);
rx_desc = htt_rx_desc(msdu);
*((u_int8_t *) &rx_desc->fw_desc.u.val) = *p_fw_msdu_rx_desc;
rx_desc->msdu_end.last_msdu = 1;
adf_nbuf_map(pdev->osdev, msdu, ADF_OS_DMA_FROM_DEVICE);
}
#define HTT_FAIL_NOTIFY_BREAK_CHECK(status) 0
#endif /* CONFIG_HL_SUPPORT */
#define MAX_TARGET_TX_CREDIT 204800
/* Target to host Msg/event handler for low priority messages*/
void
htt_t2h_lp_msg_handler(void *context, adf_nbuf_t htt_t2h_msg )
{
struct htt_pdev_t *pdev = (struct htt_pdev_t *) context;
u_int32_t *msg_word;
enum htt_t2h_msg_type msg_type;
msg_word = (u_int32_t *) adf_nbuf_data(htt_t2h_msg);
msg_type = HTT_T2H_MSG_TYPE_GET(*msg_word);
switch (msg_type) {
case HTT_T2H_MSG_TYPE_VERSION_CONF:
{
htc_pm_runtime_put(pdev->htc_pdev);
pdev->tgt_ver.major = HTT_VER_CONF_MAJOR_GET(*msg_word);
pdev->tgt_ver.minor = HTT_VER_CONF_MINOR_GET(*msg_word);
adf_os_print("target uses HTT version %d.%d; host uses %d.%d\n",
pdev->tgt_ver.major, pdev->tgt_ver.minor,
HTT_CURRENT_VERSION_MAJOR, HTT_CURRENT_VERSION_MINOR);
if (pdev->tgt_ver.major != HTT_CURRENT_VERSION_MAJOR) {
adf_os_print("*** Incompatible host/target HTT versions!\n");
}
/* abort if the target is incompatible with the host */
adf_os_assert(pdev->tgt_ver.major == HTT_CURRENT_VERSION_MAJOR);
if (pdev->tgt_ver.minor != HTT_CURRENT_VERSION_MINOR) {
adf_os_print(
"*** Warning: host/target HTT versions are different, "
"though compatible!\n");
}
break;
}
case HTT_T2H_MSG_TYPE_RX_FLUSH:
{
u_int16_t peer_id;
u_int8_t tid;
u_int16_t seq_num_start, seq_num_end;
enum htt_rx_flush_action action;
peer_id = HTT_RX_FLUSH_PEER_ID_GET(*msg_word);
tid = HTT_RX_FLUSH_TID_GET(*msg_word);
seq_num_start = HTT_RX_FLUSH_SEQ_NUM_START_GET(*(msg_word+1));
seq_num_end = HTT_RX_FLUSH_SEQ_NUM_END_GET(*(msg_word+1));
action =
HTT_RX_FLUSH_MPDU_STATUS_GET(*(msg_word+1)) == 1 ?
htt_rx_flush_release : htt_rx_flush_discard;
ol_rx_flush_handler(
pdev->txrx_pdev,
peer_id, tid,
seq_num_start,
seq_num_end,
action);
break;
}
case HTT_T2H_MSG_TYPE_RX_OFFLOAD_DELIVER_IND:
{
u_int16_t msdu_cnt;
msdu_cnt = HTT_RX_OFFLOAD_DELIVER_IND_MSDU_CNT_GET(*msg_word);
ol_rx_offload_deliver_ind_handler(
pdev->txrx_pdev,
htt_t2h_msg,
msdu_cnt);
if (pdev->cfg.is_high_latency) {
/* return here for HL to avoid double free on htt_t2h_msg */
return;
} else {
break;
}
}
case HTT_T2H_MSG_TYPE_RX_FRAG_IND:
{
u_int16_t peer_id;
u_int8_t tid;
peer_id = HTT_RX_FRAG_IND_PEER_ID_GET(*msg_word);
tid = HTT_RX_FRAG_IND_EXT_TID_GET(*msg_word);
HTT_RX_FRAG_SET_LAST_MSDU(pdev, htt_t2h_msg);
/* If packet len is invalid, will discard this frame. */
if (pdev->cfg.is_high_latency) {
u_int32_t rx_pkt_len = 0;
rx_pkt_len = adf_nbuf_len(htt_t2h_msg);
if (rx_pkt_len < (HTT_RX_FRAG_IND_BYTES +
sizeof(struct hl_htt_rx_ind_base)+
sizeof(struct ieee80211_frame))) {
adf_os_print("%s: invalid packet len, %u\n",
__FUNCTION__,
rx_pkt_len);
/*
* This buf will be freed before
* exiting this function.
*/
break;
}
}
ol_rx_frag_indication_handler(
pdev->txrx_pdev,
htt_t2h_msg,
peer_id,
tid);
if (pdev->cfg.is_high_latency) {
/*
* For high latency solution, HTT_T2H_MSG_TYPE_RX_FRAG_IND
* message and RX packet share the same buffer. All buffer will
* be freed by ol_rx_frag_indication_handler or upper layer to
* avoid double free issue.
*
*/
return;
}
break;
}
case HTT_T2H_MSG_TYPE_RX_ADDBA:
{
u_int16_t peer_id;
u_int8_t tid;
u_int8_t win_sz;
u_int16_t start_seq_num;
/*
* FOR NOW, the host doesn't need to know the initial
* sequence number for rx aggregation.
* Thus, any value will do - specify 0.
*/
start_seq_num = 0;
peer_id = HTT_RX_ADDBA_PEER_ID_GET(*msg_word);
tid = HTT_RX_ADDBA_TID_GET(*msg_word);
win_sz = HTT_RX_ADDBA_WIN_SIZE_GET(*msg_word);
ol_rx_addba_handler(
pdev->txrx_pdev, peer_id, tid, win_sz, start_seq_num,
0 /* success */);
break;
}
case HTT_T2H_MSG_TYPE_RX_DELBA:
{
u_int16_t peer_id;
u_int8_t tid;
peer_id = HTT_RX_DELBA_PEER_ID_GET(*msg_word);
tid = HTT_RX_DELBA_TID_GET(*msg_word);
ol_rx_delba_handler(pdev->txrx_pdev, peer_id, tid);
break;
}
case HTT_T2H_MSG_TYPE_PEER_MAP:
{
u_int8_t mac_addr_deswizzle_buf[HTT_MAC_ADDR_LEN];
u_int8_t *peer_mac_addr;
u_int16_t peer_id;
u_int8_t vdev_id;
peer_id = HTT_RX_PEER_MAP_PEER_ID_GET(*msg_word);
vdev_id = HTT_RX_PEER_MAP_VDEV_ID_GET(*msg_word);
peer_mac_addr = htt_t2h_mac_addr_deswizzle(
(u_int8_t *) (msg_word+1), &mac_addr_deswizzle_buf[0]);
if (peer_id > ol_cfg_max_peer_id(pdev->ctrl_pdev)) {
adf_os_print("%s: HTT_T2H_MSG_TYPE_PEER_MAP,"
"invalid peer_id, %u\n",
__FUNCTION__,
peer_id);
break;
}
ol_rx_peer_map_handler(
pdev->txrx_pdev, peer_id, vdev_id, peer_mac_addr, 1/*can tx*/);
break;
}
case HTT_T2H_MSG_TYPE_PEER_UNMAP:
{
u_int16_t peer_id;
peer_id = HTT_RX_PEER_UNMAP_PEER_ID_GET(*msg_word);
if (peer_id > ol_cfg_max_peer_id(pdev->ctrl_pdev)) {
adf_os_print("%s: HTT_T2H_MSG_TYPE_PEER_UNMAP,"
"invalid peer_id, %u\n",
__FUNCTION__,
peer_id);
break;
}
ol_rx_peer_unmap_handler(pdev->txrx_pdev, peer_id);
break;
}
case HTT_T2H_MSG_TYPE_SEC_IND:
{
u_int16_t peer_id;
enum htt_sec_type sec_type;
int is_unicast;
peer_id = HTT_SEC_IND_PEER_ID_GET(*msg_word);
sec_type = HTT_SEC_IND_SEC_TYPE_GET(*msg_word);
is_unicast = HTT_SEC_IND_UNICAST_GET(*msg_word);
msg_word++; /* point to the first part of the Michael key */
ol_rx_sec_ind_handler(
pdev->txrx_pdev, peer_id, sec_type, is_unicast, msg_word, msg_word+2);
break;
}
case HTT_T2H_MSG_TYPE_MGMT_TX_COMPL_IND:
{
struct htt_mgmt_tx_compl_ind *compl_msg;
int32_t credit_delta = 1;
compl_msg = (struct htt_mgmt_tx_compl_ind *)(msg_word + 1);
if (pdev->cfg.is_high_latency) {
if (!pdev->cfg.default_tx_comp_req) {
HTT_TX_MUTEX_ACQUIRE(&pdev->credit_mutex);
adf_os_atomic_add(credit_delta,
&pdev->htt_tx_credit.target_delta);
credit_delta = htt_tx_credit_update(pdev);
HTT_TX_MUTEX_RELEASE(&pdev->credit_mutex);
}
if (credit_delta) {
ol_tx_target_credit_update(pdev->txrx_pdev, credit_delta);
}
}
OL_TX_DESC_UPDATE_GROUP_CREDIT(
pdev->txrx_pdev, compl_msg->desc_id, 1, 0, compl_msg->status);
ol_tx_single_completion_handler(
pdev->txrx_pdev, compl_msg->status, compl_msg->desc_id);
htc_pm_runtime_put(pdev->htc_pdev);
HTT_TX_SCHED(pdev);
break;
}
#if TXRX_STATS_LEVEL != TXRX_STATS_LEVEL_OFF
case HTT_T2H_MSG_TYPE_STATS_CONF:
{
u_int64_t cookie;
u_int8_t *stats_info_list;
cookie = *(msg_word + 1);
cookie |= ((u_int64_t) (*(msg_word + 2))) << 32;
stats_info_list = (u_int8_t *) (msg_word + 3);
htc_pm_runtime_put(pdev->htc_pdev);
ol_txrx_fw_stats_handler(pdev->txrx_pdev, cookie, stats_info_list);
break;
}
#endif
#ifndef REMOVE_PKT_LOG
case HTT_T2H_MSG_TYPE_PKTLOG:
{
u_int32_t *pl_hdr;
u_int32_t log_type;
pl_hdr = (msg_word + 1);
log_type = (*(pl_hdr + 1) & ATH_PKTLOG_HDR_LOG_TYPE_MASK) >>
ATH_PKTLOG_HDR_LOG_TYPE_SHIFT;
if (log_type == PKTLOG_TYPE_TX_CTRL ||
(log_type) == PKTLOG_TYPE_TX_STAT ||
(log_type) == PKTLOG_TYPE_TX_MSDU_ID ||
(log_type) == PKTLOG_TYPE_TX_FRM_HDR ||
(log_type) == PKTLOG_TYPE_TX_VIRT_ADDR) {
wdi_event_handler(WDI_EVENT_TX_STATUS, pdev->txrx_pdev, pl_hdr);
} else if ((log_type) == PKTLOG_TYPE_RC_FIND) {
wdi_event_handler(WDI_EVENT_RATE_FIND, pdev->txrx_pdev, pl_hdr);
} else if ((log_type) == PKTLOG_TYPE_RC_UPDATE) {
wdi_event_handler(
WDI_EVENT_RATE_UPDATE, pdev->txrx_pdev, pl_hdr);
} else if ((log_type) == PKTLOG_TYPE_RX_STAT) {
wdi_event_handler(WDI_EVENT_RX_DESC, pdev->txrx_pdev, pl_hdr);
}
break;
}
#endif
case HTT_T2H_MSG_TYPE_TX_CREDIT_UPDATE_IND:
{
u_int32_t htt_credit_delta_abs;
int32_t htt_credit_delta;
int sign, old_credit;
htt_credit_delta_abs = HTT_TX_CREDIT_DELTA_ABS_GET(*msg_word);
sign = HTT_TX_CREDIT_SIGN_BIT_GET(*msg_word) ? -1 : 1;
htt_credit_delta = sign * htt_credit_delta_abs;
old_credit = adf_os_atomic_read(&pdev->htt_tx_credit.target_delta);
if (((old_credit + htt_credit_delta) > MAX_TARGET_TX_CREDIT) ||
((old_credit + htt_credit_delta) < -MAX_TARGET_TX_CREDIT)) {
adf_os_print("%s: invalid credit update,old_credit=%d,"
"htt_credit_delta=%d\n",
__FUNCTION__,
old_credit,
htt_credit_delta);
break;
}
if (pdev->cfg.is_high_latency &&
!pdev->cfg.default_tx_comp_req) {
HTT_TX_MUTEX_ACQUIRE(&pdev->credit_mutex);
adf_os_atomic_add(htt_credit_delta,
&pdev->htt_tx_credit.target_delta);
htt_credit_delta = htt_tx_credit_update(pdev);
HTT_TX_MUTEX_RELEASE(&pdev->credit_mutex);
}
HTT_TX_GROUP_CREDIT_PROCESS(pdev, msg_word);
/*
* Call ol_tx_credit_completion even if htt_credit_delta is zero,
* in case there is some global credit already available, but the
* above group credit updates have removed credit restrictions,
* possibly allowing the download scheduler to perform a download
* even if htt_credit_delta == 0.
*/
ol_tx_credit_completion_handler(pdev->txrx_pdev, htt_credit_delta);
break;
}
#ifdef IPA_UC_OFFLOAD
case HTT_T2H_MSG_TYPE_WDI_IPA_OP_RESPONSE:
{
u_int8_t op_code;
u_int16_t len;
u_int8_t *op_msg_buffer;
u_int8_t *msg_start_ptr;
htc_pm_runtime_put(pdev->htc_pdev);
msg_start_ptr = (u_int8_t *)msg_word;
op_code = HTT_WDI_IPA_OP_RESPONSE_OP_CODE_GET(*msg_word);
msg_word++;
len = HTT_WDI_IPA_OP_RESPONSE_RSP_LEN_GET(*msg_word);
op_msg_buffer = adf_os_mem_alloc(NULL,
sizeof(struct htt_wdi_ipa_op_response_t) + len);
if (!op_msg_buffer) {
adf_os_print("OPCODE messsage buffer alloc fail");
break;
}
adf_os_mem_copy(op_msg_buffer,
msg_start_ptr,
sizeof(struct htt_wdi_ipa_op_response_t) + len);
ol_txrx_ipa_uc_op_response(pdev->txrx_pdev, op_msg_buffer);
break;
}
#endif /* IPA_UC_OFFLOAD */
case HTT_T2H_MSG_TYPE_RX_OFLD_PKT_ERR:
{
switch (HTT_RX_OFLD_PKT_ERR_MSG_SUB_TYPE_GET(*msg_word)) {
case HTT_RX_OFLD_PKT_ERR_TYPE_MIC_ERR:
{
struct ol_error_info err_info;
struct ol_txrx_vdev_t *vdev;
struct ol_txrx_peer_t *peer;
u_int8_t * pn_ptr;
u_int16_t peer_id =
HTT_RX_OFLD_PKT_ERR_MIC_ERR_PEER_ID_GET(*(msg_word + 1));
peer = ol_txrx_peer_find_by_id(pdev->txrx_pdev, peer_id);
if (!peer) {
adf_os_print("%s: invalid peer id %d\n", __FUNCTION__,
peer_id);
break;
}
vdev = peer->vdev;
err_info.u.mic_err.vdev_id = vdev->vdev_id;
err_info.u.mic_err.key_id =
HTT_RX_OFLD_PKT_ERR_MIC_ERR_KEYID_GET(*(msg_word + 1));
adf_os_mem_copy(err_info.u.mic_err.da,
(u_int8_t *)(msg_word + 2),
OL_TXRX_MAC_ADDR_LEN);
adf_os_mem_copy(err_info.u.mic_err.sa,
(u_int8_t *)(msg_word + 4),
OL_TXRX_MAC_ADDR_LEN);
adf_os_mem_copy(err_info.u.mic_err.ta,
peer->mac_addr.raw, OL_TXRX_MAC_ADDR_LEN);
pn_ptr = (u_int8_t *)&err_info.u.mic_err.pn;
adf_os_mem_copy(pn_ptr, (u_int8_t *)(msg_word + 6), 4);
adf_os_mem_copy((pn_ptr + 4), (u_int8_t *)(msg_word + 7), 2);
ol_indicate_err(OL_RX_ERR_TKIP_MIC, &err_info);
break;
}
default:
{
adf_os_print("%s: unhandled error type %d\n", __FUNCTION__,
HTT_RX_OFLD_PKT_ERR_MSG_SUB_TYPE_GET(*msg_word));
break;
}
}
break;
}
case HTT_T2H_MSG_TYPE_RATE_REPORT:
{
u_int16_t peer_cnt = HTT_PEER_RATE_REPORT_MSG_PEER_COUNT_GET(*msg_word);
u_int16_t i;
struct rate_report_t *report, *each;
int max_peers;
/* Param sanity check */
if (peer_cnt == 0) {
adf_os_print("RATE REPORT messsage peer_cnt is 0! \n");
break;
}
max_peers = ol_cfg_max_peer_id(pdev->ctrl_pdev) + 1;
if (peer_cnt > max_peers) {
adf_os_print("RATE REPORT msg peer_cnt is larger than %d\n",
max_peers);
break;
}
/* At least one peer and no limit apply to peer_cnt here */
report = adf_os_mem_alloc(NULL,
sizeof(struct rate_report_t) * peer_cnt);
if (!report) {
adf_os_print("RATE REPORT messsage buffer alloc fail. peer_cnt %d\n",
peer_cnt);
break;
}
each = report;
msg_word++; /* point to the payload */
for (i = 0; i < peer_cnt; i++) {
each->id =
HTT_PEER_RATE_REPORT_MSG_PEER_ID_GET(*(msg_word + i*2));
each->phy =
HTT_PEER_RATE_REPORT_MSG_PHY_GET(*(msg_word + i*2));
each->rate = *(msg_word + i*2 + 1);
each++;
}
ol_txrx_peer_link_status_handler(pdev->txrx_pdev, peer_cnt, report);
adf_os_mem_free(report);
break;
}
default:
break;
};
/* Free the indication buffer */
adf_nbuf_free(htt_t2h_msg);
}
/* Generic Target to host Msg/event handler for low priority messages
Low priority message are handler in a different handler called from
this function . So that the most likely succes path like Rx and
Tx comp has little code foot print
*/
void
htt_t2h_msg_handler(void *context, HTC_PACKET *pkt)
{
struct htt_pdev_t *pdev = (struct htt_pdev_t *) context;
adf_nbuf_t htt_t2h_msg = (adf_nbuf_t) pkt->pPktContext;
u_int32_t *msg_word;
enum htt_t2h_msg_type msg_type;
/* check for successful message reception */
if (pkt->Status != A_OK) {
if (pkt->Status != A_ECANCELED) {
pdev->stats.htc_err_cnt++;
}
adf_nbuf_free(htt_t2h_msg);
return;
}
#ifdef HTT_RX_RESTORE
if (adf_os_unlikely(pdev->rx_ring.rx_reset)) {
adf_os_print("rx restore ..\n");
adf_nbuf_free(htt_t2h_msg);
return;
}
#endif
/* confirm alignment */
HTT_ASSERT3((((unsigned long) adf_nbuf_data(htt_t2h_msg)) & 0x3) == 0);
msg_word = (u_int32_t *) adf_nbuf_data(htt_t2h_msg);
msg_type = HTT_T2H_MSG_TYPE_GET(*msg_word);
switch (msg_type) {
case HTT_T2H_MSG_TYPE_RX_IND:
{
unsigned num_mpdu_ranges;
unsigned num_msdu_bytes;
u_int16_t peer_id;
u_int8_t tid;
if (adf_os_unlikely(pdev->cfg.is_full_reorder_offload)) {
adf_os_print("HTT_T2H_MSG_TYPE_RX_IND not supported with full "
"reorder offload\n");
break;
}
peer_id = HTT_RX_IND_PEER_ID_GET(*msg_word);
tid = HTT_RX_IND_EXT_TID_GET(*msg_word);
if (tid >= OL_TXRX_NUM_EXT_TIDS) {
adf_os_print("HTT_T2H_MSG_TYPE_RX_IND, invalid tid %d\n", tid);
break;
}
num_msdu_bytes = HTT_RX_IND_FW_RX_DESC_BYTES_GET(
*(msg_word + 2 + HTT_RX_PPDU_DESC_SIZE32));
/*
* 1 word for the message header,
* HTT_RX_PPDU_DESC_SIZE32 words for the FW rx PPDU desc
* 1 word to specify the number of MSDU bytes,
* 1 word for every 4 MSDU bytes (round up),
* 1 word for the MPDU range header
*/
pdev->rx_mpdu_range_offset_words =
(HTT_RX_IND_HDR_BYTES + num_msdu_bytes + 3) >> 2;
num_mpdu_ranges = HTT_RX_IND_NUM_MPDU_RANGES_GET(*(msg_word + 1));
pdev->rx_ind_msdu_byte_idx = 0;
if (pdev->cfg.is_high_latency) {
/*
* TODO: remove copy after stopping reuse skb on HIF layer
* because SDIO HIF may reuse skb before upper layer release it
*/
if (VOS_MONITOR_MODE == vos_get_conparam())
ol_rx_mon_indication_handler(
pdev->txrx_pdev, htt_t2h_msg, peer_id, tid,
num_mpdu_ranges);
else
ol_rx_indication_handler(
pdev->txrx_pdev, htt_t2h_msg, peer_id, tid,
num_mpdu_ranges);
return;
} else {
ol_rx_indication_handler(
pdev->txrx_pdev, htt_t2h_msg, peer_id, tid,
num_mpdu_ranges);
}
break;
}
case HTT_T2H_MSG_TYPE_TX_COMPL_IND:
{
int old_credit;
int num_msdus;
enum htt_tx_status status;
int msg_len = adf_nbuf_len(htt_t2h_msg);
/* status - no enum translation needed */
status = HTT_TX_COMPL_IND_STATUS_GET(*msg_word);
num_msdus = HTT_TX_COMPL_IND_NUM_GET(*msg_word);
/*
* each desc id will occupy 2 bytes.
* the 4 is for htt msg header
*/
if ((num_msdus * HTT_TX_COMPL_BYTES_PER_MSDU_ID +
HTT_TX_COMPL_HEAD_SZ) > msg_len) {
adf_os_print("%s: num_msdus(%d) is invalid,"
"adf_nbuf_len = %d\n",
__FUNCTION__,
num_msdus,
msg_len);
break;
}
if (num_msdus & 0x1) {
struct htt_tx_compl_ind_base *compl = (void *)msg_word;
/*
* Host CPU endianness can be different from FW CPU. This
* can result in even and odd MSDU IDs being switched. If
* this happens, copy the switched final odd MSDU ID from
* location payload[size], to location payload[size-1],
* where the message handler function expects to find it
*/
if (compl->payload[num_msdus] != HTT_TX_COMPL_INV_MSDU_ID) {
compl->payload[num_msdus - 1] =
compl->payload[num_msdus];
}
}
/* Indicate failure status to user space */
ol_tx_failure_indication(pdev->txrx_pdev,
HTT_TX_COMPL_IND_TID_GET(*msg_word),
num_msdus, status);
if (pdev->cfg.is_high_latency) {
/*
* For regular frms in HL case, frms have already been
* freed and tx credit has been updated. FW indicates
* special message for failure MSDUs with status type
* htt_tx_status_fail_notify. Once such message was
* received, just break here.
*/
if (ol_cfg_tx_free_at_download(pdev->ctrl_pdev) &&
HTT_FAIL_NOTIFY_BREAK_CHECK(status)) {
adf_os_print("HTT TX COMPL for failed data frm.\n");
break;
}
old_credit = adf_os_atomic_read(&pdev->htt_tx_credit.target_delta);
if (((old_credit + num_msdus) > MAX_TARGET_TX_CREDIT) ||
((old_credit + num_msdus) < -MAX_TARGET_TX_CREDIT)) {
adf_os_print("%s: invalid credit update,old_credit=%d,"
"num_msdus=%d\n",
__FUNCTION__,
old_credit,
num_msdus);
} else {
if (!pdev->cfg.default_tx_comp_req) {
int credit_delta;
HTT_TX_MUTEX_ACQUIRE(&pdev->credit_mutex);
adf_os_atomic_add(num_msdus,
&pdev->htt_tx_credit.target_delta);
credit_delta = htt_tx_credit_update(pdev);
HTT_TX_MUTEX_RELEASE(&pdev->credit_mutex);
if (credit_delta) {
ol_tx_target_credit_update(pdev->txrx_pdev,
credit_delta);
}
} else {
ol_tx_target_credit_update(pdev->txrx_pdev,
num_msdus);
}
}
}
ol_tx_completion_handler(
pdev->txrx_pdev, num_msdus, status, msg_word);
HTT_TX_SCHED(pdev);
break;
}
case HTT_T2H_MSG_TYPE_RX_PN_IND:
{
u_int16_t peer_id;
u_int8_t tid, pn_ie_cnt, *pn_ie=NULL;
u_int16_t seq_num_start, seq_num_end;
/*First dword */
peer_id = HTT_RX_PN_IND_PEER_ID_GET(*msg_word);
tid = HTT_RX_PN_IND_EXT_TID_GET(*msg_word);
msg_word++;
/*Second dword */
seq_num_start = HTT_RX_PN_IND_SEQ_NUM_START_GET(*msg_word);
seq_num_end = HTT_RX_PN_IND_SEQ_NUM_END_GET(*msg_word);
pn_ie_cnt = HTT_RX_PN_IND_PN_IE_CNT_GET(*msg_word);
msg_word++;
/*Third dword*/
if (pn_ie_cnt) {
pn_ie = (u_int8_t *)msg_word;
}
ol_rx_pn_ind_handler(
pdev->txrx_pdev, peer_id, tid, seq_num_start, seq_num_end,
pn_ie_cnt, pn_ie);
break;
}
case HTT_T2H_MSG_TYPE_TX_INSPECT_IND:
{
int num_msdus;
int msg_len = adf_nbuf_len(htt_t2h_msg);
num_msdus = HTT_TX_COMPL_IND_NUM_GET(*msg_word);
/*
* each desc id will occupy 2 bytes.
* the 4 is for htt msg header
*/
if ((num_msdus * HTT_TX_COMPL_BYTES_PER_MSDU_ID +
HTT_TX_COMPL_HEAD_SZ) > msg_len) {
adf_os_print("%s: num_msdus(%d) is invalid,"
"adf_nbuf_len = %d,inspect\n",
__FUNCTION__,
num_msdus,
msg_len);
break;
}
if (num_msdus & 0x1) {
struct htt_tx_compl_ind_base *compl = (void *)msg_word;
/*
* Host CPU endianness can be different from FW CPU. This
* can result in even and odd MSDU IDs being switched. If
* this happens, copy the switched final odd MSDU ID from
* location payload[size], to location payload[size-1],
* where the message handler function expects to find it
*/
if (compl->payload[num_msdus] != HTT_TX_COMPL_INV_MSDU_ID) {
compl->payload[num_msdus - 1] =
compl->payload[num_msdus];
}
}
ol_tx_inspect_handler(pdev->txrx_pdev, num_msdus, msg_word + 1);
HTT_TX_SCHED(pdev);
break;
}
case HTT_T2H_MSG_TYPE_RX_IN_ORD_PADDR_IND:
{
u_int16_t peer_id;
u_int8_t tid;
u_int8_t offload_ind, frag_ind;
if (adf_os_unlikely(!pdev->cfg.is_full_reorder_offload)) {
adf_os_print("HTT_T2H_MSG_TYPE_RX_IN_ORD_PADDR_IND not supported"
" when full reorder offload is disabled\n");
break;
}
if (adf_os_unlikely(pdev->cfg.is_high_latency)) {
adf_os_print("HTT_T2H_MSG_TYPE_RX_IN_ORD_PADDR_IND not supported"
" on high latency\n");
break;
}
peer_id = HTT_RX_IN_ORD_PADDR_IND_PEER_ID_GET(*msg_word);
tid = HTT_RX_IN_ORD_PADDR_IND_EXT_TID_GET(*msg_word);
offload_ind = HTT_RX_IN_ORD_PADDR_IND_OFFLOAD_GET(*msg_word);
frag_ind = HTT_RX_IN_ORD_PADDR_IND_FRAG_GET(*msg_word);
if (adf_os_unlikely(frag_ind)) {
ol_rx_frag_indication_handler(pdev->txrx_pdev, htt_t2h_msg,
peer_id, tid);
break;
}
ol_rx_in_order_indication_handler(pdev->txrx_pdev, htt_t2h_msg,
peer_id, tid, offload_ind);
break;
}
case HTT_T2H_MSG_TYPE_MONITOR_MAC_HEADER_IND:
{
ol_rx_mon_mac_header_handler(pdev->txrx_pdev, htt_t2h_msg);
break;
}
default:
htt_t2h_lp_msg_handler(context, htt_t2h_msg);
return ;
};
/* Free the indication buffer */
adf_nbuf_free(htt_t2h_msg);
}
/*--- target->host HTT message Info Element access methods ------------------*/
/*--- tx completion message ---*/
u_int16_t
htt_tx_compl_desc_id(void *iterator, int num)
{
/*
* The MSDU IDs are packed , 2 per 32-bit word.
* Iterate on them as an array of 16-bit elements.
* This will work fine if the host endianness matches
* the target endianness.
* If the host endianness is opposite of the target's,
* this iterator will produce descriptor IDs in a different
* order than the target inserted them into the message -
* if the target puts in [0, 1, 2, 3, ...] the host will
* put out [1, 0, 3, 2, ...].
* This is fine, except for the last ID if there are an
* odd number of IDs. But the TX_COMPL_IND handling code
* in the htt_t2h_msg_handler already added a duplicate
* of the final ID, if there were an odd number of IDs,
* so this function can safely treat the IDs as an array
* of 16-bit elements.
*/
return *(((u_int16_t *) iterator) + num);
}
/*--- rx indication message ---*/
int
htt_rx_ind_flush(htt_pdev_handle pdev, adf_nbuf_t rx_ind_msg)
{
u_int32_t *msg_word;
msg_word = (u_int32_t *) adf_nbuf_data(rx_ind_msg);
return HTT_RX_IND_FLUSH_VALID_GET(*msg_word);
}
void
htt_rx_ind_flush_seq_num_range(
htt_pdev_handle pdev,
adf_nbuf_t rx_ind_msg,
unsigned *seq_num_start,
unsigned *seq_num_end)
{
u_int32_t *msg_word;
msg_word = (u_int32_t *) adf_nbuf_data(rx_ind_msg);
msg_word++;
*seq_num_start = HTT_RX_IND_FLUSH_SEQ_NUM_START_GET(*msg_word);
*seq_num_end = HTT_RX_IND_FLUSH_SEQ_NUM_END_GET(*msg_word);
}
int
htt_rx_ind_release(htt_pdev_handle pdev, adf_nbuf_t rx_ind_msg)
{
u_int32_t *msg_word;
msg_word = (u_int32_t *) adf_nbuf_data(rx_ind_msg);
return HTT_RX_IND_REL_VALID_GET(*msg_word);
}
void
htt_rx_ind_release_seq_num_range(
htt_pdev_handle pdev,
adf_nbuf_t rx_ind_msg,
unsigned *seq_num_start,
unsigned *seq_num_end)
{
u_int32_t *msg_word;
msg_word = (u_int32_t *) adf_nbuf_data(rx_ind_msg);
msg_word++;
*seq_num_start = HTT_RX_IND_REL_SEQ_NUM_START_GET(*msg_word);
*seq_num_end = HTT_RX_IND_REL_SEQ_NUM_END_GET(*msg_word);
}
void
htt_rx_ind_mpdu_range_info(
struct htt_pdev_t *pdev,
adf_nbuf_t rx_ind_msg,
int mpdu_range_num,
enum htt_rx_status *status,
int *mpdu_count)
{
u_int32_t *msg_word;
msg_word = (u_int32_t *) adf_nbuf_data(rx_ind_msg);
msg_word += pdev->rx_mpdu_range_offset_words + mpdu_range_num;
*status = HTT_RX_IND_MPDU_STATUS_GET(*msg_word);
*mpdu_count = HTT_RX_IND_MPDU_COUNT_GET(*msg_word);
}
/**
* htt_rx_ind_rssi_dbm() - Return the RSSI provided in a rx indication message.
*
* @pdev: the HTT instance the rx data was received on
* @rx_ind_msg: the netbuf containing the rx indication message
*
* Return the RSSI from an rx indication message in dBm units.
*
* Return: RSSI in dBm, or HTT_INVALID_RSSI
*/
int16_t
htt_rx_ind_rssi_dbm(htt_pdev_handle pdev, adf_nbuf_t rx_ind_msg)
{
int8_t rssi;
u_int32_t *msg_word;
msg_word = (u_int32_t *)
(adf_nbuf_data(rx_ind_msg) + HTT_RX_IND_FW_RX_PPDU_DESC_BYTE_OFFSET);
/* check if the RX_IND message contains valid rx PPDU start info */
if (!HTT_RX_IND_START_VALID_GET(*msg_word)) {
return HTT_RSSI_INVALID;
}
rssi = HTT_RX_IND_RSSI_CMB_GET(*msg_word);
return (HTT_TGT_RSSI_INVALID == rssi) ?
HTT_RSSI_INVALID :
rssi;
}
/**
* htt_rx_ind_rssi_dbm_chain() - Return the RSSI for a chain provided in a rx
* indication message.
* @pdev: the HTT instance the rx data was received on
* @rx_ind_msg: the netbuf containing the rx indication message
* @chain: the index of the chain (0-4)
*
* Return the RSSI for a chain from an rx indication message in dBm units.
*
* Return: RSSI in dBm, or HTT_INVALID_RSSI
*/
int16_t
htt_rx_ind_rssi_dbm_chain(htt_pdev_handle pdev, adf_nbuf_t rx_ind_msg,
int8_t chain)
{
int8_t rssi;
u_int32_t *msg_word;
if (chain < 0 || chain > 3) {
return HTT_RSSI_INVALID;
}
msg_word = (u_int32_t *)
(adf_nbuf_data(rx_ind_msg) + HTT_RX_IND_FW_RX_PPDU_DESC_BYTE_OFFSET);
/* check if the RX_IND message contains valid rx PPDU start info */
if (!HTT_RX_IND_START_VALID_GET(*msg_word)) {
return HTT_RSSI_INVALID;
}
msg_word += 1 + chain;
rssi = HTT_RX_IND_RSSI_PRI20_GET(*msg_word);
return (HTT_TGT_RSSI_INVALID == rssi) ?
HTT_RSSI_INVALID :
rssi;
}
/**
* htt_rx_ind_noise_floor_chain() - Return the nosie floor for a chain
* provided in a rx indication message.
* @pdev: the HTT instance the rx data was received on
* @rx_ind_msg: the netbuf containing the rx indication message
* @chain: the index of the chain (0-1) for DSRC
*
* Return the noise floor for a chain from an rx indication message.
*
* Return: noise floor, or HTT_NOISE_FLOOR_INVALID
*/
int8_t
htt_rx_ind_noise_floor_chain(htt_pdev_handle pdev, adf_nbuf_t rx_ind_msg,
int8_t chain)
{
int8_t noise_floor;
u_int32_t *msg_word;
/* only chain0/1 used with 11p DSRC */
if (chain < 0 || chain > 1) {
return HTT_NOISE_FLOOR_INVALID;
}
msg_word = (u_int32_t *)
(adf_nbuf_data(rx_ind_msg) +
HTT_RX_IND_FW_RX_PPDU_DESC_BYTE_OFFSET);
/* check if the RX_IND message contains valid rx PPDU start info */
if (!HTT_RX_IND_START_VALID_GET(*msg_word)) {
return HTT_NOISE_FLOOR_INVALID;
}
msg_word = (u_int32_t *)
(adf_nbuf_data(rx_ind_msg) + HTT_RX_IND_HDR_SUFFIX_BYTE_OFFSET);
if (chain == 0)
noise_floor = HTT_RX_IND_NOISE_FLOOR_CHAIN0_GET(*msg_word);
else if (chain == 1)
noise_floor = HTT_RX_IND_NOISE_FLOOR_CHAIN1_GET(*msg_word);
return noise_floor;
}
/**
* htt_rx_ind_legacy_rate() - Return the data rate
* @pdev: the HTT instance the rx data was received on
* @rx_ind_msg: the netbuf containing the rx indication message
* @legacy_rate: (output) the data rate
* The legacy_rate parameter's value depends on the
* legacy_rate_sel value.
* If legacy_rate_sel is 0:
* 0x8: OFDM 48 Mbps
* 0x9: OFDM 24 Mbps
* 0xA: OFDM 12 Mbps
* 0xB: OFDM 6 Mbps
* 0xC: OFDM 54 Mbps
* 0xD: OFDM 36 Mbps
* 0xE: OFDM 18 Mbps
* 0xF: OFDM 9 Mbps
* If legacy_rate_sel is 1:
* 0x8: CCK 11 Mbps long preamble
* 0x9: CCK 5.5 Mbps long preamble
* 0xA: CCK 2 Mbps long preamble
* 0xB: CCK 1 Mbps long preamble
* 0xC: CCK 11 Mbps short preamble
* 0xD: CCK 5.5 Mbps short preamble
* 0xE: CCK 2 Mbps short preamble
* -1 on error.
* @legacy_rate_sel: (output) 0 to indicate OFDM, 1 to indicate CCK.
* -1 on error.
*
* Return the data rate provided in a rx indication message.
*/
void
htt_rx_ind_legacy_rate(htt_pdev_handle pdev, adf_nbuf_t rx_ind_msg,
uint8_t *legacy_rate, uint8_t *legacy_rate_sel)
{
u_int32_t *msg_word;
msg_word = (u_int32_t *)
(adf_nbuf_data(rx_ind_msg) + HTT_RX_IND_FW_RX_PPDU_DESC_BYTE_OFFSET);
/* check if the RX_IND message contains valid rx PPDU start info */
if (!HTT_RX_IND_START_VALID_GET(*msg_word)) {
*legacy_rate = -1;
*legacy_rate_sel = -1;
return;
}
*legacy_rate = HTT_RX_IND_LEGACY_RATE_GET(*msg_word);
*legacy_rate_sel = HTT_RX_IND_LEGACY_RATE_SEL_GET(*msg_word);
}
/**
* htt_rx_ind_timestamp() - Return the timestamp
* @pdev: the HTT instance the rx data was received on
* @rx_ind_msg: the netbuf containing the rx indication message
* @timestamp_microsec: (output) the timestamp to microsecond resolution.
* -1 on error.
* @timestamp_submicrosec: the submicrosecond portion of the
* timestamp. -1 on error.
*
* Return the timestamp provided in a rx indication message.
*/
void
htt_rx_ind_timestamp(htt_pdev_handle pdev, adf_nbuf_t rx_ind_msg,
uint32_t *timestamp_microsec, uint8_t *timestamp_submicrosec)
{
u_int32_t *msg_word;
msg_word = (u_int32_t *)
(adf_nbuf_data(rx_ind_msg) + HTT_RX_IND_FW_RX_PPDU_DESC_BYTE_OFFSET);
/* check if the RX_IND message contains valid rx PPDU start info */
if (!HTT_RX_IND_END_VALID_GET(*msg_word)) {
*timestamp_microsec = -1;
*timestamp_submicrosec = -1;
return;
}
*timestamp_microsec = *(msg_word + 6);
*timestamp_submicrosec =
HTT_RX_IND_TIMESTAMP_SUBMICROSEC_GET(*msg_word);
}
/**
* htt_rx_ind_tsf32() - Return the TSF timestamp
* @pdev: the HTT instance the rx data was received on
* @rx_ind_msg: the netbuf containing the rx indication message
*
* Return the TSF timestamp provided in a rx indication message.
*
* Return: TSF timestamp
*/
uint32_t
htt_rx_ind_tsf32(htt_pdev_handle pdev, adf_nbuf_t rx_ind_msg)
{
u_int32_t *msg_word;
msg_word = (u_int32_t *)
(adf_nbuf_data(rx_ind_msg) + HTT_RX_IND_FW_RX_PPDU_DESC_BYTE_OFFSET);
/* check if the RX_IND message contains valid rx PPDU start info */
if (!HTT_RX_IND_END_VALID_GET(*msg_word)) {
return -1;
}
return *(msg_word + 5);
}
/**
* htt_rx_ind_ext_tid() - Return the extended traffic ID provided in a rx indication message.
* @pdev: the HTT instance the rx data was received on
* @rx_ind_msg: the netbuf containing the rx indication message
*
* Return the extended traffic ID in a rx indication message.
*
* Return: Extended TID
*/
uint8_t
htt_rx_ind_ext_tid(htt_pdev_handle pdev, adf_nbuf_t rx_ind_msg)
{
u_int32_t *msg_word;
msg_word = (u_int32_t *)
(adf_nbuf_data(rx_ind_msg));
return HTT_RX_IND_EXT_TID_GET(*msg_word);
}
/*--- stats confirmation message ---*/
void
htt_t2h_dbg_stats_hdr_parse(
u_int8_t *stats_info_list,
enum htt_dbg_stats_type *type,
enum htt_dbg_stats_status *status,
int *length,
u_int8_t **stats_data)
{
u_int32_t *msg_word = (u_int32_t *) stats_info_list;
*type = HTT_T2H_STATS_CONF_TLV_TYPE_GET(*msg_word);
*status = HTT_T2H_STATS_CONF_TLV_STATUS_GET(*msg_word);
*length = HTT_T2H_STATS_CONF_TLV_HDR_SIZE + /* header length */
HTT_T2H_STATS_CONF_TLV_LENGTH_GET(*msg_word); /* data length */
*stats_data = stats_info_list + HTT_T2H_STATS_CONF_TLV_HDR_SIZE;
}
void
htt_rx_frag_ind_flush_seq_num_range(
htt_pdev_handle pdev,
adf_nbuf_t rx_frag_ind_msg,
u_int16_t *seq_num_start,
u_int16_t *seq_num_end)
{
u_int32_t *msg_word;
msg_word = (u_int32_t *) adf_nbuf_data(rx_frag_ind_msg);
msg_word++;
*seq_num_start = HTT_RX_FRAG_IND_FLUSH_SEQ_NUM_START_GET(*msg_word);
*seq_num_end = HTT_RX_FRAG_IND_FLUSH_SEQ_NUM_END_GET(*msg_word);
}