carl9170: 802.11 rx/tx processing and usb backend

/*

 * Atheros CARL9170 driver

 *

 * 802.11 & command trap routines

 *

 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>

 * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; see the file COPYING.  If not, see

 * http://www.gnu.org/licenses/.

 *

 * This file incorporates work covered by the following copyright and

 * permission notice:

 *    Copyright (c) 2007-2008 Atheros Communications, Inc.

 *

 *    Permission to use, copy, modify, and/or distribute this software for any

 *    purpose with or without fee is hereby granted, provided that the above

 *    copyright notice and this permission notice appear in all copies.

 *

 *    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 *    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 *    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 *    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 *    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

 *    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

 *    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

#include <linux/init.h>

#include <linux/slab.h>

#include <linux/module.h>

#include <linux/etherdevice.h>

#include <linux/crc32.h>

#include <net/mac80211.h>

#include "carl9170.h"

#include "hw.h"

#include "cmd.h"

static void carl9170_dbg_message(struct ar9170 *ar, const char *buf, u32 len)

{

	bool restart = false;

	enum carl9170_restart_reasons reason = CARL9170_RR_NO_REASON;

	if (len > 3) {

		if (memcmp(buf, CARL9170_ERR_MAGIC, 3) == 0) {

			ar->fw.err_counter++;

			if (ar->fw.err_counter > 3) {

				restart = true;

				reason = CARL9170_RR_TOO_MANY_FIRMWARE_ERRORS;

			}

		}

		if (memcmp(buf, CARL9170_BUG_MAGIC, 3) == 0) {

			ar->fw.bug_counter++;

			restart = true;

			reason = CARL9170_RR_FATAL_FIRMWARE_ERROR;

		}

	}

	wiphy_info(ar->hw->wiphy, "FW: %.*s\n", len, buf);

	if (restart)

		carl9170_restart(ar, reason);

}

static void carl9170_handle_ps(struct ar9170 *ar, struct carl9170_rsp *rsp)

{

	u32 ps;

	bool new_ps;

	ps = le32_to_cpu(rsp->psm.state);

	new_ps = (ps & CARL9170_PSM_COUNTER) != CARL9170_PSM_WAKE;

	if (ar->ps.state != new_ps) {

		if (!new_ps) {

			ar->ps.sleep_ms = jiffies_to_msecs(jiffies -

				ar->ps.last_action);

		}

		ar->ps.last_action = jiffies;

		ar->ps.state = new_ps;

	}

}

static int carl9170_check_sequence(struct ar9170 *ar, unsigned int seq)

{

	if (ar->cmd_seq < -1)

		return 0;

	/*

	 * Initialize Counter

	 */

	if (ar->cmd_seq < 0)

		ar->cmd_seq = seq;

	/*

	 * The sequence is strictly monotonic increasing and it never skips!

	 *

	 * Therefore we can safely assume that whenever we received an

	 * unexpected sequence we have lost some valuable data.

	 */

	if (seq != ar->cmd_seq) {

		int count;

		count = (seq - ar->cmd_seq) % ar->fw.cmd_bufs;

		wiphy_err(ar->hw->wiphy, "lost %d command responses/traps! "

			  "w:%d g:%d\n", count, ar->cmd_seq, seq);

		carl9170_restart(ar, CARL9170_RR_LOST_RSP);

		return -EIO;

	}

	ar->cmd_seq = (ar->cmd_seq + 1) % ar->fw.cmd_bufs;

	return 0;

}

static void carl9170_cmd_callback(struct ar9170 *ar, u32 len, void *buffer)

{

	/*

	 * Some commands may have a variable response length

	 * and we cannot predict the correct length in advance.

	 * So we only check if we provided enough space for the data.

	 */

	if (unlikely(ar->readlen != (len - 4))) {

		dev_warn(&ar->udev->dev, "received invalid command response:"

			 "got %d, instead of %d\n", len - 4, ar->readlen);

		print_hex_dump_bytes("carl9170 cmd:", DUMP_PREFIX_OFFSET,

			ar->cmd_buf, (ar->cmd.hdr.len + 4) & 0x3f);

		print_hex_dump_bytes("carl9170 rsp:", DUMP_PREFIX_OFFSET,

			buffer, len);

		/*

		 * Do not complete. The command times out,

		 * and we get a stack trace from there.

		 */

		carl9170_restart(ar, CARL9170_RR_INVALID_RSP);

	}

	spin_lock(&ar->cmd_lock);

	if (ar->readbuf) {

		if (len >= 4)

			memcpy(ar->readbuf, buffer + 4, len - 4);

		ar->readbuf = NULL;

	}

	complete(&ar->cmd_wait);

	spin_unlock(&ar->cmd_lock);

}

void carl9170_handle_command_response(struct ar9170 *ar, void *buf, u32 len)

{

	struct carl9170_rsp *cmd = (void *) buf;

	struct ieee80211_vif *vif;

	if (carl9170_check_sequence(ar, cmd->hdr.seq))

		return;

	if ((cmd->hdr.cmd & CARL9170_RSP_FLAG) != CARL9170_RSP_FLAG) {

		if (!(cmd->hdr.cmd & CARL9170_CMD_ASYNC_FLAG))

			carl9170_cmd_callback(ar, len, buf);

		return;

	}

	if (unlikely(cmd->hdr.len != (len - 4))) {

		if (net_ratelimit()) {

			wiphy_err(ar->hw->wiphy, "FW: received over-/under"

				"sized event %x (%d, but should be %d).\n",

			       cmd->hdr.cmd, cmd->hdr.len, len - 4);

			print_hex_dump_bytes("dump:", DUMP_PREFIX_NONE,

					     buf, len);

		}

		return;

	}

	/* hardware event handlers */

	switch (cmd->hdr.cmd) {

	case CARL9170_RSP_PRETBTT:

		/* pre-TBTT event */

		rcu_read_lock();

		vif = carl9170_get_main_vif(ar);

		if (!vif) {

			rcu_read_unlock();

			break;

		}

		switch (vif->type) {

		case NL80211_IFTYPE_STATION:

			carl9170_handle_ps(ar, cmd);

			break;

		case NL80211_IFTYPE_AP:

		case NL80211_IFTYPE_ADHOC:

			carl9170_update_beacon(ar, true);

			break;

		default:

			break;

		}

		rcu_read_unlock();

		break;

	case CARL9170_RSP_TXCOMP:

		/* TX status notification */

		carl9170_tx_process_status(ar, cmd);

		break;

	case CARL9170_RSP_BEACON_CONFIG:

		/*

		 * (IBSS) beacon send notification

		 * bytes: 04 c2 XX YY B4 B3 B2 B1

		 *

		 * XX always 80

		 * YY always 00

		 * B1-B4 "should" be the number of send out beacons.

		 */

		break;

	case CARL9170_RSP_ATIM:

		/* End of Atim Window */

		break;

	case CARL9170_RSP_WATCHDOG:

		/* Watchdog Interrupt */

		carl9170_restart(ar, CARL9170_RR_WATCHDOG);

		break;

	case CARL9170_RSP_TEXT:

		/* firmware debug */

		carl9170_dbg_message(ar, (char *)buf + 4, len - 4);

		break;

	case CARL9170_RSP_HEXDUMP:

		wiphy_dbg(ar->hw->wiphy, "FW: HD %d\n", len - 4);

		print_hex_dump_bytes("FW:", DUMP_PREFIX_NONE,

				     (char *)buf + 4, len - 4);

		break;

	case CARL9170_RSP_RADAR:

		if (!net_ratelimit())

			break;

		wiphy_info(ar->hw->wiphy, "FW: RADAR! Please report this "

		       "incident to linux-wireless@vger.kernel.org !\n");

		break;

	case CARL9170_RSP_GPIO:

#ifdef CONFIG_CARL9170_WPC

		if (ar->wps.pbc) {

			bool state = !!(cmd->gpio.gpio & cpu_to_le32(

				AR9170_GPIO_PORT_WPS_BUTTON_PRESSED));

			if (state != ar->wps.pbc_state) {

				ar->wps.pbc_state = state;

				input_report_key(ar->wps.pbc, KEY_WPS_BUTTON,

						 state);

				input_sync(ar->wps.pbc);

			}

		}

#endif /* CONFIG_CARL9170_WPC */

		break;

	case CARL9170_RSP_BOOT:

		complete(&ar->fw_boot_wait);

		break;

	default:

		wiphy_err(ar->hw->wiphy, "FW: received unhandled event %x\n",

			cmd->hdr.cmd);

		print_hex_dump_bytes("dump:", DUMP_PREFIX_NONE, buf, len);

		break;

	}

}

static int carl9170_rx_mac_status(struct ar9170 *ar,

	struct ar9170_rx_head *head, struct ar9170_rx_macstatus *mac,

	struct ieee80211_rx_status *status)

{

	struct ieee80211_channel *chan;

	u8 error, decrypt;

	BUILD_BUG_ON(sizeof(struct ar9170_rx_head) != 12);

	BUILD_BUG_ON(sizeof(struct ar9170_rx_macstatus) != 4);

	error = mac->error;

	if (error & AR9170_RX_ERROR_WRONG_RA) {

		if (!ar->sniffer_enabled)

			return -EINVAL;

	}

	if (error & AR9170_RX_ERROR_PLCP) {

		if (!(ar->filter_state & FIF_PLCPFAIL))

			return -EINVAL;

		status->flag |= RX_FLAG_FAILED_PLCP_CRC;

	}

	if (error & AR9170_RX_ERROR_FCS) {

		ar->tx_fcs_errors++;

		if (!(ar->filter_state & FIF_FCSFAIL))

			return -EINVAL;

		status->flag |= RX_FLAG_FAILED_FCS_CRC;

	}

	decrypt = ar9170_get_decrypt_type(mac);

	if (!(decrypt & AR9170_RX_ENC_SOFTWARE) &&

	    decrypt != AR9170_ENC_ALG_NONE) {

		if ((decrypt == AR9170_ENC_ALG_TKIP) &&

		    (error & AR9170_RX_ERROR_MMIC))

			status->flag |= RX_FLAG_MMIC_ERROR;

		status->flag |= RX_FLAG_DECRYPTED;

	}

	if (error & AR9170_RX_ERROR_DECRYPT && !ar->sniffer_enabled)

		return -ENODATA;

	error &= ~(AR9170_RX_ERROR_MMIC |

		   AR9170_RX_ERROR_FCS |

		   AR9170_RX_ERROR_WRONG_RA |

		   AR9170_RX_ERROR_DECRYPT |

		   AR9170_RX_ERROR_PLCP);

	/* drop any other error frames */

	if (unlikely(error)) {

		/* TODO: update netdevice's RX dropped/errors statistics */

		if (net_ratelimit())

			wiphy_dbg(ar->hw->wiphy, "received frame with "

			       "suspicious error code (%#x).\n", error);

		return -EINVAL;

	}

	chan = ar->channel;

	if (chan) {

		status->band = chan->band;

		status->freq = chan->center_freq;

	}

	switch (mac->status & AR9170_RX_STATUS_MODULATION) {

	case AR9170_RX_STATUS_MODULATION_CCK:

		if (mac->status & AR9170_RX_STATUS_SHORT_PREAMBLE)

			status->flag |= RX_FLAG_SHORTPRE;

		switch (head->plcp[0]) {

		case AR9170_RX_PHY_RATE_CCK_1M:

			status->rate_idx = 0;

			break;

		case AR9170_RX_PHY_RATE_CCK_2M:

			status->rate_idx = 1;

			break;

		case AR9170_RX_PHY_RATE_CCK_5M:

			status->rate_idx = 2;

			break;

		case AR9170_RX_PHY_RATE_CCK_11M:

			status->rate_idx = 3;

			break;

		default:

			if (net_ratelimit()) {

				wiphy_err(ar->hw->wiphy, "invalid plcp cck "

				       "rate (%x).\n", head->plcp[0]);

			}

			return -EINVAL;

		}

		break;

	case AR9170_RX_STATUS_MODULATION_DUPOFDM:

	case AR9170_RX_STATUS_MODULATION_OFDM:

		switch (head->plcp[0] & 0xf) {

		case AR9170_TXRX_PHY_RATE_OFDM_6M:

			status->rate_idx = 0;

			break;

		case AR9170_TXRX_PHY_RATE_OFDM_9M:

			status->rate_idx = 1;

			break;

		case AR9170_TXRX_PHY_RATE_OFDM_12M:

			status->rate_idx = 2;

			break;

		case AR9170_TXRX_PHY_RATE_OFDM_18M:

			status->rate_idx = 3;

			break;

		case AR9170_TXRX_PHY_RATE_OFDM_24M:

			status->rate_idx = 4;

			break;

		case AR9170_TXRX_PHY_RATE_OFDM_36M:

			status->rate_idx = 5;

			break;

		case AR9170_TXRX_PHY_RATE_OFDM_48M:

			status->rate_idx = 6;

			break;

		case AR9170_TXRX_PHY_RATE_OFDM_54M:

			status->rate_idx = 7;

			break;

		default:

			if (net_ratelimit()) {

				wiphy_err(ar->hw->wiphy, "invalid plcp ofdm "

					"rate (%x).\n", head->plcp[0]);

			}

			return -EINVAL;

		}

		if (status->band == IEEE80211_BAND_2GHZ)

			status->rate_idx += 4;

		break;

	case AR9170_RX_STATUS_MODULATION_HT:

		if (head->plcp[3] & 0x80)

			status->flag |= RX_FLAG_40MHZ;

		if (head->plcp[6] & 0x80)

			status->flag |= RX_FLAG_SHORT_GI;

		status->rate_idx = clamp(0, 75, head->plcp[3] & 0x7f);

		status->flag |= RX_FLAG_HT;

		break;

	default:

		BUG();

		return -ENOSYS;

	}

	return 0;

}

static void carl9170_rx_phy_status(struct ar9170 *ar,

	struct ar9170_rx_phystatus *phy, struct ieee80211_rx_status *status)

{

	int i;

	BUILD_BUG_ON(sizeof(struct ar9170_rx_phystatus) != 20);

	for (i = 0; i < 3; i++)

		if (phy->rssi[i] != 0x80)

			status->antenna |= BIT(i);

	/* post-process RSSI */

	for (i = 0; i < 7; i++)

		if (phy->rssi[i] & 0x80)

			phy->rssi[i] = ((phy->rssi[i] & 0x7f) + 1) & 0x7f;

	/* TODO: we could do something with phy_errors */

	status->signal = ar->noise[0] + phy->rssi_combined;

}

static struct sk_buff *carl9170_rx_copy_data(u8 *buf, int len)

{

	struct sk_buff *skb;

	int reserved = 0;

	struct ieee80211_hdr *hdr = (void *) buf;

	if (ieee80211_is_data_qos(hdr->frame_control)) {

		u8 *qc = ieee80211_get_qos_ctl(hdr);

		reserved += NET_IP_ALIGN;

		if (*qc & IEEE80211_QOS_CONTROL_A_MSDU_PRESENT)

			reserved += NET_IP_ALIGN;

	}

	if (ieee80211_has_a4(hdr->frame_control))

		reserved += NET_IP_ALIGN;

	reserved = 32 + (reserved & NET_IP_ALIGN);

	skb = dev_alloc_skb(len + reserved);

	if (likely(skb)) {

		skb_reserve(skb, reserved);

		memcpy(skb_put(skb, len), buf, len);

	}

	return skb;

}

static u8 *carl9170_find_ie(u8 *data, unsigned int len, u8 ie)

{

	struct ieee80211_mgmt *mgmt = (void *)data;

	u8 *pos, *end;

	pos = (u8 *)mgmt->u.beacon.variable;

	end = data + len;

	while (pos < end) {

		if (pos + 2 + pos[1] > end)

			return NULL;

		if (pos[0] == ie)

			return pos;

		pos += 2 + pos[1];

	}

	return NULL;

}

/*

 * NOTE:

 *

 * The firmware is in charge of waking up the device just before

 * the AP is expected to transmit the next beacon.

 *

 * This leaves the driver with the important task of deciding when

 * to set the PHY back to bed again.

 */

static void carl9170_ps_beacon(struct ar9170 *ar, void *data, unsigned int len)

{

	struct ieee80211_hdr *hdr = (void *) data;

	struct ieee80211_tim_ie *tim_ie;

	u8 *tim;

	u8 tim_len;

	bool cam;

	if (likely(!(ar->hw->conf.flags & IEEE80211_CONF_PS)))

		return;

	/* check if this really is a beacon */

	if (!ieee80211_is_beacon(hdr->frame_control))

		return;

	/* min. beacon length + FCS_LEN */

	if (len <= 40 + FCS_LEN)

		return;

	/* and only beacons from the associated BSSID, please */

	if (compare_ether_addr(hdr->addr3, ar->common.curbssid) ||

	    !ar->common.curaid)

		return;

	ar->ps.last_beacon = jiffies;

	tim = carl9170_find_ie(data, len - FCS_LEN, WLAN_EID_TIM);

	if (!tim)

		return;

	if (tim[1] < sizeof(*tim_ie))

		return;

	tim_len = tim[1];

	tim_ie = (struct ieee80211_tim_ie *) &tim[2];

	if (!WARN_ON_ONCE(!ar->hw->conf.ps_dtim_period))

		ar->ps.dtim_counter = (tim_ie->dtim_count - 1) %

			ar->hw->conf.ps_dtim_period;

	/* Check whenever the PHY can be turned off again. */

	/* 1. What about buffered unicast traffic for our AID? */

	cam = ieee80211_check_tim(tim_ie, tim_len, ar->common.curaid);

	/* 2. Maybe the AP wants to send multicast/broadcast data? */

	cam = !!(tim_ie->bitmap_ctrl & 0x01);

	if (!cam) {

		/* back to low-power land. */

		ar->ps.off_override &= ~PS_OFF_BCN;

		carl9170_ps_check(ar);

	} else {

		/* force CAM */

		ar->ps.off_override |= PS_OFF_BCN;

	}

}

/*

 * If the frame alignment is right (or the kernel has

 * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS), and there

 * is only a single MPDU in the USB frame, then we could

 * submit to mac80211 the SKB directly. However, since

 * there may be multiple packets in one SKB in stream

 * mode, and we need to observe the proper ordering,

 * this is non-trivial.

 */

static void carl9170_handle_mpdu(struct ar9170 *ar, u8 *buf, int len)

{

	struct ar9170_rx_head *head;

	struct ar9170_rx_macstatus *mac;

	struct ar9170_rx_phystatus *phy = NULL;

	struct ieee80211_rx_status status;

	struct sk_buff *skb;

	int mpdu_len;

	if (!IS_STARTED(ar))

		return;

	if (unlikely(len < sizeof(*mac))) {

		ar->rx_dropped++;

		return;

	}

	mpdu_len = len - sizeof(*mac);

	mac = (void *)(buf + mpdu_len);

	if (unlikely(mac->error & AR9170_RX_ERROR_FATAL)) {

		ar->rx_dropped++;

		return;

	}

	switch (mac->status & AR9170_RX_STATUS_MPDU) {

	case AR9170_RX_STATUS_MPDU_FIRST:

		/* Aggregated MPDUs start with an PLCP header */

		if (likely(mpdu_len >= sizeof(struct ar9170_rx_head))) {

			head = (void *) buf;

			/*

			 * The PLCP header needs to be cached for the

			 * following MIDDLE + LAST A-MPDU packets.

			 *

			 * So, if you are wondering why all frames seem

			 * to share a common RX status information,

			 * then you have the answer right here...

			 */

			memcpy(&ar->rx_plcp, (void *) buf,

			       sizeof(struct ar9170_rx_head));

			mpdu_len -= sizeof(struct ar9170_rx_head);

			buf += sizeof(struct ar9170_rx_head);

			ar->rx_has_plcp = true;

		} else {

			if (net_ratelimit()) {

				wiphy_err(ar->hw->wiphy, "plcp info "

					"is clipped.\n");

			}

			ar->rx_dropped++;

			return;

		}

		break;

	case AR9170_RX_STATUS_MPDU_LAST:

		/*

		 * The last frame of an A-MPDU has an extra tail

		 * which does contain the phy status of the whole

		 * aggregate.

		 */

		if (likely(mpdu_len >= sizeof(struct ar9170_rx_phystatus))) {

			mpdu_len -= sizeof(struct ar9170_rx_phystatus);

			phy = (void *)(buf + mpdu_len);

		} else {

			if (net_ratelimit()) {

				wiphy_err(ar->hw->wiphy, "frame tail "

					"is clipped.\n");

			}

			ar->rx_dropped++;

			return;

		}

	case AR9170_RX_STATUS_MPDU_MIDDLE:

		/*  These are just data + mac status */

		if (unlikely(!ar->rx_has_plcp)) {

			if (!net_ratelimit())

				return;

			wiphy_err(ar->hw->wiphy, "rx stream does not start "

					"with a first_mpdu frame tag.\n");

			ar->rx_dropped++;

			return;

		}

		head = &ar->rx_plcp;

		break;

	case AR9170_RX_STATUS_MPDU_SINGLE:

		/* single mpdu has both: plcp (head) and phy status (tail) */

		head = (void *) buf;

		mpdu_len -= sizeof(struct ar9170_rx_head);

		mpdu_len -= sizeof(struct ar9170_rx_phystatus);

		buf += sizeof(struct ar9170_rx_head);

		phy = (void *)(buf + mpdu_len);

		break;

	default:

		BUG_ON(1);

		break;

	}

	/* FC + DU + RA + FCS */

	if (unlikely(mpdu_len < (2 + 2 + 6 + FCS_LEN))) {

		ar->rx_dropped++;

		return;

	}

	memset(&status, 0, sizeof(status));

	if (unlikely(carl9170_rx_mac_status(ar, head, mac, &status))) {

		ar->rx_dropped++;

		return;

	}

	if (phy)

		carl9170_rx_phy_status(ar, phy, &status);

	carl9170_ps_beacon(ar, buf, mpdu_len);

	skb = carl9170_rx_copy_data(buf, mpdu_len);

	if (likely(skb)) {

		memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));

		ieee80211_rx(ar->hw, skb);

	} else {

		ar->rx_dropped++;