Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit fb9987d0 authored by Sujith's avatar Sujith Committed by John W. Linville
Browse files

ath9k_htc: Support for AR9271 chipset. 

Features:

 * Station mode
 * IBSS mode
 * Monitor mode
 * Legacy support
 * HT support
 * TX/RX 11n Aggregation
 * HW encryption
 * LED
 * Suspend/Resume

For more information: http://wireless.kernel.org/en/users/Drivers/ath9k_htc



Signed-off-by: default avatarSujith <Sujith.Manoharan@atheros.com>
Signed-off-by: default avatarVasanthakumar Thiagarajan <vasanth@atheros.com>
Signed-off-by: default avatarSenthil Balasubramanian <senthilkumar@atheros.com>
Signed-off-by: default avatarJohn W. Linville <linville@tuxdriver.com>
parent 736b3a27

drivers/net/wireless/ath/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -3,7 +3,7 @@ menuconfig ATH_COMMON 
	depends on CFG80211

	---help---

	  This will enable the support for the Atheros wireless drivers.

	  ath5k, ath9k and ar9170 drivers share some common code, this option

	  ath5k, ath9k, ath9k_htc and ar9170 drivers share some common code, this option

	  enables the common ath.ko module which shares common helpers.



	  For more information and documentation on this module you can visit:

drivers/net/wireless/ath/ath9k/Kconfig

+21 −0
Original line number Diff line number Diff line
@@ -32,3 +32,24 @@ config ATH9K_DEBUGFS 


	  Also required for changing debug message flags at run time.



config ATH9K_HTC

       tristate "Atheros HTC based wireless cards support"

       depends on USB && MAC80211

       select ATH9K_HW

       select MAC80211_LEDS

       select LEDS_CLASS

       select NEW_LEDS

       select ATH9K_COMMON

       ---help---

	 Support for Atheros HTC based cards.

	 Chipsets supported: AR9271



	 For more information: http://wireless.kernel.org/en/users/Drivers/ath9k_htc



	 The built module will be ath9k_htc.



config ATH9K_HTC_DEBUGFS

	bool "Atheros ath9k_htc debugging"

	depends on ATH9K_HTC && DEBUG_FS

	---help---

	  Say Y, if you need access to ath9k_htc's statistics.

drivers/net/wireless/ath/ath9k/Makefile

+10 −0
Original line number Diff line number Diff line
@@ -28,3 +28,13 @@ obj-$(CONFIG_ATH9K_HW) += ath9k_hw.o 


obj-$(CONFIG_ATH9K_COMMON) += ath9k_common.o

ath9k_common-y:=	common.o



ath9k_htc-y +=	htc_hst.o \

		hif_usb.o \

		wmi.o \

		htc_drv_txrx.o \

		htc_drv_main.o \

		htc_drv_beacon.o \

		htc_drv_init.o



obj-$(CONFIG_ATH9K_HTC) += ath9k_htc.o

drivers/net/wireless/ath/ath9k/common.c

+421 −0
Original line number Diff line number Diff line
@@ -286,6 +286,427 @@ int ath9k_cmn_padpos(__le16 frame_control) 
}

EXPORT_SYMBOL(ath9k_cmn_padpos);



int ath9k_cmn_get_hw_crypto_keytype(struct sk_buff *skb)

{

	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);



	if (tx_info->control.hw_key) {

		if (tx_info->control.hw_key->alg == ALG_WEP)

			return ATH9K_KEY_TYPE_WEP;

		else if (tx_info->control.hw_key->alg == ALG_TKIP)

			return ATH9K_KEY_TYPE_TKIP;

		else if (tx_info->control.hw_key->alg == ALG_CCMP)

			return ATH9K_KEY_TYPE_AES;

	}



	return ATH9K_KEY_TYPE_CLEAR;

}

EXPORT_SYMBOL(ath9k_cmn_get_hw_crypto_keytype);



/*

 * Calculate the RX filter to be set in the HW.

 */

u32 ath9k_cmn_calcrxfilter(struct ieee80211_hw *hw, struct ath_hw *ah,

			   unsigned int rxfilter)

{

#define	RX_FILTER_PRESERVE (ATH9K_RX_FILTER_PHYERR | ATH9K_RX_FILTER_PHYRADAR)



	u32 rfilt;



	rfilt = (ath9k_hw_getrxfilter(ah) & RX_FILTER_PRESERVE)

		| ATH9K_RX_FILTER_UCAST | ATH9K_RX_FILTER_BCAST

		| ATH9K_RX_FILTER_MCAST;



	/* If not a STA, enable processing of Probe Requests */

	if (ah->opmode != NL80211_IFTYPE_STATION)

		rfilt |= ATH9K_RX_FILTER_PROBEREQ;



	/*

	 * Set promiscuous mode when FIF_PROMISC_IN_BSS is enabled for station

	 * mode interface or when in monitor mode. AP mode does not need this

	 * since it receives all in-BSS frames anyway.

	 */

	if (((ah->opmode != NL80211_IFTYPE_AP) &&

	     (rxfilter & FIF_PROMISC_IN_BSS)) ||

	    (ah->opmode == NL80211_IFTYPE_MONITOR))

		rfilt |= ATH9K_RX_FILTER_PROM;



	if (rxfilter & FIF_CONTROL)

		rfilt |= ATH9K_RX_FILTER_CONTROL;



	if ((ah->opmode == NL80211_IFTYPE_STATION) &&

	    !(rxfilter & FIF_BCN_PRBRESP_PROMISC))

		rfilt |= ATH9K_RX_FILTER_MYBEACON;

	else

		rfilt |= ATH9K_RX_FILTER_BEACON;



	if ((AR_SREV_9280_10_OR_LATER(ah) ||

	    AR_SREV_9285_10_OR_LATER(ah)) &&

	    (ah->opmode == NL80211_IFTYPE_AP) &&

	    (rxfilter & FIF_PSPOLL))

		rfilt |= ATH9K_RX_FILTER_PSPOLL;



	if (conf_is_ht(&hw->conf))

		rfilt |= ATH9K_RX_FILTER_COMP_BAR;



	return rfilt;



#undef RX_FILTER_PRESERVE

}

EXPORT_SYMBOL(ath9k_cmn_calcrxfilter);



/*

 * Recv initialization for opmode change.

 */

void ath9k_cmn_opmode_init(struct ieee80211_hw *hw, struct ath_hw *ah,

			   unsigned int rxfilter)

{

	struct ath_common *common = ath9k_hw_common(ah);



	u32 rfilt, mfilt[2];



	/* configure rx filter */

	rfilt = ath9k_cmn_calcrxfilter(hw, ah, rxfilter);

	ath9k_hw_setrxfilter(ah, rfilt);



	/* configure bssid mask */

	if (ah->caps.hw_caps & ATH9K_HW_CAP_BSSIDMASK)

		ath_hw_setbssidmask(common);



	/* configure operational mode */

	ath9k_hw_setopmode(ah);



	/* Handle any link-level address change. */

	ath9k_hw_setmac(ah, common->macaddr);



	/* calculate and install multicast filter */

	mfilt[0] = mfilt[1] = ~0;

	ath9k_hw_setmcastfilter(ah, mfilt[0], mfilt[1]);

}

EXPORT_SYMBOL(ath9k_cmn_opmode_init);



static u32 ath9k_get_extchanmode(struct ieee80211_channel *chan,

				 enum nl80211_channel_type channel_type)

{

	u32 chanmode = 0;



	switch (chan->band) {

	case IEEE80211_BAND_2GHZ:

		switch (channel_type) {

		case NL80211_CHAN_NO_HT:

		case NL80211_CHAN_HT20:

			chanmode = CHANNEL_G_HT20;

			break;

		case NL80211_CHAN_HT40PLUS:

			chanmode = CHANNEL_G_HT40PLUS;

			break;

		case NL80211_CHAN_HT40MINUS:

			chanmode = CHANNEL_G_HT40MINUS;

			break;

		}

		break;

	case IEEE80211_BAND_5GHZ:

		switch (channel_type) {

		case NL80211_CHAN_NO_HT:

		case NL80211_CHAN_HT20:

			chanmode = CHANNEL_A_HT20;

			break;

		case NL80211_CHAN_HT40PLUS:

			chanmode = CHANNEL_A_HT40PLUS;

			break;

		case NL80211_CHAN_HT40MINUS:

			chanmode = CHANNEL_A_HT40MINUS;

			break;

		}

		break;

	default:

		break;

	}



	return chanmode;

}



/*

 * Update internal channel flags.

 */

void ath9k_cmn_update_ichannel(struct ieee80211_hw *hw,

			       struct ath9k_channel *ichan)

{

	struct ieee80211_channel *chan = hw->conf.channel;

	struct ieee80211_conf *conf = &hw->conf;



	ichan->channel = chan->center_freq;

	ichan->chan = chan;



	if (chan->band == IEEE80211_BAND_2GHZ) {

		ichan->chanmode = CHANNEL_G;

		ichan->channelFlags = CHANNEL_2GHZ | CHANNEL_OFDM | CHANNEL_G;

	} else {

		ichan->chanmode = CHANNEL_A;

		ichan->channelFlags = CHANNEL_5GHZ | CHANNEL_OFDM;

	}



	if (conf_is_ht(conf))

		ichan->chanmode = ath9k_get_extchanmode(chan,

							conf->channel_type);

}

EXPORT_SYMBOL(ath9k_cmn_update_ichannel);



/*

 * Get the internal channel reference.

 */

struct ath9k_channel *ath9k_cmn_get_curchannel(struct ieee80211_hw *hw,

					       struct ath_hw *ah)

{

	struct ieee80211_channel *curchan = hw->conf.channel;

	struct ath9k_channel *channel;

	u8 chan_idx;



	chan_idx = curchan->hw_value;

	channel = &ah->channels[chan_idx];

	ath9k_cmn_update_ichannel(hw, channel);



	return channel;

}

EXPORT_SYMBOL(ath9k_cmn_get_curchannel);



static int ath_setkey_tkip(struct ath_common *common, u16 keyix, const u8 *key,

			   struct ath9k_keyval *hk, const u8 *addr,

			   bool authenticator)

{

	struct ath_hw *ah = common->ah;

	const u8 *key_rxmic;

	const u8 *key_txmic;



	key_txmic = key + NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY;

	key_rxmic = key + NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY;



	if (addr == NULL) {

		/*

		 * Group key installation - only two key cache entries are used

		 * regardless of splitmic capability since group key is only

		 * used either for TX or RX.

		 */

		if (authenticator) {

			memcpy(hk->kv_mic, key_txmic, sizeof(hk->kv_mic));

			memcpy(hk->kv_txmic, key_txmic, sizeof(hk->kv_mic));

		} else {

			memcpy(hk->kv_mic, key_rxmic, sizeof(hk->kv_mic));

			memcpy(hk->kv_txmic, key_rxmic, sizeof(hk->kv_mic));

		}

		return ath9k_hw_set_keycache_entry(ah, keyix, hk, addr);

	}

	if (!common->splitmic) {

		/* TX and RX keys share the same key cache entry. */

		memcpy(hk->kv_mic, key_rxmic, sizeof(hk->kv_mic));

		memcpy(hk->kv_txmic, key_txmic, sizeof(hk->kv_txmic));

		return ath9k_hw_set_keycache_entry(ah, keyix, hk, addr);

	}



	/* Separate key cache entries for TX and RX */



	/* TX key goes at first index, RX key at +32. */

	memcpy(hk->kv_mic, key_txmic, sizeof(hk->kv_mic));

	if (!ath9k_hw_set_keycache_entry(ah, keyix, hk, NULL)) {

		/* TX MIC entry failed. No need to proceed further */

		ath_print(common, ATH_DBG_FATAL,

			  "Setting TX MIC Key Failed\n");

		return 0;

	}



	memcpy(hk->kv_mic, key_rxmic, sizeof(hk->kv_mic));

	/* XXX delete tx key on failure? */

	return ath9k_hw_set_keycache_entry(ah, keyix + 32, hk, addr);

}



static int ath_reserve_key_cache_slot_tkip(struct ath_common *common)

{

	int i;



	for (i = IEEE80211_WEP_NKID; i < common->keymax / 2; i++) {

		if (test_bit(i, common->keymap) ||

		    test_bit(i + 64, common->keymap))

			continue; /* At least one part of TKIP key allocated */

		if (common->splitmic &&

		    (test_bit(i + 32, common->keymap) ||

		     test_bit(i + 64 + 32, common->keymap)))

			continue; /* At least one part of TKIP key allocated */



		/* Found a free slot for a TKIP key */

		return i;

	}

	return -1;

}



static int ath_reserve_key_cache_slot(struct ath_common *common)

{

	int i;



	/* First, try to find slots that would not be available for TKIP. */

	if (common->splitmic) {

		for (i = IEEE80211_WEP_NKID; i < common->keymax / 4; i++) {

			if (!test_bit(i, common->keymap) &&

			    (test_bit(i + 32, common->keymap) ||

			     test_bit(i + 64, common->keymap) ||

			     test_bit(i + 64 + 32, common->keymap)))

				return i;

			if (!test_bit(i + 32, common->keymap) &&

			    (test_bit(i, common->keymap) ||

			     test_bit(i + 64, common->keymap) ||

			     test_bit(i + 64 + 32, common->keymap)))

				return i + 32;

			if (!test_bit(i + 64, common->keymap) &&

			    (test_bit(i , common->keymap) ||

			     test_bit(i + 32, common->keymap) ||

			     test_bit(i + 64 + 32, common->keymap)))

				return i + 64;

			if (!test_bit(i + 64 + 32, common->keymap) &&

			    (test_bit(i, common->keymap) ||

			     test_bit(i + 32, common->keymap) ||

			     test_bit(i + 64, common->keymap)))

				return i + 64 + 32;

		}

	} else {

		for (i = IEEE80211_WEP_NKID; i < common->keymax / 2; i++) {

			if (!test_bit(i, common->keymap) &&

			    test_bit(i + 64, common->keymap))

				return i;

			if (test_bit(i, common->keymap) &&

			    !test_bit(i + 64, common->keymap))

				return i + 64;

		}

	}



	/* No partially used TKIP slots, pick any available slot */

	for (i = IEEE80211_WEP_NKID; i < common->keymax; i++) {

		/* Do not allow slots that could be needed for TKIP group keys

		 * to be used. This limitation could be removed if we know that

		 * TKIP will not be used. */

		if (i >= 64 && i < 64 + IEEE80211_WEP_NKID)

			continue;

		if (common->splitmic) {

			if (i >= 32 && i < 32 + IEEE80211_WEP_NKID)

				continue;

			if (i >= 64 + 32 && i < 64 + 32 + IEEE80211_WEP_NKID)

				continue;

		}



		if (!test_bit(i, common->keymap))

			return i; /* Found a free slot for a key */

	}



	/* No free slot found */

	return -1;

}



/*

 * Configure encryption in the HW.

 */

int ath9k_cmn_key_config(struct ath_common *common,

			 struct ieee80211_vif *vif,

			 struct ieee80211_sta *sta,

			 struct ieee80211_key_conf *key)

{

	struct ath_hw *ah = common->ah;

	struct ath9k_keyval hk;

	const u8 *mac = NULL;

	int ret = 0;

	int idx;



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



	switch (key->alg) {

	case ALG_WEP:

		hk.kv_type = ATH9K_CIPHER_WEP;

		break;

	case ALG_TKIP:

		hk.kv_type = ATH9K_CIPHER_TKIP;

		break;

	case ALG_CCMP:

		hk.kv_type = ATH9K_CIPHER_AES_CCM;

		break;

	default:

		return -EOPNOTSUPP;

	}



	hk.kv_len = key->keylen;

	memcpy(hk.kv_val, key->key, key->keylen);



	if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {

		/* For now, use the default keys for broadcast keys. This may

		 * need to change with virtual interfaces. */

		idx = key->keyidx;

	} else if (key->keyidx) {

		if (WARN_ON(!sta))

			return -EOPNOTSUPP;

		mac = sta->addr;



		if (vif->type != NL80211_IFTYPE_AP) {

			/* Only keyidx 0 should be used with unicast key, but

			 * allow this for client mode for now. */

			idx = key->keyidx;

		} else

			return -EIO;

	} else {

		if (WARN_ON(!sta))

			return -EOPNOTSUPP;

		mac = sta->addr;



		if (key->alg == ALG_TKIP)

			idx = ath_reserve_key_cache_slot_tkip(common);

		else

			idx = ath_reserve_key_cache_slot(common);

		if (idx < 0)

			return -ENOSPC; /* no free key cache entries */

	}



	if (key->alg == ALG_TKIP)

		ret = ath_setkey_tkip(common, idx, key->key, &hk, mac,

				      vif->type == NL80211_IFTYPE_AP);

	else

		ret = ath9k_hw_set_keycache_entry(ah, idx, &hk, mac);



	if (!ret)

		return -EIO;



	set_bit(idx, common->keymap);

	if (key->alg == ALG_TKIP) {

		set_bit(idx + 64, common->keymap);

		if (common->splitmic) {

			set_bit(idx + 32, common->keymap);

			set_bit(idx + 64 + 32, common->keymap);

		}

	}



	return idx;

}

EXPORT_SYMBOL(ath9k_cmn_key_config);



/*

 * Delete Key.

 */

void ath9k_cmn_key_delete(struct ath_common *common,

			  struct ieee80211_key_conf *key)

{

	struct ath_hw *ah = common->ah;



	ath9k_hw_keyreset(ah, key->hw_key_idx);

	if (key->hw_key_idx < IEEE80211_WEP_NKID)

		return;



	clear_bit(key->hw_key_idx, common->keymap);

	if (key->alg != ALG_TKIP)

		return;



	clear_bit(key->hw_key_idx + 64, common->keymap);

	if (common->splitmic) {

		ath9k_hw_keyreset(ah, key->hw_key_idx + 32);

		clear_bit(key->hw_key_idx + 32, common->keymap);

		clear_bit(key->hw_key_idx + 64 + 32, common->keymap);

	}

}

EXPORT_SYMBOL(ath9k_cmn_key_delete);



static int __init ath9k_cmn_init(void)

{

	return 0;

drivers/net/wireless/ath/ath9k/common.h

+17 −0
Original line number Diff line number Diff line
@@ -23,6 +23,8 @@ 


/* Common header for Atheros 802.11n base driver cores */



#define IEEE80211_WEP_NKID 4



#define WME_NUM_TID             16

#define WME_BA_BMP_SIZE         64

#define WME_MAX_BA              WME_BA_BMP_SIZE
@@ -125,3 +127,18 @@ void ath9k_cmn_rx_skb_postprocess(struct ath_common *common, 
				  bool decrypt_error);



int ath9k_cmn_padpos(__le16 frame_control);

int ath9k_cmn_get_hw_crypto_keytype(struct sk_buff *skb);

u32 ath9k_cmn_calcrxfilter(struct ieee80211_hw *hw, struct ath_hw *ah,

			   unsigned int rxfilter);

void ath9k_cmn_opmode_init(struct ieee80211_hw *hw, struct ath_hw *ah,

			   unsigned int rxfilter);

void ath9k_cmn_update_ichannel(struct ieee80211_hw *hw,

			       struct ath9k_channel *ichan);

struct ath9k_channel *ath9k_cmn_get_curchannel(struct ieee80211_hw *hw,

					       struct ath_hw *ah);

int ath9k_cmn_key_config(struct ath_common *common,

			 struct ieee80211_vif *vif,

			 struct ieee80211_sta *sta,

			 struct ieee80211_key_conf *key);

void ath9k_cmn_key_delete(struct ath_common *common,

			  struct ieee80211_key_conf *key);