[deliverable/linux.git] / drivers / net / wireless / libertas / tx.c

/**
  * This file contains the handling of TX in wlan driver.
  */
#include <linux/netdevice.h>

#include "hostcmd.h"
#include "radiotap.h"
#include "decl.h"
#include "defs.h"
#include "dev.h"
#include "wext.h"

/**
 *  @brief This function converts Tx/Rx rates from IEEE80211_RADIOTAP_RATE
 *  units (500 Kb/s) into Marvell WLAN format (see Table 8 in Section 3.2.1)
 *
 *  @param rate    Input rate
 *  @return      Output Rate (0 if invalid)
 */
static u32 convert_radiotap_rate_to_mv(u8 rate)
{
	switch (rate) {
	case 2:		/*   1 Mbps */
		return 0 | (1 << 4);
	case 4:		/*   2 Mbps */
		return 1 | (1 << 4);
	case 11:		/* 5.5 Mbps */
		return 2 | (1 << 4);
	case 22:		/*  11 Mbps */
		return 3 | (1 << 4);
	case 12:		/*   6 Mbps */
		return 4 | (1 << 4);
	case 18:		/*   9 Mbps */
		return 5 | (1 << 4);
	case 24:		/*  12 Mbps */
		return 6 | (1 << 4);
	case 36:		/*  18 Mbps */
		return 7 | (1 << 4);
	case 48:		/*  24 Mbps */
		return 8 | (1 << 4);
	case 72:		/*  36 Mbps */
		return 9 | (1 << 4);
	case 96:		/*  48 Mbps */
		return 10 | (1 << 4);
	case 108:		/*  54 Mbps */
		return 11 | (1 << 4);
	}
	return 0;
}

/**
 *  @brief This function processes a single packet and sends
 *  to IF layer
 *
 *  @param priv    A pointer to wlan_private structure
 *  @param skb     A pointer to skb which includes TX packet
 *  @return 	   0 or -1
 */
static int SendSinglePacket(wlan_private * priv, struct sk_buff *skb)
{
	wlan_adapter *adapter = priv->adapter;
	int ret = 0;
	struct txpd localtxpd;
	struct txpd *plocaltxpd = &localtxpd;
	u8 *p802x_hdr;
	struct tx_radiotap_hdr *pradiotap_hdr;
	u32 new_rate;
	u8 *ptr = priv->adapter->tmptxbuf;

	lbs_deb_enter(LBS_DEB_TX);

	if (priv->adapter->surpriseremoved)
		return -1;

	if ((priv->adapter->debugmode & MRVDRV_DEBUG_TX_PATH) != 0)
		lbs_dbg_hex("TX packet: ", skb->data,
			 min_t(unsigned int, skb->len, 100));

	if (!skb->len || (skb->len > MRVDRV_ETH_TX_PACKET_BUFFER_SIZE)) {
		lbs_deb_tx("tx err: skb length %d 0 or > %zd\n",
		       skb->len, MRVDRV_ETH_TX_PACKET_BUFFER_SIZE);
		ret = -1;
		goto done;
	}

	memset(plocaltxpd, 0, sizeof(struct txpd));

	plocaltxpd->tx_packet_length = skb->len;

	/* offset of actual data */
	plocaltxpd->tx_packet_location = sizeof(struct txpd);

	/* TxCtrl set by user or default */
	plocaltxpd->tx_control = adapter->pkttxctrl;

	p802x_hdr = skb->data;
	if (priv->adapter->radiomode == WLAN_RADIOMODE_RADIOTAP) {

		/* locate radiotap header */
		pradiotap_hdr = (struct tx_radiotap_hdr *)skb->data;

		/* set txpd fields from the radiotap header */
		new_rate = convert_radiotap_rate_to_mv(pradiotap_hdr->rate);
		if (new_rate != 0) {
			/* erase tx_control[4:0] */
			plocaltxpd->tx_control &= ~0x1f;
			/* write new tx_control[4:0] */
			plocaltxpd->tx_control |= new_rate;
		}

		/* skip the radiotap header */
		p802x_hdr += sizeof(struct tx_radiotap_hdr);
		plocaltxpd->tx_packet_length -= sizeof(struct tx_radiotap_hdr);

	}
	/* copy destination address from 802.3 or 802.11 header */
	if (priv->adapter->linkmode == WLAN_LINKMODE_802_11)
		memcpy(plocaltxpd->tx_dest_addr_high, p802x_hdr + 4, ETH_ALEN);
	else
		memcpy(plocaltxpd->tx_dest_addr_high, p802x_hdr, ETH_ALEN);

	lbs_dbg_hex("txpd", (u8 *) plocaltxpd, sizeof(struct txpd));

	if (IS_MESH_FRAME(skb)) {
		plocaltxpd->tx_control |= TxPD_MESH_FRAME;
	}

	memcpy(ptr, plocaltxpd, sizeof(struct txpd));

	ptr += sizeof(struct txpd);

	lbs_dbg_hex("Tx Data", (u8 *) p802x_hdr, plocaltxpd->tx_packet_length);
	memcpy(ptr, p802x_hdr, plocaltxpd->tx_packet_length);
	ret = priv->hw_host_to_card(priv, MVMS_DAT,
		priv->adapter->tmptxbuf,
		plocaltxpd->tx_packet_length +
		sizeof(struct txpd));

	if (ret) {
		lbs_deb_tx("tx err: hw_host_to_card returned 0x%X\n", ret);
		goto done;
	}

	lbs_deb_tx("SendSinglePacket succeeds\n");

done:
	if (!ret) {
		priv->stats.tx_packets++;
		priv->stats.tx_bytes += skb->len;
	} else {
		priv->stats.tx_dropped++;
		priv->stats.tx_errors++;
	}

	if (!ret && priv->adapter->radiomode == WLAN_RADIOMODE_RADIOTAP) {
		/* Keep the skb to echo it back once Tx feedback is
		   received from FW */
		skb_orphan(skb);
		/* stop processing outgoing pkts */
		netif_stop_queue(priv->wlan_dev.netdev);
		netif_stop_queue(priv->mesh_dev);
		/* freeze any packets already in our queues */
		priv->adapter->TxLockFlag = 1;
	} else {
		dev_kfree_skb_any(skb);
		priv->adapter->currenttxskb = NULL;
	}

	lbs_deb_leave_args(LBS_DEB_TX, "ret %d", ret);
	return ret;
}


void libertas_tx_runqueue(wlan_private *priv)
{
	wlan_adapter *adapter = priv->adapter;
	int i;

	spin_lock(&adapter->txqueue_lock);
	for (i = 0; i < adapter->tx_queue_idx; i++) {
		struct sk_buff *skb = adapter->tx_queue_ps[i];
		spin_unlock(&adapter->txqueue_lock);
		SendSinglePacket(priv, skb);
		spin_lock(&adapter->txqueue_lock);
	}
	adapter->tx_queue_idx = 0;
	spin_unlock(&adapter->txqueue_lock);
}

static void wlan_tx_queue(wlan_private *priv, struct sk_buff *skb)
{
	wlan_adapter *adapter = priv->adapter;

	spin_lock(&adapter->txqueue_lock);

	WARN_ON(priv->adapter->tx_queue_idx >= NR_TX_QUEUE);
	adapter->tx_queue_ps[adapter->tx_queue_idx++] = skb;
	if (adapter->tx_queue_idx == NR_TX_QUEUE) {
		netif_stop_queue(priv->wlan_dev.netdev);
		netif_stop_queue(priv->mesh_dev);
	} else {
		netif_start_queue(priv->wlan_dev.netdev);
		netif_start_queue(priv->mesh_dev);
	}

	spin_unlock(&adapter->txqueue_lock);
}

/**
 *  @brief This function checks the conditions and sends packet to IF
 *  layer if everything is ok.
 *
 *  @param priv    A pointer to wlan_private structure
 *  @return 	   n/a
 */
int libertas_process_tx(wlan_private * priv, struct sk_buff *skb)
{
	int ret = -1;

	lbs_deb_enter(LBS_DEB_TX);
	lbs_dbg_hex("TX Data", skb->data, min_t(unsigned int, skb->len, 100));

	if (priv->wlan_dev.dnld_sent) {
		lbs_pr_alert( "TX error: dnld_sent = %d, not sending\n",
		       priv->wlan_dev.dnld_sent);
		goto done;
	}

	if ((priv->adapter->psstate == PS_STATE_SLEEP) ||
	    (priv->adapter->psstate == PS_STATE_PRE_SLEEP)) {
		wlan_tx_queue(priv, skb);
		return ret;
	}

	priv->adapter->currenttxskb = skb;

	ret = SendSinglePacket(priv, skb);
done:
	lbs_deb_leave_args(LBS_DEB_TX, "ret %d", ret);
	return ret;
}

/**
 *  @brief This function sends to the host the last transmitted packet,
 *  filling the radiotap headers with transmission information.
 *
 *  @param priv     A pointer to wlan_private structure
 *  @param status   A 32 bit value containing transmission status.
 *
 *  @returns void
 */
void libertas_send_tx_feedback(wlan_private * priv)
{
	wlan_adapter *adapter = priv->adapter;
	struct tx_radiotap_hdr *radiotap_hdr;
	u32 status = adapter->eventcause;
	int txfail;
	int try_count;

	if (adapter->radiomode != WLAN_RADIOMODE_RADIOTAP ||
	    adapter->currenttxskb == NULL)
		return;

	radiotap_hdr = (struct tx_radiotap_hdr *)adapter->currenttxskb->data;

	if ((adapter->debugmode & MRVDRV_DEBUG_TX_PATH) != 0)
		lbs_dbg_hex("TX feedback: ", (u8 *) radiotap_hdr,
			min_t(unsigned int, adapter->currenttxskb->len, 100));

	txfail = (status >> 24);

#if 0
	/* The version of roofnet that we've tested does not use this yet
	 * But it may be used in the future.
	 */
	if (txfail)
		radiotap_hdr->flags &= IEEE80211_RADIOTAP_F_TX_FAIL;
#endif
	try_count = (status >> 16) & 0xff;
	radiotap_hdr->data_retries = (try_count) ?
	    (1 + adapter->txretrycount - try_count) : 0;
	libertas_upload_rx_packet(priv, adapter->currenttxskb);
	adapter->currenttxskb = NULL;
	priv->adapter->TxLockFlag = 0;
	if (priv->adapter->connect_status == libertas_connected) {
		netif_wake_queue(priv->wlan_dev.netdev);
		netif_wake_queue(priv->mesh_dev);
	}
}
EXPORT_SYMBOL_GPL(libertas_send_tx_feedback);
Commit	Line	Data
876c9d3a MT	1	/**
	2	* This file contains the handling of TX in wlan driver.
	3	*/
	4	#include <linux/netdevice.h>
	5
	6	#include "hostcmd.h"
	7	#include "radiotap.h"
876c9d3a MT	8	#include "decl.h"
	9	#include "defs.h"
	10	#include "dev.h"
	11	#include "wext.h"
	12
	13	/**
	14	* @brief This function converts Tx/Rx rates from IEEE80211_RADIOTAP_RATE
	15	* units (500 Kb/s) into Marvell WLAN format (see Table 8 in Section 3.2.1)
	16	*
	17	* @param rate Input rate
	18	* @return Output Rate (0 if invalid)
	19	*/
	20	static u32 convert_radiotap_rate_to_mv(u8 rate)
	21	{
	22	switch (rate) {
	23	case 2: /* 1 Mbps */
	24	return 0 \| (1 << 4);
	25	case 4: /* 2 Mbps */
	26	return 1 \| (1 << 4);
	27	case 11: /* 5.5 Mbps */
	28	return 2 \| (1 << 4);
	29	case 22: /* 11 Mbps */
	30	return 3 \| (1 << 4);
	31	case 12: /* 6 Mbps */
	32	return 4 \| (1 << 4);
	33	case 18: /* 9 Mbps */
	34	return 5 \| (1 << 4);
	35	case 24: /* 12 Mbps */
	36	return 6 \| (1 << 4);
	37	case 36: /* 18 Mbps */
	38	return 7 \| (1 << 4);
	39	case 48: /* 24 Mbps */
	40	return 8 \| (1 << 4);
	41	case 72: /* 36 Mbps */
	42	return 9 \| (1 << 4);
	43	case 96: /* 48 Mbps */
	44	return 10 \| (1 << 4);
	45	case 108: /* 54 Mbps */
	46	return 11 \| (1 << 4);
	47	}
	48	return 0;
	49	}
	50
	51	/**
	52	* @brief This function processes a single packet and sends
	53	* to IF layer
	54	*
	55	* @param priv A pointer to wlan_private structure
	56	* @param skb A pointer to skb which includes TX packet
	57	* @return 0 or -1
	58	*/
	59	static int SendSinglePacket(wlan_private * priv, struct sk_buff *skb)
	60	{
	61	wlan_adapter *adapter = priv->adapter;
	62	int ret = 0;
	63	struct txpd localtxpd;
	64	struct txpd *plocaltxpd = &localtxpd;
	65	u8 *p802x_hdr;
	66	struct tx_radiotap_hdr *pradiotap_hdr;
	67	u32 new_rate;
	68	u8 *ptr = priv->adapter->tmptxbuf;
	69
9012b28a	70	lbs_deb_enter(LBS_DEB_TX);
876c9d3a MT	71
	72	if (priv->adapter->surpriseremoved)
	73	return -1;
	74
	75	if ((priv->adapter->debugmode & MRVDRV_DEBUG_TX_PATH) != 0)
	76	lbs_dbg_hex("TX packet: ", skb->data,
	77	min_t(unsigned int, skb->len, 100));
	78
	79	if (!skb->len \|\| (skb->len > MRVDRV_ETH_TX_PACKET_BUFFER_SIZE)) {
9012b28a	80	lbs_deb_tx("tx err: skb length %d 0 or > %zd\n",
876c9d3a MT	81	skb->len, MRVDRV_ETH_TX_PACKET_BUFFER_SIZE);
	82	ret = -1;
	83	goto done;
	84	}
	85
	86	memset(plocaltxpd, 0, sizeof(struct txpd));
	87
	88	plocaltxpd->tx_packet_length = skb->len;
	89
	90	/* offset of actual data */
	91	plocaltxpd->tx_packet_location = sizeof(struct txpd);
	92
	93	/* TxCtrl set by user or default */
	94	plocaltxpd->tx_control = adapter->pkttxctrl;
	95
	96	p802x_hdr = skb->data;
	97	if (priv->adapter->radiomode == WLAN_RADIOMODE_RADIOTAP) {
	98
	99	/* locate radiotap header */
	100	pradiotap_hdr = (struct tx_radiotap_hdr *)skb->data;
	101
	102	/* set txpd fields from the radiotap header */
	103	new_rate = convert_radiotap_rate_to_mv(pradiotap_hdr->rate);
	104	if (new_rate != 0) {
	105	/* erase tx_control[4:0] */
	106	plocaltxpd->tx_control &= ~0x1f;
	107	/* write new tx_control[4:0] */
	108	plocaltxpd->tx_control \|= new_rate;
	109	}
	110
	111	/* skip the radiotap header */
	112	p802x_hdr += sizeof(struct tx_radiotap_hdr);
	113	plocaltxpd->tx_packet_length -= sizeof(struct tx_radiotap_hdr);
	114
	115	}
	116	/* copy destination address from 802.3 or 802.11 header */
	117	if (priv->adapter->linkmode == WLAN_LINKMODE_802_11)
	118	memcpy(plocaltxpd->tx_dest_addr_high, p802x_hdr + 4, ETH_ALEN);
	119	else
	120	memcpy(plocaltxpd->tx_dest_addr_high, p802x_hdr, ETH_ALEN);
	121
	122	lbs_dbg_hex("txpd", (u8 *) plocaltxpd, sizeof(struct txpd));
	123
	124	if (IS_MESH_FRAME(skb)) {
	125	plocaltxpd->tx_control \|= TxPD_MESH_FRAME;
	126	}
	127
	128	memcpy(ptr, plocaltxpd, sizeof(struct txpd));
	129
	130	ptr += sizeof(struct txpd);
	131
	132	lbs_dbg_hex("Tx Data", (u8 *) p802x_hdr, plocaltxpd->tx_packet_length);
	133	memcpy(ptr, p802x_hdr, plocaltxpd->tx_packet_length);
208fdd2f HS	134	ret = priv->hw_host_to_card(priv, MVMS_DAT,
	135	priv->adapter->tmptxbuf,
	136	plocaltxpd->tx_packet_length +
	137	sizeof(struct txpd));
876c9d3a MT	138
876c9d3a MT	139	if (ret) {
208fdd2f	140	lbs_deb_tx("tx err: hw_host_to_card returned 0x%X\n", ret);
876c9d3a MT	141	goto done;
	142	}
	143
9012b28a	144	lbs_deb_tx("SendSinglePacket succeeds\n");
876c9d3a	145
9012b28a	146	done:
876c9d3a MT	147	if (!ret) {
	148	priv->stats.tx_packets++;
	149	priv->stats.tx_bytes += skb->len;
	150	} else {
	151	priv->stats.tx_dropped++;
	152	priv->stats.tx_errors++;
	153	}
	154
	155	if (!ret && priv->adapter->radiomode == WLAN_RADIOMODE_RADIOTAP) {
	156	/* Keep the skb to echo it back once Tx feedback is
	157	received from FW */
	158	skb_orphan(skb);
	159	/* stop processing outgoing pkts */
	160	netif_stop_queue(priv->wlan_dev.netdev);
51d84f50	161	netif_stop_queue(priv->mesh_dev);
876c9d3a MT	162	/* freeze any packets already in our queues */
	163	priv->adapter->TxLockFlag = 1;
	164	} else {
	165	dev_kfree_skb_any(skb);
	166	priv->adapter->currenttxskb = NULL;
	167	}
	168
9012b28a	169	lbs_deb_leave_args(LBS_DEB_TX, "ret %d", ret);
876c9d3a MT	170	return ret;
	171	}
	172
	173
	174	void libertas_tx_runqueue(wlan_private *priv)
	175	{
	176	wlan_adapter *adapter = priv->adapter;
	177	int i;
	178
	179	spin_lock(&adapter->txqueue_lock);
	180	for (i = 0; i < adapter->tx_queue_idx; i++) {
	181	struct sk_buff *skb = adapter->tx_queue_ps[i];
	182	spin_unlock(&adapter->txqueue_lock);
	183	SendSinglePacket(priv, skb);
	184	spin_lock(&adapter->txqueue_lock);
	185	}
	186	adapter->tx_queue_idx = 0;
	187	spin_unlock(&adapter->txqueue_lock);
	188	}
	189
	190	static void wlan_tx_queue(wlan_private priv, struct sk_buff skb)
	191	{
	192	wlan_adapter *adapter = priv->adapter;
	193
	194	spin_lock(&adapter->txqueue_lock);
	195
	196	WARN_ON(priv->adapter->tx_queue_idx >= NR_TX_QUEUE);
	197	adapter->tx_queue_ps[adapter->tx_queue_idx++] = skb;
51d84f50	198	if (adapter->tx_queue_idx == NR_TX_QUEUE) {
876c9d3a	199	netif_stop_queue(priv->wlan_dev.netdev);
51d84f50 JC	200	netif_stop_queue(priv->mesh_dev);
51d84f50 JC	201	} else {
876c9d3a	202	netif_start_queue(priv->wlan_dev.netdev);
51d84f50 JC	203	netif_start_queue(priv->mesh_dev);
51d84f50 JC	204	}
876c9d3a MT	205
	206	spin_unlock(&adapter->txqueue_lock);
	207	}
	208
	209	/**
	210	* @brief This function checks the conditions and sends packet to IF
	211	* layer if everything is ok.
	212	*
	213	* @param priv A pointer to wlan_private structure
	214	* @return n/a
	215	*/
	216	int libertas_process_tx(wlan_private * priv, struct sk_buff *skb)
	217	{
	218	int ret = -1;
	219
9012b28a	220	lbs_deb_enter(LBS_DEB_TX);
876c9d3a MT	221	lbs_dbg_hex("TX Data", skb->data, min_t(unsigned int, skb->len, 100));
	222
	223	if (priv->wlan_dev.dnld_sent) {
	224	lbs_pr_alert( "TX error: dnld_sent = %d, not sending\n",
	225	priv->wlan_dev.dnld_sent);
	226	goto done;
	227	}
	228
	229	if ((priv->adapter->psstate == PS_STATE_SLEEP) \|\|
	230	(priv->adapter->psstate == PS_STATE_PRE_SLEEP)) {
	231	wlan_tx_queue(priv, skb);
	232	return ret;
	233	}
	234
	235	priv->adapter->currenttxskb = skb;
	236
	237	ret = SendSinglePacket(priv, skb);
	238	done:
9012b28a	239	lbs_deb_leave_args(LBS_DEB_TX, "ret %d", ret);
876c9d3a MT	240	return ret;
	241	}
	242
	243	/**
	244	* @brief This function sends to the host the last transmitted packet,
	245	* filling the radiotap headers with transmission information.
	246	*
	247	* @param priv A pointer to wlan_private structure
	248	* @param status A 32 bit value containing transmission status.
	249	*
	250	* @returns void
	251	*/
	252	void libertas_send_tx_feedback(wlan_private * priv)
	253	{
	254	wlan_adapter *adapter = priv->adapter;
	255	struct tx_radiotap_hdr *radiotap_hdr;
	256	u32 status = adapter->eventcause;
	257	int txfail;
	258	int try_count;
	259
	260	if (adapter->radiomode != WLAN_RADIOMODE_RADIOTAP \|\|
	261	adapter->currenttxskb == NULL)
	262	return;
	263
	264	radiotap_hdr = (struct tx_radiotap_hdr *)adapter->currenttxskb->data;
	265
	266	if ((adapter->debugmode & MRVDRV_DEBUG_TX_PATH) != 0)
	267	lbs_dbg_hex("TX feedback: ", (u8 *) radiotap_hdr,
	268	min_t(unsigned int, adapter->currenttxskb->len, 100));
	269
	270	txfail = (status >> 24);
	271
	272	#if 0
	273	/* The version of roofnet that we've tested does not use this yet
	274	* But it may be used in the future.
	275	*/
	276	if (txfail)
	277	radiotap_hdr->flags &= IEEE80211_RADIOTAP_F_TX_FAIL;
	278	#endif
	279	try_count = (status >> 16) & 0xff;
	280	radiotap_hdr->data_retries = (try_count) ?
	281	(1 + adapter->txretrycount - try_count) : 0;
	282	libertas_upload_rx_packet(priv, adapter->currenttxskb);
	283	adapter->currenttxskb = NULL;
	284	priv->adapter->TxLockFlag = 0;
51d84f50	285	if (priv->adapter->connect_status == libertas_connected) {
876c9d3a	286	netif_wake_queue(priv->wlan_dev.netdev);
51d84f50 JC	287	netif_wake_queue(priv->mesh_dev);
51d84f50 JC	288	}
876c9d3a	289	}
084708b6	290	EXPORT_SYMBOL_GPL(libertas_send_tx_feedback);