[deliverable/linux.git] / drivers / net / wireless / mwifiex / txrx.c

/*
 * Marvell Wireless LAN device driver: generic TX/RX data handling
 *
 * Copyright (C) 2011-2014, Marvell International Ltd.
 *
 * This software file (the "File") is distributed by Marvell International
 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
 * (the "License").  You may use, redistribute and/or modify this File in
 * accordance with the terms and conditions of the License, a copy of which
 * is available by writing to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 *
 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
 * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
 * this warranty disclaimer.
 */

#include "decl.h"
#include "ioctl.h"
#include "util.h"
#include "fw.h"
#include "main.h"
#include "wmm.h"

/*
 * This function processes the received buffer.
 *
 * Main responsibility of this function is to parse the RxPD to
 * identify the correct interface this packet is headed for and
 * forwarding it to the associated handling function, where the
 * packet will be further processed and sent to kernel/upper layer
 * if required.
 */
int mwifiex_handle_rx_packet(struct mwifiex_adapter *adapter,
			     struct sk_buff *skb)
{
	struct mwifiex_private *priv =
		mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
	struct rxpd *local_rx_pd;
	struct mwifiex_rxinfo *rx_info = MWIFIEX_SKB_RXCB(skb);
	int ret;

	local_rx_pd = (struct rxpd *) (skb->data);
	/* Get the BSS number from rxpd, get corresponding priv */
	priv = mwifiex_get_priv_by_id(adapter, local_rx_pd->bss_num &
				      BSS_NUM_MASK, local_rx_pd->bss_type);
	if (!priv)
		priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);

	if (!priv) {
		mwifiex_dbg(adapter, ERROR,
			    "data: priv not found. Drop RX packet\n");
		dev_kfree_skb_any(skb);
		return -1;
	}

	mwifiex_dbg_dump(adapter, DAT_D, "rx pkt:", skb->data,
			 min_t(size_t, skb->len, DEBUG_DUMP_DATA_MAX_LEN));

	memset(rx_info, 0, sizeof(*rx_info));
	rx_info->bss_num = priv->bss_num;
	rx_info->bss_type = priv->bss_type;

	if (priv->bss_role == MWIFIEX_BSS_ROLE_UAP)
		ret = mwifiex_process_uap_rx_packet(priv, skb);
	else
		ret = mwifiex_process_sta_rx_packet(priv, skb);

	return ret;
}
EXPORT_SYMBOL_GPL(mwifiex_handle_rx_packet);

/*
 * This function sends a packet to device.
 *
 * It processes the packet to add the TxPD, checks condition and
 * sends the processed packet to firmware for transmission.
 *
 * On successful completion, the function calls the completion callback
 * and logs the time.
 */
int mwifiex_process_tx(struct mwifiex_private *priv, struct sk_buff *skb,
		       struct mwifiex_tx_param *tx_param)
{
	int hroom, ret = -1;
	struct mwifiex_adapter *adapter = priv->adapter;
	u8 *head_ptr;
	struct txpd *local_tx_pd = NULL;
	struct mwifiex_sta_node *dest_node;
	struct ethhdr *hdr = (void *)skb->data;

	hroom = (adapter->iface_type == MWIFIEX_USB) ? 0 : INTF_HEADER_LEN;

	if (priv->bss_role == MWIFIEX_BSS_ROLE_UAP) {
		dest_node = mwifiex_get_sta_entry(priv, hdr->h_dest);
		if (dest_node) {
			dest_node->stats.tx_bytes += skb->len;
			dest_node->stats.tx_packets++;
		}

		head_ptr = mwifiex_process_uap_txpd(priv, skb);
	} else {
		head_ptr = mwifiex_process_sta_txpd(priv, skb);
	}

	if ((adapter->data_sent || adapter->tx_lock_flag) && head_ptr) {
		skb_queue_tail(&adapter->tx_data_q, skb);
		atomic_inc(&adapter->tx_queued);
		return 0;
	}

	if (head_ptr) {
		if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA)
			local_tx_pd = (struct txpd *)(head_ptr + hroom);
		if (adapter->iface_type == MWIFIEX_USB) {
			ret = adapter->if_ops.host_to_card(adapter,
							   priv->usb_port,
							   skb, NULL);
		} else {
			ret = adapter->if_ops.host_to_card(adapter,
							   MWIFIEX_TYPE_DATA,
							   skb, tx_param);
		}
	}
	mwifiex_dbg_dump(adapter, DAT_D, "tx pkt:", skb->data,
			 min_t(size_t, skb->len, DEBUG_DUMP_DATA_MAX_LEN));

	switch (ret) {
	case -ENOSR:
		mwifiex_dbg(adapter, DATA, "data: -ENOSR is returned\n");
		break;
	case -EBUSY:
		if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) &&
		    (adapter->pps_uapsd_mode) && (adapter->tx_lock_flag)) {
				priv->adapter->tx_lock_flag = false;
				if (local_tx_pd)
					local_tx_pd->flags = 0;
		}
		mwifiex_dbg(adapter, ERROR, "data: -EBUSY is returned\n");
		break;
	case -1:
		mwifiex_dbg(adapter, ERROR,
			    "mwifiex_write_data_async failed: 0x%X\n",
			    ret);
		adapter->dbg.num_tx_host_to_card_failure++;
		mwifiex_write_data_complete(adapter, skb, 0, ret);
		break;
	case -EINPROGRESS:
		break;
	case 0:
		mwifiex_write_data_complete(adapter, skb, 0, ret);
		break;
	default:
		break;
	}

	return ret;
}

static int mwifiex_host_to_card(struct mwifiex_adapter *adapter,
				struct sk_buff *skb,
				struct mwifiex_tx_param *tx_param)
{
	struct txpd *local_tx_pd = NULL;
	u8 *head_ptr = skb->data;
	int ret = 0;
	struct mwifiex_private *priv;
	struct mwifiex_txinfo *tx_info;

	tx_info = MWIFIEX_SKB_TXCB(skb);
	priv = mwifiex_get_priv_by_id(adapter, tx_info->bss_num,
				      tx_info->bss_type);
	if (!priv) {
		mwifiex_dbg(adapter, ERROR,
			    "data: priv not found. Drop TX packet\n");
		adapter->dbg.num_tx_host_to_card_failure++;
		mwifiex_write_data_complete(adapter, skb, 0, 0);
		return ret;
	}
	if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) {
		if (adapter->iface_type == MWIFIEX_USB)
			local_tx_pd = (struct txpd *)head_ptr;
		else
			local_tx_pd = (struct txpd *) (head_ptr +
				INTF_HEADER_LEN);
	}

	if (adapter->iface_type == MWIFIEX_USB) {
		ret = adapter->if_ops.host_to_card(adapter,
						   priv->usb_port,
						   skb, NULL);
	} else {
		ret = adapter->if_ops.host_to_card(adapter,
						   MWIFIEX_TYPE_DATA,
						   skb, tx_param);
	}
	switch (ret) {
	case -ENOSR:
		mwifiex_dbg(adapter, ERROR, "data: -ENOSR is returned\n");
		break;
	case -EBUSY:
		if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) &&
		    (adapter->pps_uapsd_mode) &&
		    (adapter->tx_lock_flag)) {
			priv->adapter->tx_lock_flag = false;
			if (local_tx_pd)
				local_tx_pd->flags = 0;
		}
		skb_queue_head(&adapter->tx_data_q, skb);
		if (tx_info->flags & MWIFIEX_BUF_FLAG_AGGR_PKT)
			atomic_add(tx_info->aggr_num, &adapter->tx_queued);
		else
			atomic_inc(&adapter->tx_queued);
		mwifiex_dbg(adapter, ERROR, "data: -EBUSY is returned\n");
		break;
	case -1:
		mwifiex_dbg(adapter, ERROR,
			    "mwifiex_write_data_async failed: 0x%X\n", ret);
		adapter->dbg.num_tx_host_to_card_failure++;
		mwifiex_write_data_complete(adapter, skb, 0, ret);
		break;
	case -EINPROGRESS:
		break;
	case 0:
		mwifiex_write_data_complete(adapter, skb, 0, ret);
		break;
	default:
		break;
	}
	return ret;
}

static int
mwifiex_dequeue_tx_queue(struct mwifiex_adapter *adapter)
{
	struct sk_buff *skb, *skb_next;
	struct mwifiex_txinfo *tx_info;
	struct mwifiex_tx_param tx_param;

	skb = skb_dequeue(&adapter->tx_data_q);
	if (!skb)
		return -1;

	tx_info = MWIFIEX_SKB_TXCB(skb);
	if (tx_info->flags & MWIFIEX_BUF_FLAG_AGGR_PKT)
		atomic_sub(tx_info->aggr_num, &adapter->tx_queued);
	else
		atomic_dec(&adapter->tx_queued);

	if (!skb_queue_empty(&adapter->tx_data_q))
		skb_next = skb_peek(&adapter->tx_data_q);
	else
		skb_next = NULL;
	tx_param.next_pkt_len = ((skb_next) ? skb_next->len : 0);
	if (!tx_param.next_pkt_len) {
		if (!mwifiex_wmm_lists_empty(adapter))
			tx_param.next_pkt_len = 1;
	}
	return mwifiex_host_to_card(adapter, skb, &tx_param);
}

void
mwifiex_process_tx_queue(struct mwifiex_adapter *adapter)
{
	do {
		if (adapter->data_sent || adapter->tx_lock_flag)
			break;
		if (mwifiex_dequeue_tx_queue(adapter))
			break;
	} while (!skb_queue_empty(&adapter->tx_data_q));
}

/*
 * Packet send completion callback handler.
 *
 * It either frees the buffer directly or forwards it to another
 * completion callback which checks conditions, updates statistics,
 * wakes up stalled traffic queue if required, and then frees the buffer.
 */
int mwifiex_write_data_complete(struct mwifiex_adapter *adapter,
				struct sk_buff *skb, int aggr, int status)
{
	struct mwifiex_private *priv;
	struct mwifiex_txinfo *tx_info;
	struct netdev_queue *txq;
	int index;

	if (!skb)
		return 0;

	tx_info = MWIFIEX_SKB_TXCB(skb);
	priv = mwifiex_get_priv_by_id(adapter, tx_info->bss_num,
				      tx_info->bss_type);
	if (!priv)
		goto done;

	mwifiex_set_trans_start(priv->netdev);
	if (!status) {
		priv->stats.tx_packets++;
		priv->stats.tx_bytes += tx_info->pkt_len;
		if (priv->tx_timeout_cnt)
			priv->tx_timeout_cnt = 0;
	} else {
		priv->stats.tx_errors++;
	}

	if (tx_info->flags & MWIFIEX_BUF_FLAG_BRIDGED_PKT)
		atomic_dec_return(&adapter->pending_bridged_pkts);

	if (tx_info->flags & MWIFIEX_BUF_FLAG_AGGR_PKT)
		goto done;

	if (aggr)
		/* For skb_aggr, do not wake up tx queue */
		goto done;

	atomic_dec(&adapter->tx_pending);

	index = mwifiex_1d_to_wmm_queue[skb->priority];
	if (atomic_dec_return(&priv->wmm_tx_pending[index]) < LOW_TX_PENDING) {
		txq = netdev_get_tx_queue(priv->netdev, index);
		if (netif_tx_queue_stopped(txq)) {
			netif_tx_wake_queue(txq);
			mwifiex_dbg(adapter, DATA, "wake queue: %d\n", index);
		}
	}
done:
	dev_kfree_skb_any(skb);

	return 0;
}
EXPORT_SYMBOL_GPL(mwifiex_write_data_complete);

void mwifiex_parse_tx_status_event(struct mwifiex_private *priv,
				   void *event_body)
{
	struct tx_status_event *tx_status = (void *)priv->adapter->event_body;
	struct sk_buff *ack_skb;
	unsigned long flags;
	struct mwifiex_txinfo *tx_info;

	if (!tx_status->tx_token_id)
		return;

	spin_lock_irqsave(&priv->ack_status_lock, flags);
	ack_skb = idr_find(&priv->ack_status_frames, tx_status->tx_token_id);
	if (ack_skb)
		idr_remove(&priv->ack_status_frames, tx_status->tx_token_id);
	spin_unlock_irqrestore(&priv->ack_status_lock, flags);

	if (ack_skb) {
		tx_info = MWIFIEX_SKB_TXCB(ack_skb);

		if (tx_info->flags & MWIFIEX_BUF_FLAG_EAPOL_TX_STATUS) {
			/* consumes ack_skb */
			skb_complete_wifi_ack(ack_skb, !tx_status->status);
		} else {
			/* Remove broadcast address which was added by driver */
			memmove(ack_skb->data +
				sizeof(struct ieee80211_hdr_3addr) +
				MWIFIEX_MGMT_FRAME_HEADER_SIZE + sizeof(u16),
				ack_skb->data +
				sizeof(struct ieee80211_hdr_3addr) +
				MWIFIEX_MGMT_FRAME_HEADER_SIZE + sizeof(u16) +
				ETH_ALEN, ack_skb->len -
				(sizeof(struct ieee80211_hdr_3addr) +
				MWIFIEX_MGMT_FRAME_HEADER_SIZE + sizeof(u16) +
				ETH_ALEN));
			ack_skb->len = ack_skb->len - ETH_ALEN;
			/* Remove driver's proprietary header including 2 bytes
			 * of packet length and pass actual management frame buffer
			 * to cfg80211.
			 */
			cfg80211_mgmt_tx_status(&priv->wdev, tx_info->cookie,
						ack_skb->data +
						MWIFIEX_MGMT_FRAME_HEADER_SIZE +
						sizeof(u16), ack_skb->len -
						(MWIFIEX_MGMT_FRAME_HEADER_SIZE
						 + sizeof(u16)),
						!tx_status->status, GFP_ATOMIC);
			dev_kfree_skb_any(ack_skb);
		}
	}
}
Commit	Line	Data
5e6e3a92 BZ	1	/*
	2	* Marvell Wireless LAN device driver: generic TX/RX data handling
	3	*
65da33f5	4	* Copyright (C) 2011-2014, Marvell International Ltd.
5e6e3a92 BZ	5	*
	6	* This software file (the "File") is distributed by Marvell International
	7	* Ltd. under the terms of the GNU General Public License Version 2, June 1991
	8	* (the "License"). You may use, redistribute and/or modify this File in
	9	* accordance with the terms and conditions of the License, a copy of which
	10	* is available by writing to the Free Software Foundation, Inc.,
	11	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
	12	* worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
	13	*
	14	* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
	16	* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
	17	* this warranty disclaimer.
	18	*/
	19
	20	#include "decl.h"
	21	#include "ioctl.h"
	22	#include "util.h"
	23	#include "fw.h"
	24	#include "main.h"
	25	#include "wmm.h"
	26
	27	/*
	28	* This function processes the received buffer.
	29	*
	30	* Main responsibility of this function is to parse the RxPD to
	31	* identify the correct interface this packet is headed for and
	32	* forwarding it to the associated handling function, where the
	33	* packet will be further processed and sent to kernel/upper layer
	34	* if required.
	35	*/
	36	int mwifiex_handle_rx_packet(struct mwifiex_adapter *adapter,
	37	struct sk_buff *skb)
	38	{
5e6e3a92 BZ	39	struct mwifiex_private *priv =
	40	mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
	41	struct rxpd *local_rx_pd;
	42	struct mwifiex_rxinfo *rx_info = MWIFIEX_SKB_RXCB(skb);
ca8d6dfc	43	int ret;
5e6e3a92 BZ	44
	45	local_rx_pd = (struct rxpd *) (skb->data);
	46	/* Get the BSS number from rxpd, get corresponding priv */
	47	priv = mwifiex_get_priv_by_id(adapter, local_rx_pd->bss_num &
	48	BSS_NUM_MASK, local_rx_pd->bss_type);
	49	if (!priv)
	50	priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
	51
f3b369e4	52	if (!priv) {
acebe8c1 ZL	53	mwifiex_dbg(adapter, ERROR,
acebe8c1 ZL	54	"data: priv not found. Drop RX packet\n");
f3b369e4 AP	55	dev_kfree_skb_any(skb);
	56	return -1;
	57	}
	58
868093a9 ZL	59	mwifiex_dbg_dump(adapter, DAT_D, "rx pkt:", skb->data,
	60	min_t(size_t, skb->len, DEBUG_DUMP_DATA_MAX_LEN));
	61
701a9e61	62	memset(rx_info, 0, sizeof(*rx_info));
9da9a3b2 YAP	63	rx_info->bss_num = priv->bss_num;
9da9a3b2 YAP	64	rx_info->bss_type = priv->bss_type;
5e6e3a92	65
838e4f44	66	if (priv->bss_role == MWIFIEX_BSS_ROLE_UAP)
ca8d6dfc UR	67	ret = mwifiex_process_uap_rx_packet(priv, skb);
	68	else
	69	ret = mwifiex_process_sta_rx_packet(priv, skb);
838e4f44	70
ca8d6dfc	71	return ret;
5e6e3a92 BZ	72	}
	73	EXPORT_SYMBOL_GPL(mwifiex_handle_rx_packet);
	74
	75	/*
	76	* This function sends a packet to device.
	77	*
	78	* It processes the packet to add the TxPD, checks condition and
	79	* sends the processed packet to firmware for transmission.
	80	*
	81	* On successful completion, the function calls the completion callback
	82	* and logs the time.
	83	*/
	84	int mwifiex_process_tx(struct mwifiex_private priv, struct sk_buff skb,
	85	struct mwifiex_tx_param *tx_param)
	86	{
4ce7bc0a	87	int hroom, ret = -1;
5e6e3a92	88	struct mwifiex_adapter *adapter = priv->adapter;
270e58e8	89	u8 *head_ptr;
5e6e3a92	90	struct txpd *local_tx_pd = NULL;
442f6f9b XH	91	struct mwifiex_sta_node *dest_node;
442f6f9b XH	92	struct ethhdr hdr = (void )skb->data;
5e6e3a92	93
4ce7bc0a ZL	94	hroom = (adapter->iface_type == MWIFIEX_USB) ? 0 : INTF_HEADER_LEN;
4ce7bc0a ZL	95
442f6f9b XH	96	if (priv->bss_role == MWIFIEX_BSS_ROLE_UAP) {
	97	dest_node = mwifiex_get_sta_entry(priv, hdr->h_dest);
	98	if (dest_node) {
	99	dest_node->stats.tx_bytes += skb->len;
	100	dest_node->stats.tx_packets++;
	101	}
	102
4ac8764a	103	head_ptr = mwifiex_process_uap_txpd(priv, skb);
442f6f9b	104	} else {
4ac8764a	105	head_ptr = mwifiex_process_sta_txpd(priv, skb);
442f6f9b	106	}
4ac8764a	107
e35000ea ZL	108	if ((adapter->data_sent \|\| adapter->tx_lock_flag) && head_ptr) {
	109	skb_queue_tail(&adapter->tx_data_q, skb);
	110	atomic_inc(&adapter->tx_queued);
	111	return 0;
	112	}
	113
5e6e3a92 BZ	114	if (head_ptr) {
5e6e3a92 BZ	115	if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA)
4ce7bc0a	116	local_tx_pd = (struct txpd *)(head_ptr + hroom);
4daffe35	117	if (adapter->iface_type == MWIFIEX_USB) {
4daffe35	118	ret = adapter->if_ops.host_to_card(adapter,
735ab6bf	119	priv->usb_port,
4daffe35 AK	120	skb, NULL);
	121	} else {
	122	ret = adapter->if_ops.host_to_card(adapter,
	123	MWIFIEX_TYPE_DATA,
	124	skb, tx_param);
	125	}
5e6e3a92	126	}
868093a9 ZL	127	mwifiex_dbg_dump(adapter, DAT_D, "tx pkt:", skb->data,
868093a9 ZL	128	min_t(size_t, skb->len, DEBUG_DUMP_DATA_MAX_LEN));
5e6e3a92 BZ	129
5e6e3a92 BZ	130	switch (ret) {
4daffe35	131	case -ENOSR:
17090bee	132	mwifiex_dbg(adapter, DATA, "data: -ENOSR is returned\n");
4daffe35	133	break;
5e6e3a92 BZ	134	case -EBUSY:
5e6e3a92 BZ	135	if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) &&
c65a30f3	136	(adapter->pps_uapsd_mode) && (adapter->tx_lock_flag)) {
5e6e3a92	137	priv->adapter->tx_lock_flag = false;
3d82de0f YAP	138	if (local_tx_pd)
3d82de0f YAP	139	local_tx_pd->flags = 0;
5e6e3a92	140	}
acebe8c1	141	mwifiex_dbg(adapter, ERROR, "data: -EBUSY is returned\n");
5e6e3a92 BZ	142	break;
5e6e3a92 BZ	143	case -1:
acebe8c1 ZL	144	mwifiex_dbg(adapter, ERROR,
	145	"mwifiex_write_data_async failed: 0x%X\n",
	146	ret);
5e6e3a92	147	adapter->dbg.num_tx_host_to_card_failure++;
47411a06	148	mwifiex_write_data_complete(adapter, skb, 0, ret);
5e6e3a92 BZ	149	break;
5e6e3a92 BZ	150	case -EINPROGRESS:
5e6e3a92 BZ	151	break;
5e6e3a92 BZ	152	case 0:
47411a06	153	mwifiex_write_data_complete(adapter, skb, 0, ret);
5e6e3a92 BZ	154	break;
	155	default:
	156	break;
	157	}
	158
	159	return ret;
	160	}
	161
e35000ea ZL	162	static int mwifiex_host_to_card(struct mwifiex_adapter *adapter,
	163	struct sk_buff *skb,
	164	struct mwifiex_tx_param *tx_param)
	165	{
	166	struct txpd *local_tx_pd = NULL;
	167	u8 *head_ptr = skb->data;
	168	int ret = 0;
	169	struct mwifiex_private *priv;
	170	struct mwifiex_txinfo *tx_info;
	171
	172	tx_info = MWIFIEX_SKB_TXCB(skb);
	173	priv = mwifiex_get_priv_by_id(adapter, tx_info->bss_num,
	174	tx_info->bss_type);
	175	if (!priv) {
acebe8c1 ZL	176	mwifiex_dbg(adapter, ERROR,
acebe8c1 ZL	177	"data: priv not found. Drop TX packet\n");
e35000ea ZL	178	adapter->dbg.num_tx_host_to_card_failure++;
	179	mwifiex_write_data_complete(adapter, skb, 0, 0);
	180	return ret;
	181	}
	182	if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) {
	183	if (adapter->iface_type == MWIFIEX_USB)
	184	local_tx_pd = (struct txpd *)head_ptr;
	185	else
	186	local_tx_pd = (struct txpd *) (head_ptr +
	187	INTF_HEADER_LEN);
	188	}
	189
	190	if (adapter->iface_type == MWIFIEX_USB) {
e35000ea	191	ret = adapter->if_ops.host_to_card(adapter,
735ab6bf	192	priv->usb_port,
e35000ea ZL	193	skb, NULL);
	194	} else {
	195	ret = adapter->if_ops.host_to_card(adapter,
	196	MWIFIEX_TYPE_DATA,
	197	skb, tx_param);
	198	}
	199	switch (ret) {
	200	case -ENOSR:
acebe8c1	201	mwifiex_dbg(adapter, ERROR, "data: -ENOSR is returned\n");
e35000ea ZL	202	break;
	203	case -EBUSY:
	204	if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) &&
	205	(adapter->pps_uapsd_mode) &&
	206	(adapter->tx_lock_flag)) {
	207	priv->adapter->tx_lock_flag = false;
	208	if (local_tx_pd)
	209	local_tx_pd->flags = 0;
	210	}
	211	skb_queue_head(&adapter->tx_data_q, skb);
	212	if (tx_info->flags & MWIFIEX_BUF_FLAG_AGGR_PKT)
	213	atomic_add(tx_info->aggr_num, &adapter->tx_queued);
	214	else
	215	atomic_inc(&adapter->tx_queued);
acebe8c1	216	mwifiex_dbg(adapter, ERROR, "data: -EBUSY is returned\n");
e35000ea ZL	217	break;
e35000ea ZL	218	case -1:
acebe8c1 ZL	219	mwifiex_dbg(adapter, ERROR,
acebe8c1 ZL	220	"mwifiex_write_data_async failed: 0x%X\n", ret);
e35000ea ZL	221	adapter->dbg.num_tx_host_to_card_failure++;
	222	mwifiex_write_data_complete(adapter, skb, 0, ret);
	223	break;
	224	case -EINPROGRESS:
e35000ea ZL	225	break;
	226	case 0:
	227	mwifiex_write_data_complete(adapter, skb, 0, ret);
	228	break;
	229	default:
	230	break;
	231	}
	232	return ret;
	233	}
	234
	235	static int
	236	mwifiex_dequeue_tx_queue(struct mwifiex_adapter *adapter)
	237	{
	238	struct sk_buff skb, skb_next;
	239	struct mwifiex_txinfo *tx_info;
	240	struct mwifiex_tx_param tx_param;
	241
	242	skb = skb_dequeue(&adapter->tx_data_q);
	243	if (!skb)
	244	return -1;
	245
	246	tx_info = MWIFIEX_SKB_TXCB(skb);
	247	if (tx_info->flags & MWIFIEX_BUF_FLAG_AGGR_PKT)
	248	atomic_sub(tx_info->aggr_num, &adapter->tx_queued);
	249	else
	250	atomic_dec(&adapter->tx_queued);
	251
	252	if (!skb_queue_empty(&adapter->tx_data_q))
	253	skb_next = skb_peek(&adapter->tx_data_q);
	254	else
	255	skb_next = NULL;
	256	tx_param.next_pkt_len = ((skb_next) ? skb_next->len : 0);
	257	if (!tx_param.next_pkt_len) {
	258	if (!mwifiex_wmm_lists_empty(adapter))
	259	tx_param.next_pkt_len = 1;
	260	}
	261	return mwifiex_host_to_card(adapter, skb, &tx_param);
	262	}
	263
	264	void
	265	mwifiex_process_tx_queue(struct mwifiex_adapter *adapter)
	266	{
	267	do {
	268	if (adapter->data_sent \|\| adapter->tx_lock_flag)
	269	break;
	270	if (mwifiex_dequeue_tx_queue(adapter))
	271	break;
	272	} while (!skb_queue_empty(&adapter->tx_data_q));
	273	}
	274
5e6e3a92 BZ	275	/*
	276	* Packet send completion callback handler.
	277	*
	278	* It either frees the buffer directly or forwards it to another
	279	* completion callback which checks conditions, updates statistics,
	280	* wakes up stalled traffic queue if required, and then frees the buffer.
	281	*/
	282	int mwifiex_write_data_complete(struct mwifiex_adapter *adapter,
47411a06	283	struct sk_buff *skb, int aggr, int status)
5e6e3a92	284	{
47411a06	285	struct mwifiex_private *priv;
270e58e8	286	struct mwifiex_txinfo *tx_info;
47411a06 AP	287	struct netdev_queue *txq;
47411a06 AP	288	int index;
5e6e3a92 BZ	289
	290	if (!skb)
	291	return 0;
	292
	293	tx_info = MWIFIEX_SKB_TXCB(skb);
9da9a3b2	294	priv = mwifiex_get_priv_by_id(adapter, tx_info->bss_num,
c65a30f3	295	tx_info->bss_type);
5e6e3a92 BZ	296	if (!priv)
	297	goto done;
	298
bbea3bc4	299	mwifiex_set_trans_start(priv->netdev);
5e6e3a92 BZ	300	if (!status) {
5e6e3a92 BZ	301	priv->stats.tx_packets++;
a1ed4849	302	priv->stats.tx_bytes += tx_info->pkt_len;
8908c7d5 AN	303	if (priv->tx_timeout_cnt)
8908c7d5 AN	304	priv->tx_timeout_cnt = 0;
5e6e3a92 BZ	305	} else {
	306	priv->stats.tx_errors++;
	307	}
62a5b7dc	308
ec264a43	309	if (tx_info->flags & MWIFIEX_BUF_FLAG_BRIDGED_PKT)
838e4f44	310	atomic_dec_return(&adapter->pending_bridged_pkts);
ec264a43 XH	311
	312	if (tx_info->flags & MWIFIEX_BUF_FLAG_AGGR_PKT)
	313	goto done;
47411a06 AP	314
	315	if (aggr)
	316	/* For skb_aggr, do not wake up tx queue */
62a5b7dc	317	goto done;
5e6e3a92	318
47411a06	319	atomic_dec(&adapter->tx_pending);
5e6e3a92	320
47411a06 AP	321	index = mwifiex_1d_to_wmm_queue[skb->priority];
	322	if (atomic_dec_return(&priv->wmm_tx_pending[index]) < LOW_TX_PENDING) {
	323	txq = netdev_get_tx_queue(priv->netdev, index);
	324	if (netif_tx_queue_stopped(txq)) {
	325	netif_tx_wake_queue(txq);
acebe8c1	326	mwifiex_dbg(adapter, DATA, "wake queue: %d\n", index);
47411a06	327	}
5e6e3a92 BZ	328	}
	329	done:
	330	dev_kfree_skb_any(skb);
	331
	332	return 0;
	333	}
4daffe35	334	EXPORT_SYMBOL_GPL(mwifiex_write_data_complete);
5e6e3a92	335
808bbebc AK	336	void mwifiex_parse_tx_status_event(struct mwifiex_private *priv,
	337	void *event_body)
	338	{
	339	struct tx_status_event tx_status = (void )priv->adapter->event_body;
	340	struct sk_buff *ack_skb;
	341	unsigned long flags;
18ca4382	342	struct mwifiex_txinfo *tx_info;
808bbebc AK	343
	344	if (!tx_status->tx_token_id)
	345	return;
	346
	347	spin_lock_irqsave(&priv->ack_status_lock, flags);
	348	ack_skb = idr_find(&priv->ack_status_frames, tx_status->tx_token_id);
	349	if (ack_skb)
	350	idr_remove(&priv->ack_status_frames, tx_status->tx_token_id);
	351	spin_unlock_irqrestore(&priv->ack_status_lock, flags);
	352
18ca4382 AK	353	if (ack_skb) {
	354	tx_info = MWIFIEX_SKB_TXCB(ack_skb);
	355
	356	if (tx_info->flags & MWIFIEX_BUF_FLAG_EAPOL_TX_STATUS) {
	357	/* consumes ack_skb */
	358	skb_complete_wifi_ack(ack_skb, !tx_status->status);
	359	} else {
ae86c587 AN	360	/* Remove broadcast address which was added by driver */
	361	memmove(ack_skb->data +
	362	sizeof(struct ieee80211_hdr_3addr) +
	363	MWIFIEX_MGMT_FRAME_HEADER_SIZE + sizeof(u16),
	364	ack_skb->data +
	365	sizeof(struct ieee80211_hdr_3addr) +
	366	MWIFIEX_MGMT_FRAME_HEADER_SIZE + sizeof(u16) +
	367	ETH_ALEN, ack_skb->len -
	368	(sizeof(struct ieee80211_hdr_3addr) +
	369	MWIFIEX_MGMT_FRAME_HEADER_SIZE + sizeof(u16) +
	370	ETH_ALEN));
	371	ack_skb->len = ack_skb->len - ETH_ALEN;
	372	/* Remove driver's proprietary header including 2 bytes
	373	* of packet length and pass actual management frame buffer
	374	* to cfg80211.
	375	*/
4facc34a	376	cfg80211_mgmt_tx_status(&priv->wdev, tx_info->cookie,
ae86c587 AN	377	ack_skb->data +
	378	MWIFIEX_MGMT_FRAME_HEADER_SIZE +
	379	sizeof(u16), ack_skb->len -
	380	(MWIFIEX_MGMT_FRAME_HEADER_SIZE
	381	+ sizeof(u16)),
18ca4382 AK	382	!tx_status->status, GFP_ATOMIC);
	383	dev_kfree_skb_any(ack_skb);
	384	}
	385	}
808bbebc	386	}