[thirdparty/linux.git] / drivers / staging / vt6656 / usbpipe.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
 * All rights reserved.
 *
 * File: usbpipe.c
 *
 * Purpose: Handle USB control endpoint
 *
 * Author: Warren Hsu
 *
 * Date: Mar. 29, 2005
 *
 * Functions:
 *	vnt_control_out - Write variable length bytes to MEM/BB/MAC/EEPROM
 *	vnt_control_in - Read variable length bytes from MEM/BB/MAC/EEPROM
 *	vnt_control_out_u8 - Write one byte to MEM/BB/MAC/EEPROM
 *	vnt_control_in_u8 - Read one byte from MEM/BB/MAC/EEPROM
 *
 * Revision History:
 *      04-05-2004 Jerry Chen: Initial release
 *      11-24-2004 Warren Hsu: Add ControlvWriteByte,ControlvReadByte,
 *                             ControlvMaskByte
 *
 */

#include "rxtx.h"
#include "desc.h"
#include "device.h"
#include "usbpipe.h"
#include "mac.h"
#include "rf.h"

#define USB_CTL_WAIT	500 /* ms */

int vnt_control_out(struct vnt_private *priv, u8 request, u16 value,
		    u16 index, u16 length, const u8 *buffer)
{
	int ret = 0;
	u8 *usb_buffer;

	if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
		ret = -EINVAL;
		goto end;
	}

	mutex_lock(&priv->usb_lock);

	usb_buffer = kmemdup(buffer, length, GFP_KERNEL);
	if (!usb_buffer) {
		ret = -ENOMEM;
		goto end_unlock;
	}

	ret = usb_control_msg(priv->usb,
			      usb_sndctrlpipe(priv->usb, 0),
			      request, 0x40, value,
			      index, usb_buffer, length, USB_CTL_WAIT);

	kfree(usb_buffer);

	if (ret == (int)length)
		ret = 0;
	else
		ret = -EIO;

end_unlock:
	mutex_unlock(&priv->usb_lock);
end:
	return ret;
}

int vnt_control_out_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 data)
{
	return vnt_control_out(priv, MESSAGE_TYPE_WRITE,
			       reg_off, reg, sizeof(u8), &data);
}

int vnt_control_out_blocks(struct vnt_private *priv,
			   u16 block, u8 reg, u16 length, u8 *data)
{
	int ret = 0, i;

	for (i = 0; i < length; i += block) {
		u16 len = min_t(int, length - i, block);

		ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE,
				      i, reg, len, data + i);
		if (ret)
			goto end;
	}
end:
	return ret;
}

int vnt_control_in(struct vnt_private *priv, u8 request, u16 value,
		   u16 index, u16 length, u8 *buffer)
{
	int ret = 0;
	u8 *usb_buffer;

	if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
		ret = -EINVAL;
		goto end;
	}

	mutex_lock(&priv->usb_lock);

	usb_buffer = kmalloc(length, GFP_KERNEL);
	if (!usb_buffer) {
		ret = -ENOMEM;
		goto end_unlock;
	}

	ret = usb_control_msg(priv->usb,
			      usb_rcvctrlpipe(priv->usb, 0),
			      request, 0xc0, value,
			      index, usb_buffer, length, USB_CTL_WAIT);

	if (ret == length)
		memcpy(buffer, usb_buffer, length);

	kfree(usb_buffer);

	if (ret == (int)length)
		ret = 0;
	else
		ret = -EIO;

end_unlock:
	mutex_unlock(&priv->usb_lock);
end:
	return ret;
}

int vnt_control_in_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 *data)
{
	return vnt_control_in(priv, MESSAGE_TYPE_READ,
			      reg_off, reg, sizeof(u8), data);
}

static int vnt_int_report_rate(struct vnt_private *priv, u8 pkt_no, u8 tsr)
{
	struct vnt_usb_send_context *context;
	struct ieee80211_tx_info *info;
	u8 tx_retry = (tsr & 0xf0) >> 4;
	s8 idx;

	if (pkt_no >= priv->num_tx_context)
		return -EINVAL;

	context = priv->tx_context[pkt_no];

	if (!context->skb)
		return -EINVAL;

	info = IEEE80211_SKB_CB(context->skb);
	idx = info->control.rates[0].idx;

	ieee80211_tx_info_clear_status(info);

	info->status.rates[0].count = tx_retry;

	if (!(tsr & TSR_TMO)) {
		info->status.rates[0].idx = idx;

		if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
			info->flags |= IEEE80211_TX_STAT_ACK;
	}

	ieee80211_tx_status_irqsafe(priv->hw, context->skb);

	context->in_use = false;

	return 0;
}

static void vnt_int_process_data(struct vnt_private *priv)
{
	struct vnt_interrupt_data *int_data;
	struct ieee80211_low_level_stats *low_stats = &priv->low_stats;

	dev_dbg(&priv->usb->dev, "---->s_nsInterruptProcessData\n");

	int_data = (struct vnt_interrupt_data *)priv->int_buf.data_buf;

	if (int_data->tsr0 & TSR_VALID)
		vnt_int_report_rate(priv, int_data->pkt0, int_data->tsr0);

	if (int_data->tsr1 & TSR_VALID)
		vnt_int_report_rate(priv, int_data->pkt1, int_data->tsr1);

	if (int_data->tsr2 & TSR_VALID)
		vnt_int_report_rate(priv, int_data->pkt2, int_data->tsr2);

	if (int_data->tsr3 & TSR_VALID)
		vnt_int_report_rate(priv, int_data->pkt3, int_data->tsr3);

	if (int_data->isr0 != 0) {
		if (int_data->isr0 & ISR_BNTX &&
		    priv->op_mode == NL80211_IFTYPE_AP)
			vnt_schedule_command(priv, WLAN_CMD_BECON_SEND);

		if (int_data->isr0 & ISR_TBTT &&
		    priv->hw->conf.flags & IEEE80211_CONF_PS) {
			if (!priv->wake_up_count)
				priv->wake_up_count =
					priv->hw->conf.listen_interval;

			if (priv->wake_up_count)
				--priv->wake_up_count;

			/* Turn on wake up to listen next beacon */
			if (priv->wake_up_count == 1)
				vnt_schedule_command(priv,
						     WLAN_CMD_TBTT_WAKEUP);
		}
		priv->current_tsf = le64_to_cpu(int_data->tsf);

		low_stats->dot11RTSSuccessCount += int_data->rts_success;
		low_stats->dot11RTSFailureCount += int_data->rts_fail;
		low_stats->dot11ACKFailureCount += int_data->ack_fail;
		low_stats->dot11FCSErrorCount += int_data->fcs_err;
	}
}

static void vnt_start_interrupt_urb_complete(struct urb *urb)
{
	struct vnt_private *priv = urb->context;
	int status = urb->status;

	switch (status) {
	case 0:
	case -ETIMEDOUT:
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		return;
	default:
		break;
	}

	if (status)
		dev_dbg(&priv->usb->dev, "%s status = %d\n", __func__, status);
	else
		vnt_int_process_data(priv);

	status = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC);
	if (status)
		dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", status);
}

int vnt_start_interrupt_urb(struct vnt_private *priv)
{
	int ret = 0;

	dev_dbg(&priv->usb->dev, "---->Interrupt Polling Thread\n");

	usb_fill_int_urb(priv->interrupt_urb,
			 priv->usb,
			 usb_rcvintpipe(priv->usb, 1),
			 priv->int_buf.data_buf,
			 MAX_INTERRUPT_SIZE,
			 vnt_start_interrupt_urb_complete,
			 priv,
			 priv->int_interval);

	ret = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC);
	if (ret)
		dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", ret);

	return ret;
}

static int vnt_rx_data(struct vnt_private *priv, struct vnt_rcb *ptr_rcb,
		       unsigned long bytes_received)
{
	struct ieee80211_hw *hw = priv->hw;
	struct ieee80211_supported_band *sband;
	struct sk_buff *skb;
	struct ieee80211_rx_status *rx_status;
	struct vnt_rx_header *head;
	struct vnt_rx_tail *tail;
	u32 frame_size;
	int ii;
	u16 rx_bitrate, pay_load_with_padding;
	u8 rate_idx = 0;
	long rx_dbm;

	skb = ptr_rcb->skb;
	rx_status = IEEE80211_SKB_RXCB(skb);

	/* [31:16]RcvByteCount ( not include 4-byte Status ) */
	head = (struct vnt_rx_header *)skb->data;
	frame_size = head->wbk_status >> 16;
	frame_size += 4;

	if (bytes_received != frame_size) {
		dev_dbg(&priv->usb->dev, "------- WRONG Length 1\n");
		return false;
	}

	if ((bytes_received > 2372) || (bytes_received <= 40)) {
		/* Frame Size error drop this packet.*/
		dev_dbg(&priv->usb->dev, "------ WRONG Length 2\n");
		return false;
	}

	/* real Frame Size = USBframe_size -4WbkStatus - 4RxStatus */
	/* -8TSF - 4RSR - 4SQ3 - ?Padding */

	/* if SQ3 the range is 24~27, if no SQ3 the range is 20~23 */

	/*Fix hardware bug => PLCP_Length error */
	if (((bytes_received - head->pay_load_len) > 27) ||
	    ((bytes_received - head->pay_load_len) < 24) ||
	    (bytes_received < head->pay_load_len)) {
		dev_dbg(&priv->usb->dev, "Wrong PLCP Length %x\n",
			head->pay_load_len);
		return false;
	}

	sband = hw->wiphy->bands[hw->conf.chandef.chan->band];
	rx_bitrate = head->rx_rate * 5; /* rx_rate * 5 */

	for (ii = 0; ii < sband->n_bitrates; ii++) {
		if (sband->bitrates[ii].bitrate == rx_bitrate) {
			rate_idx = ii;
				break;
		}
	}

	if (ii == sband->n_bitrates) {
		dev_dbg(&priv->usb->dev, "Wrong Rx Bit Rate %d\n", rx_bitrate);
		return false;
	}

	pay_load_with_padding = ((head->pay_load_len / 4) +
		((head->pay_load_len % 4) ? 1 : 0)) * 4;

	tail = (struct vnt_rx_tail *)(skb->data +
				      sizeof(*head) + pay_load_with_padding);
	priv->tsf_time = le64_to_cpu(tail->tsf_time);

	if (tail->rsr & (RSR_IVLDTYP | RSR_IVLDLEN))
		return false;

	vnt_rf_rssi_to_dbm(priv, tail->rssi, &rx_dbm);

	priv->bb_pre_ed_rssi = (u8)-rx_dbm + 1;
	priv->current_rssi = priv->bb_pre_ed_rssi;

	skb_pull(skb, sizeof(*head));
	skb_trim(skb, head->pay_load_len);

	rx_status->mactime = priv->tsf_time;
	rx_status->band = hw->conf.chandef.chan->band;
	rx_status->signal = rx_dbm;
	rx_status->flag = 0;
	rx_status->freq = hw->conf.chandef.chan->center_freq;

	if (!(tail->rsr & RSR_CRCOK))
		rx_status->flag |= RX_FLAG_FAILED_FCS_CRC;

	rx_status->rate_idx = rate_idx;

	if (tail->new_rsr & NEWRSR_DECRYPTOK)
		rx_status->flag |= RX_FLAG_DECRYPTED;

	ieee80211_rx_irqsafe(priv->hw, skb);

	return true;
}

static void vnt_submit_rx_urb_complete(struct urb *urb)
{
	struct vnt_rcb *rcb = urb->context;
	struct vnt_private *priv = rcb->priv;

	switch (urb->status) {
	case 0:
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		return;
	case -ETIMEDOUT:
	default:
		dev_dbg(&priv->usb->dev, "BULK In failed %d\n", urb->status);
		break;
	}

	if (urb->actual_length) {
		if (vnt_rx_data(priv, rcb, urb->actual_length)) {
			rcb->skb = dev_alloc_skb(priv->rx_buf_sz);
			if (!rcb->skb)
				return;
		} else {
			skb_push(rcb->skb, skb_headroom(rcb->skb));
			skb_trim(rcb->skb, 0);
		}

		urb->transfer_buffer = skb_put(rcb->skb,
					       skb_tailroom(rcb->skb));
	}

	if (usb_submit_urb(urb, GFP_ATOMIC))
		dev_dbg(&priv->usb->dev, "Failed to re submit rx skb\n");
}

int vnt_submit_rx_urb(struct vnt_private *priv, struct vnt_rcb *rcb)
{
	int ret = 0;
	struct urb *urb = rcb->urb;

	if (!rcb->skb) {
		dev_dbg(&priv->usb->dev, "rcb->skb is null\n");
		ret = -EINVAL;
		goto end;
	}

	usb_fill_bulk_urb(urb,
			  priv->usb,
			  usb_rcvbulkpipe(priv->usb, 2),
			  skb_put(rcb->skb, skb_tailroom(rcb->skb)),
			  MAX_TOTAL_SIZE_WITH_ALL_HEADERS,
			  vnt_submit_rx_urb_complete,
			  rcb);

	ret = usb_submit_urb(urb, GFP_ATOMIC);
	if (ret)
		dev_dbg(&priv->usb->dev, "Submit Rx URB failed %d\n", ret);
end:
	return ret;
}

static void vnt_tx_context_complete(struct urb *urb)
{
	struct vnt_usb_send_context *context = urb->context;
	struct vnt_private *priv = context->priv;

	switch (urb->status) {
	case 0:
		dev_dbg(&priv->usb->dev, "Write %d bytes\n", context->buf_len);
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		context->in_use = false;
		return;
	case -ETIMEDOUT:
	default:
		dev_dbg(&priv->usb->dev, "BULK Out failed %d\n", urb->status);
		break;
	}

	if (context->type == CONTEXT_DATA_PACKET)
		ieee80211_wake_queues(priv->hw);

	if (urb->status || context->type == CONTEXT_BEACON_PACKET) {
		if (context->skb)
			ieee80211_free_txskb(priv->hw, context->skb);

		context->in_use = false;
	}
}

int vnt_tx_context(struct vnt_private *priv,
		   struct vnt_usb_send_context *context)
{
	int status;
	struct urb *urb = context->urb;

	if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
		context->in_use = false;
		return -ENODEV;
	}

	usb_fill_bulk_urb(urb,
			  priv->usb,
			  usb_sndbulkpipe(priv->usb, 3),
			  context->data,
			  context->buf_len,
			  vnt_tx_context_complete,
			  context);

	status = usb_submit_urb(urb, GFP_ATOMIC);
	if (status) {
		dev_dbg(&priv->usb->dev, "Submit Tx URB failed %d\n", status);

		context->in_use = false;
	}

	return status;
}
Commit	Line	Data
6b4c6ce8	1	// SPDX-License-Identifier: GPL-2.0+
92b96797 FB	2	/*
	3	* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
	4	* All rights reserved.
	5	*
92b96797 FB	6	* File: usbpipe.c
	7	*
	8	* Purpose: Handle USB control endpoint
	9	*
	10	* Author: Warren Hsu
	11	*
	12	* Date: Mar. 29, 2005
	13	*
	14	* Functions:
1390b02a	15	* vnt_control_out - Write variable length bytes to MEM/BB/MAC/EEPROM
441c21c3	16	* vnt_control_in - Read variable length bytes from MEM/BB/MAC/EEPROM
285d58c4	17	* vnt_control_out_u8 - Write one byte to MEM/BB/MAC/EEPROM
53742906	18	* vnt_control_in_u8 - Read one byte from MEM/BB/MAC/EEPROM
92b96797 FB	19	*
92b96797 FB	20	* Revision History:
3b1d7533 AJ	21	* 04-05-2004 Jerry Chen: Initial release
	22	* 11-24-2004 Warren Hsu: Add ControlvWriteByte,ControlvReadByte,
	23	* ControlvMaskByte
92b96797 FB	24	*
	25	*/
	26
92b96797	27	#include "rxtx.h"
92b96797	28	#include "desc.h"
92b96797	29	#include "device.h"
62c8526d	30	#include "usbpipe.h"
10e9a359	31	#include "mac.h"
3c505f50	32	#include "rf.h"
92b96797	33
b2435179	34	#define USB_CTL_WAIT 500 /* ms */
92b96797	35
1390b02a	36	int vnt_control_out(struct vnt_private *priv, u8 request, u16 value,
747a64bd	37	u16 index, u16 length, const u8 *buffer)
92b96797	38	{
59608cb1	39	int ret = 0;
12ecd24e	40	u8 *usb_buffer;
92b96797	41
59608cb1 QD	42	if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
	43	ret = -EINVAL;
	44	goto end;
	45	}
e1feda13	46
0f06a739	47	mutex_lock(&priv->usb_lock);
c91b1869	48
12ecd24e MP	49	usb_buffer = kmemdup(buffer, length, GFP_KERNEL);
12ecd24e MP	50	if (!usb_buffer) {
59608cb1 QD	51	ret = -ENOMEM;
59608cb1 QD	52	goto end_unlock;
12ecd24e MP	53	}
12ecd24e MP	54
59608cb1 QD	55	ret = usb_control_msg(priv->usb,
	56	usb_sndctrlpipe(priv->usb, 0),
	57	request, 0x40, value,
	58	index, usb_buffer, length, USB_CTL_WAIT);
12ecd24e MP	59
12ecd24e MP	60	kfree(usb_buffer);
ae5943de	61
58c3e681 MP	62	if (ret == (int)length)
	63	ret = 0;
	64	else
59608cb1	65	ret = -EIO;
ae5943de	66
59608cb1 QD	67	end_unlock:
	68	mutex_unlock(&priv->usb_lock);
	69	end:
	70	return ret;
92b96797 FB	71	}
92b96797 FB	72
59608cb1	73	int vnt_control_out_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 data)
285d58c4	74	{
59608cb1 QD	75	return vnt_control_out(priv, MESSAGE_TYPE_WRITE,
59608cb1 QD	76	reg_off, reg, sizeof(u8), &data);
285d58c4 MP	77	}
285d58c4 MP	78
69cc1f92 MP	79	int vnt_control_out_blocks(struct vnt_private *priv,
	80	u16 block, u8 reg, u16 length, u8 *data)
	81	{
	82	int ret = 0, i;
	83
	84	for (i = 0; i < length; i += block) {
	85	u16 len = min_t(int, length - i, block);
	86
	87	ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE,
	88	i, reg, len, data + i);
	89	if (ret)
	90	goto end;
	91	}
	92	end:
	93	return ret;
	94	}
	95
441c21c3	96	int vnt_control_in(struct vnt_private *priv, u8 request, u16 value,
3781f887	97	u16 index, u16 length, u8 *buffer)
92b96797	98	{
59608cb1	99	int ret = 0;
05c0cf88	100	u8 *usb_buffer;
731047f9	101
59608cb1 QD	102	if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
	103	ret = -EINVAL;
	104	goto end;
	105	}
ae5943de	106
9af49fdb	107	mutex_lock(&priv->usb_lock);
c91b1869	108
05c0cf88 MP	109	usb_buffer = kmalloc(length, GFP_KERNEL);
05c0cf88 MP	110	if (!usb_buffer) {
59608cb1 QD	111	ret = -ENOMEM;
59608cb1 QD	112	goto end_unlock;
05c0cf88 MP	113	}
05c0cf88 MP	114
59608cb1 QD	115	ret = usb_control_msg(priv->usb,
	116	usb_rcvctrlpipe(priv->usb, 0),
	117	request, 0xc0, value,
	118	index, usb_buffer, length, USB_CTL_WAIT);
05c0cf88	119
59608cb1	120	if (ret == length)
05c0cf88 MP	121	memcpy(buffer, usb_buffer, length);
	122
	123	kfree(usb_buffer);
92b96797	124
58c3e681 MP	125	if (ret == (int)length)
	126	ret = 0;
	127	else
59608cb1	128	ret = -EIO;
fe5d00eb	129
59608cb1 QD	130	end_unlock:
	131	mutex_unlock(&priv->usb_lock);
	132	end:
	133	return ret;
92b96797 FB	134	}
92b96797 FB	135
59608cb1	136	int vnt_control_in_u8(struct vnt_private priv, u8 reg, u8 reg_off, u8 data)
53742906	137	{
59608cb1 QD	138	return vnt_control_in(priv, MESSAGE_TYPE_READ,
59608cb1 QD	139	reg_off, reg, sizeof(u8), data);
53742906 MP	140	}
53742906 MP	141
10e9a359 MP	142	static int vnt_int_report_rate(struct vnt_private *priv, u8 pkt_no, u8 tsr)
	143	{
	144	struct vnt_usb_send_context *context;
	145	struct ieee80211_tx_info *info;
	146	u8 tx_retry = (tsr & 0xf0) >> 4;
	147	s8 idx;
	148
	149	if (pkt_no >= priv->num_tx_context)
	150	return -EINVAL;
	151
	152	context = priv->tx_context[pkt_no];
	153
	154	if (!context->skb)
	155	return -EINVAL;
	156
	157	info = IEEE80211_SKB_CB(context->skb);
	158	idx = info->control.rates[0].idx;
	159
	160	ieee80211_tx_info_clear_status(info);
	161
	162	info->status.rates[0].count = tx_retry;
	163
	164	if (!(tsr & TSR_TMO)) {
	165	info->status.rates[0].idx = idx;
	166
	167	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
	168	info->flags \|= IEEE80211_TX_STAT_ACK;
	169	}
	170
	171	ieee80211_tx_status_irqsafe(priv->hw, context->skb);
	172
	173	context->in_use = false;
	174
	175	return 0;
	176	}
	177
	178	static void vnt_int_process_data(struct vnt_private *priv)
	179	{
	180	struct vnt_interrupt_data *int_data;
	181	struct ieee80211_low_level_stats *low_stats = &priv->low_stats;
	182
	183	dev_dbg(&priv->usb->dev, "---->s_nsInterruptProcessData\n");
	184
	185	int_data = (struct vnt_interrupt_data *)priv->int_buf.data_buf;
	186
	187	if (int_data->tsr0 & TSR_VALID)
	188	vnt_int_report_rate(priv, int_data->pkt0, int_data->tsr0);
	189
	190	if (int_data->tsr1 & TSR_VALID)
	191	vnt_int_report_rate(priv, int_data->pkt1, int_data->tsr1);
	192
	193	if (int_data->tsr2 & TSR_VALID)
	194	vnt_int_report_rate(priv, int_data->pkt2, int_data->tsr2);
	195
	196	if (int_data->tsr3 & TSR_VALID)
	197	vnt_int_report_rate(priv, int_data->pkt3, int_data->tsr3);
	198
	199	if (int_data->isr0 != 0) {
	200	if (int_data->isr0 & ISR_BNTX &&
	201	priv->op_mode == NL80211_IFTYPE_AP)
	202	vnt_schedule_command(priv, WLAN_CMD_BECON_SEND);
	203
	204	if (int_data->isr0 & ISR_TBTT &&
	205	priv->hw->conf.flags & IEEE80211_CONF_PS) {
206	if (!priv->wake_up_count)
207	priv->wake_up_count =
208	priv->hw->conf.listen_interval;
209
ea81c348 MP	210	if (priv->wake_up_count)
ea81c348 MP	211	--priv->wake_up_count;
10e9a359 MP	212
	213	/* Turn on wake up to listen next beacon */
	214	if (priv->wake_up_count == 1)
	215	vnt_schedule_command(priv,
	216	WLAN_CMD_TBTT_WAKEUP);
	217	}
	218	priv->current_tsf = le64_to_cpu(int_data->tsf);
	219
	220	low_stats->dot11RTSSuccessCount += int_data->rts_success;
	221	low_stats->dot11RTSFailureCount += int_data->rts_fail;
	222	low_stats->dot11ACKFailureCount += int_data->ack_fail;
	223	low_stats->dot11FCSErrorCount += int_data->fcs_err;
	224	}
10e9a359 MP	225	}
10e9a359 MP	226
34f98e3f	227	static void vnt_start_interrupt_urb_complete(struct urb *urb)
92b96797	228	{
599e4b5c	229	struct vnt_private *priv = urb->context;
b9183fdd	230	int status = urb->status;
92b96797	231
b9183fdd	232	switch (status) {
c98fbf90 MP	233	case 0:
	234	case -ETIMEDOUT:
	235	break;
	236	case -ECONNRESET:
	237	case -ENOENT:
	238	case -ESHUTDOWN:
c98fbf90 MP	239	return;
	240	default:
	241	break;
	242	}
	243
d1ec1242	244	if (status)
8a660261	245	dev_dbg(&priv->usb->dev, "%s status = %d\n", __func__, status);
d1ec1242	246	else
e360d2b8	247	vnt_int_process_data(priv);
92b96797	248
3d582487	249	status = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC);
86140346	250	if (status)
8a660261	251	dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", status);
92b96797 FB	252	}
92b96797 FB	253
eaa56792 MP	254	int vnt_start_interrupt_urb(struct vnt_private *priv)
eaa56792 MP	255	{
59608cb1	256	int ret = 0;
eaa56792	257
05f665dd MP	258	dev_dbg(&priv->usb->dev, "---->Interrupt Polling Thread\n");
05f665dd MP	259
eaa56792 MP	260	usb_fill_int_urb(priv->interrupt_urb,
	261	priv->usb,
	262	usb_rcvintpipe(priv->usb, 1),
	263	priv->int_buf.data_buf,
	264	MAX_INTERRUPT_SIZE,
	265	vnt_start_interrupt_urb_complete,
	266	priv,
	267	priv->int_interval);
	268
59608cb1	269	ret = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC);
d1ec1242	270	if (ret)
59608cb1	271	dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", ret);
59608cb1	272
59608cb1	273	return ret;
eaa56792 MP	274	}
eaa56792 MP	275
3c505f50 MP	276	static int vnt_rx_data(struct vnt_private priv, struct vnt_rcb ptr_rcb,
	277	unsigned long bytes_received)
	278	{
	279	struct ieee80211_hw *hw = priv->hw;
	280	struct ieee80211_supported_band *sband;
	281	struct sk_buff *skb;
	282	struct ieee80211_rx_status *rx_status;
	283	struct vnt_rx_header *head;
	284	struct vnt_rx_tail *tail;
	285	u32 frame_size;
	286	int ii;
	287	u16 rx_bitrate, pay_load_with_padding;
	288	u8 rate_idx = 0;
	289	long rx_dbm;
	290
	291	skb = ptr_rcb->skb;
	292	rx_status = IEEE80211_SKB_RXCB(skb);
	293
	294	/* [31:16]RcvByteCount ( not include 4-byte Status ) */
	295	head = (struct vnt_rx_header *)skb->data;
	296	frame_size = head->wbk_status >> 16;
	297	frame_size += 4;
	298
	299	if (bytes_received != frame_size) {
	300	dev_dbg(&priv->usb->dev, "------- WRONG Length 1\n");
	301	return false;
	302	}
	303
	304	if ((bytes_received > 2372) \|\| (bytes_received <= 40)) {
	305	/* Frame Size error drop this packet.*/
	306	dev_dbg(&priv->usb->dev, "------ WRONG Length 2\n");
	307	return false;
	308	}
	309
	310	/* real Frame Size = USBframe_size -4WbkStatus - 4RxStatus */
	311	/* -8TSF - 4RSR - 4SQ3 - ?Padding */
	312
	313	/* if SQ3 the range is 24~27, if no SQ3 the range is 20~23 */
	314
	315	/Fix hardware bug => PLCP_Length error /
	316	if (((bytes_received - head->pay_load_len) > 27) \|\|
	317	((bytes_received - head->pay_load_len) < 24) \|\|
	318	(bytes_received < head->pay_load_len)) {
	319	dev_dbg(&priv->usb->dev, "Wrong PLCP Length %x\n",
	320	head->pay_load_len);
	321	return false;
	322	}
	323
	324	sband = hw->wiphy->bands[hw->conf.chandef.chan->band];
	325	rx_bitrate = head->rx_rate * 5; /* rx_rate * 5 */
	326
	327	for (ii = 0; ii < sband->n_bitrates; ii++) {
	328	if (sband->bitrates[ii].bitrate == rx_bitrate) {
	329	rate_idx = ii;
	330	break;
	331	}
	332	}
	333
	334	if (ii == sband->n_bitrates) {
	335	dev_dbg(&priv->usb->dev, "Wrong Rx Bit Rate %d\n", rx_bitrate);
	336	return false;
	337	}
	338
	339	pay_load_with_padding = ((head->pay_load_len / 4) +
340	((head->pay_load_len % 4) ? 1 : 0)) * 4;
341
342	tail = (struct vnt_rx_tail *)(skb->data +
343	sizeof(*head) + pay_load_with_padding);
344	priv->tsf_time = le64_to_cpu(tail->tsf_time);
345
346	if (tail->rsr & (RSR_IVLDTYP \| RSR_IVLDLEN))
347	return false;
348
349	vnt_rf_rssi_to_dbm(priv, tail->rssi, &rx_dbm);
350
351	priv->bb_pre_ed_rssi = (u8)-rx_dbm + 1;
352	priv->current_rssi = priv->bb_pre_ed_rssi;
353
354	skb_pull(skb, sizeof(*head));
355	skb_trim(skb, head->pay_load_len);
356
357	rx_status->mactime = priv->tsf_time;
358	rx_status->band = hw->conf.chandef.chan->band;
359	rx_status->signal = rx_dbm;
360	rx_status->flag = 0;
361	rx_status->freq = hw->conf.chandef.chan->center_freq;
362
363	if (!(tail->rsr & RSR_CRCOK))
364	rx_status->flag \|= RX_FLAG_FAILED_FCS_CRC;
365
366	rx_status->rate_idx = rate_idx;
367
368	if (tail->new_rsr & NEWRSR_DECRYPTOK)
369	rx_status->flag \|= RX_FLAG_DECRYPTED;
370
371	ieee80211_rx_irqsafe(priv->hw, skb);
372
373	return true;
374	}
375
08823af4	376	static void vnt_submit_rx_urb_complete(struct urb *urb)
92b96797	377	{
599e4b5c	378	struct vnt_rcb *rcb = urb->context;
325de984	379	struct vnt_private *priv = rcb->priv;
92b96797	380
67638980 MP	381	switch (urb->status) {
67638980 MP	382	case 0:
67638980 MP	383	break;
	384	case -ECONNRESET:
	385	case -ENOENT:
	386	case -ESHUTDOWN:
	387	return;
	388	case -ETIMEDOUT:
	389	default:
8a660261	390	dev_dbg(&priv->usb->dev, "BULK In failed %d\n", urb->status);
67638980 MP	391	break;
67638980 MP	392	}
92b96797	393
d4fa2ab0	394	if (urb->actual_length) {
f5283274 MP	395	if (vnt_rx_data(priv, rcb, urb->actual_length)) {
f5283274 MP	396	rcb->skb = dev_alloc_skb(priv->rx_buf_sz);
696089de	397	if (!rcb->skb)
f5283274	398	return;
618ff9ce MP	399	} else {
	400	skb_push(rcb->skb, skb_headroom(rcb->skb));
	401	skb_trim(rcb->skb, 0);
8cffb3cf	402	}
d4fa2ab0	403
8cffb3cf	404	urb->transfer_buffer = skb_put(rcb->skb,
44a22dc3	405	skb_tailroom(rcb->skb));
8cffb3cf MP	406	}
8cffb3cf MP	407
696089de	408	if (usb_submit_urb(urb, GFP_ATOMIC))
8cffb3cf	409	dev_dbg(&priv->usb->dev, "Failed to re submit rx skb\n");
92b96797 FB	410	}
92b96797 FB	411
93eac3b1 MP	412	int vnt_submit_rx_urb(struct vnt_private priv, struct vnt_rcb rcb)
93eac3b1 MP	413	{
59608cb1	414	int ret = 0;
b9183fdd	415	struct urb *urb = rcb->urb;
93eac3b1	416
27f31cf9	417	if (!rcb->skb) {
93eac3b1	418	dev_dbg(&priv->usb->dev, "rcb->skb is null\n");
59608cb1 QD	419	ret = -EINVAL;
59608cb1 QD	420	goto end;
93eac3b1 MP	421	}
	422
	423	usb_fill_bulk_urb(urb,
	424	priv->usb,
	425	usb_rcvbulkpipe(priv->usb, 2),
	426	skb_put(rcb->skb, skb_tailroom(rcb->skb)),
	427	MAX_TOTAL_SIZE_WITH_ALL_HEADERS,
	428	vnt_submit_rx_urb_complete,
	429	rcb);
	430
59608cb1	431	ret = usb_submit_urb(urb, GFP_ATOMIC);
696089de	432	if (ret)
59608cb1	433	dev_dbg(&priv->usb->dev, "Submit Rx URB failed %d\n", ret);
59608cb1 QD	434	end:
59608cb1 QD	435	return ret;
93eac3b1 MP	436	}
93eac3b1 MP	437
ceebd903	438	static void vnt_tx_context_complete(struct urb *urb)
92b96797	439	{
599e4b5c	440	struct vnt_usb_send_context *context = urb->context;
30a05b39	441	struct vnt_private *priv = context->priv;
92b96797	442
e8152bfb MP	443	switch (urb->status) {
e8152bfb MP	444	case 0:
8a660261	445	dev_dbg(&priv->usb->dev, "Write %d bytes\n", context->buf_len);
e8152bfb MP	446	break;
	447	case -ECONNRESET:
	448	case -ENOENT:
	449	case -ESHUTDOWN:
30a05b39	450	context->in_use = false;
e8152bfb	451	return;
d1b2a11d	452	case -ETIMEDOUT:
e8152bfb	453	default:
8a660261	454	dev_dbg(&priv->usb->dev, "BULK Out failed %d\n", urb->status);
e8152bfb MP	455	break;
	456	}
	457
d38b13aa MP	458	if (context->type == CONTEXT_DATA_PACKET)
d38b13aa MP	459	ieee80211_wake_queues(priv->hw);
21aa212c	460
71d764ae MP	461	if (urb->status \|\| context->type == CONTEXT_BEACON_PACKET) {
	462	if (context->skb)
	463	ieee80211_free_txskb(priv->hw, context->skb);
	464
	465	context->in_use = false;
	466	}
92b96797	467	}
664b044b MP	468
	469	int vnt_tx_context(struct vnt_private *priv,
	470	struct vnt_usb_send_context *context)
	471	{
	472	int status;
b9183fdd	473	struct urb *urb = context->urb;
664b044b	474
cbcc9a36	475	if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
664b044b	476	context->in_use = false;
2812ab89	477	return -ENODEV;
664b044b MP	478	}
664b044b MP	479
664b044b MP	480	usb_fill_bulk_urb(urb,
	481	priv->usb,
	482	usb_sndbulkpipe(priv->usb, 3),
	483	context->data,
	484	context->buf_len,
	485	vnt_tx_context_complete,
	486	context);
	487
	488	status = usb_submit_urb(urb, GFP_ATOMIC);
7aa47db9	489	if (status) {
664b044b MP	490	dev_dbg(&priv->usb->dev, "Submit Tx URB failed %d\n", status);
	491
	492	context->in_use = false;
664b044b MP	493	}
664b044b MP	494
2812ab89	495	return status;
664b044b	496	}