[deliverable/linux.git] / drivers / net / wireless / ath / key.c

/*
 * Copyright (c) 2009 Atheros Communications Inc.
 * Copyright (c) 2010 Bruno Randolf <br1@einfach.org>
 *
 * 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 <asm/unaligned.h>
#include <net/mac80211.h>

#include "ath.h"
#include "reg.h"

#define REG_READ			(common->ops->read)
#define REG_WRITE(_ah, _reg, _val)	(common->ops->write)(_ah, _val, _reg)

#define IEEE80211_WEP_NKID      4       /* number of key ids */

/************************/
/* Key Cache Management */
/************************/

bool ath_hw_keyreset(struct ath_common *common, u16 entry)
{
	u32 keyType;
	void *ah = common->ah;

	if (entry >= common->keymax) {
		ath_err(common, "keycache entry %u out of range\n", entry);
		return false;
	}

	keyType = REG_READ(ah, AR_KEYTABLE_TYPE(entry));

	REG_WRITE(ah, AR_KEYTABLE_KEY0(entry), 0);
	REG_WRITE(ah, AR_KEYTABLE_KEY1(entry), 0);
	REG_WRITE(ah, AR_KEYTABLE_KEY2(entry), 0);
	REG_WRITE(ah, AR_KEYTABLE_KEY3(entry), 0);
	REG_WRITE(ah, AR_KEYTABLE_KEY4(entry), 0);
	REG_WRITE(ah, AR_KEYTABLE_TYPE(entry), AR_KEYTABLE_TYPE_CLR);
	REG_WRITE(ah, AR_KEYTABLE_MAC0(entry), 0);
	REG_WRITE(ah, AR_KEYTABLE_MAC1(entry), 0);

	if (keyType == AR_KEYTABLE_TYPE_TKIP) {
		u16 micentry = entry + 64;

		REG_WRITE(ah, AR_KEYTABLE_KEY0(micentry), 0);
		REG_WRITE(ah, AR_KEYTABLE_KEY1(micentry), 0);
		REG_WRITE(ah, AR_KEYTABLE_KEY2(micentry), 0);
		REG_WRITE(ah, AR_KEYTABLE_KEY3(micentry), 0);
		if (common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED) {
			REG_WRITE(ah, AR_KEYTABLE_KEY4(micentry), 0);
			REG_WRITE(ah, AR_KEYTABLE_TYPE(micentry),
				  AR_KEYTABLE_TYPE_CLR);
		}

	}

	return true;
}
EXPORT_SYMBOL(ath_hw_keyreset);

static bool ath_hw_keysetmac(struct ath_common *common,
			     u16 entry, const u8 *mac)
{
	u32 macHi, macLo;
	u32 unicast_flag = AR_KEYTABLE_VALID;
	void *ah = common->ah;

	if (entry >= common->keymax) {
		ath_err(common, "keycache entry %u out of range\n", entry);
		return false;
	}

	if (mac != NULL) {
		/*
		 * AR_KEYTABLE_VALID indicates that the address is a unicast
		 * address, which must match the transmitter address for
		 * decrypting frames.
		 * Not setting this bit allows the hardware to use the key
		 * for multicast frame decryption.
		 */
		if (mac[0] & 0x01)
			unicast_flag = 0;

		macHi = (mac[5] << 8) | mac[4];
		macLo = (mac[3] << 24) |
			(mac[2] << 16) |
			(mac[1] << 8) |
			mac[0];
		macLo >>= 1;
		macLo |= (macHi & 1) << 31;
		macHi >>= 1;
	} else {
		macLo = macHi = 0;
	}
	REG_WRITE(ah, AR_KEYTABLE_MAC0(entry), macLo);
	REG_WRITE(ah, AR_KEYTABLE_MAC1(entry), macHi | unicast_flag);

	return true;
}

static bool ath_hw_set_keycache_entry(struct ath_common *common, u16 entry,
				      const struct ath_keyval *k,
				      const u8 *mac)
{
	void *ah = common->ah;
	u32 key0, key1, key2, key3, key4;
	u32 keyType;

	if (entry >= common->keymax) {
		ath_err(common, "keycache entry %u out of range\n", entry);
		return false;
	}

	switch (k->kv_type) {
	case ATH_CIPHER_AES_OCB:
		keyType = AR_KEYTABLE_TYPE_AES;
		break;
	case ATH_CIPHER_AES_CCM:
		if (!(common->crypt_caps & ATH_CRYPT_CAP_CIPHER_AESCCM)) {
			ath_dbg(common, ATH_DBG_ANY,
				"AES-CCM not supported by this mac rev\n");
			return false;
		}
		keyType = AR_KEYTABLE_TYPE_CCM;
		break;
	case ATH_CIPHER_TKIP:
		keyType = AR_KEYTABLE_TYPE_TKIP;
		if (entry + 64 >= common->keymax) {
			ath_dbg(common, ATH_DBG_ANY,
				"entry %u inappropriate for TKIP\n", entry);
			return false;
		}
		break;
	case ATH_CIPHER_WEP:
		if (k->kv_len < WLAN_KEY_LEN_WEP40) {
			ath_dbg(common, ATH_DBG_ANY,
				"WEP key length %u too small\n", k->kv_len);
			return false;
		}
		if (k->kv_len <= WLAN_KEY_LEN_WEP40)
			keyType = AR_KEYTABLE_TYPE_40;
		else if (k->kv_len <= WLAN_KEY_LEN_WEP104)
			keyType = AR_KEYTABLE_TYPE_104;
		else
			keyType = AR_KEYTABLE_TYPE_128;
		break;
	case ATH_CIPHER_CLR:
		keyType = AR_KEYTABLE_TYPE_CLR;
		break;
	default:
		ath_err(common, "cipher %u not supported\n", k->kv_type);
		return false;
	}

	key0 = get_unaligned_le32(k->kv_val + 0);
	key1 = get_unaligned_le16(k->kv_val + 4);
	key2 = get_unaligned_le32(k->kv_val + 6);
	key3 = get_unaligned_le16(k->kv_val + 10);
	key4 = get_unaligned_le32(k->kv_val + 12);
	if (k->kv_len <= WLAN_KEY_LEN_WEP104)
		key4 &= 0xff;

	/*
	 * Note: Key cache registers access special memory area that requires
	 * two 32-bit writes to actually update the values in the internal
	 * memory. Consequently, the exact order and pairs used here must be
	 * maintained.
	 */

	if (keyType == AR_KEYTABLE_TYPE_TKIP) {
		u16 micentry = entry + 64;

		/*
		 * Write inverted key[47:0] first to avoid Michael MIC errors
		 * on frames that could be sent or received at the same time.
		 * The correct key will be written in the end once everything
		 * else is ready.
		 */
		REG_WRITE(ah, AR_KEYTABLE_KEY0(entry), ~key0);
		REG_WRITE(ah, AR_KEYTABLE_KEY1(entry), ~key1);

		/* Write key[95:48] */
		REG_WRITE(ah, AR_KEYTABLE_KEY2(entry), key2);
		REG_WRITE(ah, AR_KEYTABLE_KEY3(entry), key3);

		/* Write key[127:96] and key type */
		REG_WRITE(ah, AR_KEYTABLE_KEY4(entry), key4);
		REG_WRITE(ah, AR_KEYTABLE_TYPE(entry), keyType);

		/* Write MAC address for the entry */
		(void) ath_hw_keysetmac(common, entry, mac);

		if (common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED) {
			/*
			 * TKIP uses two key cache entries:
			 * Michael MIC TX/RX keys in the same key cache entry
			 * (idx = main index + 64):
			 * key0 [31:0] = RX key [31:0]
			 * key1 [15:0] = TX key [31:16]
			 * key1 [31:16] = reserved
			 * key2 [31:0] = RX key [63:32]
			 * key3 [15:0] = TX key [15:0]
			 * key3 [31:16] = reserved
			 * key4 [31:0] = TX key [63:32]
			 */
			u32 mic0, mic1, mic2, mic3, mic4;

			mic0 = get_unaligned_le32(k->kv_mic + 0);
			mic2 = get_unaligned_le32(k->kv_mic + 4);
			mic1 = get_unaligned_le16(k->kv_txmic + 2) & 0xffff;
			mic3 = get_unaligned_le16(k->kv_txmic + 0) & 0xffff;
			mic4 = get_unaligned_le32(k->kv_txmic + 4);

			/* Write RX[31:0] and TX[31:16] */
			REG_WRITE(ah, AR_KEYTABLE_KEY0(micentry), mic0);
			REG_WRITE(ah, AR_KEYTABLE_KEY1(micentry), mic1);

			/* Write RX[63:32] and TX[15:0] */
			REG_WRITE(ah, AR_KEYTABLE_KEY2(micentry), mic2);
			REG_WRITE(ah, AR_KEYTABLE_KEY3(micentry), mic3);

			/* Write TX[63:32] and keyType(reserved) */
			REG_WRITE(ah, AR_KEYTABLE_KEY4(micentry), mic4);
			REG_WRITE(ah, AR_KEYTABLE_TYPE(micentry),
				  AR_KEYTABLE_TYPE_CLR);

		} else {
			/*
			 * TKIP uses four key cache entries (two for group
			 * keys):
			 * Michael MIC TX/RX keys are in different key cache
			 * entries (idx = main index + 64 for TX and
			 * main index + 32 + 96 for RX):
			 * key0 [31:0] = TX/RX MIC key [31:0]
			 * key1 [31:0] = reserved
			 * key2 [31:0] = TX/RX MIC key [63:32]
			 * key3 [31:0] = reserved
			 * key4 [31:0] = reserved
			 *
			 * Upper layer code will call this function separately
			 * for TX and RX keys when these registers offsets are
			 * used.
			 */
			u32 mic0, mic2;

			mic0 = get_unaligned_le32(k->kv_mic + 0);
			mic2 = get_unaligned_le32(k->kv_mic + 4);

			/* Write MIC key[31:0] */
			REG_WRITE(ah, AR_KEYTABLE_KEY0(micentry), mic0);
			REG_WRITE(ah, AR_KEYTABLE_KEY1(micentry), 0);

			/* Write MIC key[63:32] */
			REG_WRITE(ah, AR_KEYTABLE_KEY2(micentry), mic2);
			REG_WRITE(ah, AR_KEYTABLE_KEY3(micentry), 0);

			/* Write TX[63:32] and keyType(reserved) */
			REG_WRITE(ah, AR_KEYTABLE_KEY4(micentry), 0);
			REG_WRITE(ah, AR_KEYTABLE_TYPE(micentry),
				  AR_KEYTABLE_TYPE_CLR);
		}

		/* MAC address registers are reserved for the MIC entry */
		REG_WRITE(ah, AR_KEYTABLE_MAC0(micentry), 0);
		REG_WRITE(ah, AR_KEYTABLE_MAC1(micentry), 0);

		/*
		 * Write the correct (un-inverted) key[47:0] last to enable
		 * TKIP now that all other registers are set with correct
		 * values.
		 */
		REG_WRITE(ah, AR_KEYTABLE_KEY0(entry), key0);
		REG_WRITE(ah, AR_KEYTABLE_KEY1(entry), key1);
	} else {
		/* Write key[47:0] */
		REG_WRITE(ah, AR_KEYTABLE_KEY0(entry), key0);
		REG_WRITE(ah, AR_KEYTABLE_KEY1(entry), key1);

		/* Write key[95:48] */
		REG_WRITE(ah, AR_KEYTABLE_KEY2(entry), key2);
		REG_WRITE(ah, AR_KEYTABLE_KEY3(entry), key3);

		/* Write key[127:96] and key type */
		REG_WRITE(ah, AR_KEYTABLE_KEY4(entry), key4);
		REG_WRITE(ah, AR_KEYTABLE_TYPE(entry), keyType);

		/* Write MAC address for the entry */
		(void) ath_hw_keysetmac(common, entry, mac);
	}

	return true;
}

static int ath_setkey_tkip(struct ath_common *common, u16 keyix, const u8 *key,
			   struct ath_keyval *hk, const u8 *addr,
			   bool authenticator)
{
	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 ath_hw_set_keycache_entry(common, keyix, hk, addr);
	}
	if (common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED) {
		/* 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 ath_hw_set_keycache_entry(common, 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 (!ath_hw_set_keycache_entry(common, keyix, hk, NULL)) {
		/* TX MIC entry failed. No need to proceed further */
		ath_err(common, "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 ath_hw_set_keycache_entry(common, 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->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED) &&
		    (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,
				      u32 cipher)
{
	int i;

	if (cipher == WLAN_CIPHER_SUITE_TKIP)
		return ath_reserve_key_cache_slot_tkip(common);

	/* First, try to find slots that would not be available for TKIP. */
	if (!(common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED)) {
		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->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED)) {
			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 ath_key_config(struct ath_common *common,
			  struct ieee80211_vif *vif,
			  struct ieee80211_sta *sta,
			  struct ieee80211_key_conf *key)
{
	struct ath_keyval hk;
	const u8 *mac = NULL;
	u8 gmac[ETH_ALEN];
	int ret = 0;
	int idx;

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

	switch (key->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_WEP104:
		hk.kv_type = ATH_CIPHER_WEP;
		break;
	case WLAN_CIPHER_SUITE_TKIP:
		hk.kv_type = ATH_CIPHER_TKIP;
		break;
	case WLAN_CIPHER_SUITE_CCMP:
		hk.kv_type = ATH_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)) {
		switch (vif->type) {
		case NL80211_IFTYPE_AP:
			memcpy(gmac, vif->addr, ETH_ALEN);
			gmac[0] |= 0x01;
			mac = gmac;
			idx = ath_reserve_key_cache_slot(common, key->cipher);
			break;
		case NL80211_IFTYPE_ADHOC:
			if (!sta) {
				idx = key->keyidx;
				break;
			}
			memcpy(gmac, sta->addr, ETH_ALEN);
			gmac[0] |= 0x01;
			mac = gmac;
			idx = ath_reserve_key_cache_slot(common, key->cipher);
			break;
		default:
			idx = key->keyidx;
			break;
		}
	} 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;

		idx = ath_reserve_key_cache_slot(common, key->cipher);
	}

	if (idx < 0)
		return -ENOSPC; /* no free key cache entries */

	if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
		ret = ath_setkey_tkip(common, idx, key->key, &hk, mac,
				      vif->type == NL80211_IFTYPE_AP);
	else
		ret = ath_hw_set_keycache_entry(common, idx, &hk, mac);

	if (!ret)
		return -EIO;

	set_bit(idx, common->keymap);
	if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
		set_bit(idx + 64, common->keymap);
		set_bit(idx, common->tkip_keymap);
		set_bit(idx + 64, common->tkip_keymap);
		if (!(common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED)) {
			set_bit(idx + 32, common->keymap);
			set_bit(idx + 64 + 32, common->keymap);
			set_bit(idx + 32, common->tkip_keymap);
			set_bit(idx + 64 + 32, common->tkip_keymap);
		}
	}

	return idx;
}
EXPORT_SYMBOL(ath_key_config);

/*
 * Delete Key.
 */
void ath_key_delete(struct ath_common *common, struct ieee80211_key_conf *key)
{
	ath_hw_keyreset(common, key->hw_key_idx);
	if (key->hw_key_idx < IEEE80211_WEP_NKID)
		return;

	clear_bit(key->hw_key_idx, common->keymap);
	if (key->cipher != WLAN_CIPHER_SUITE_TKIP)
		return;

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

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

	if (!(common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED)) {
		ath_hw_keyreset(common, key->hw_key_idx + 32);
		clear_bit(key->hw_key_idx + 32, common->keymap);
		clear_bit(key->hw_key_idx + 64 + 32, common->keymap);

		clear_bit(key->hw_key_idx + 32, common->tkip_keymap);
		clear_bit(key->hw_key_idx + 64 + 32, common->tkip_keymap);
	}
}
EXPORT_SYMBOL(ath_key_delete);
Commit	Line	Data
1bba5b73 BR	1	/*
	2	* Copyright (c) 2009 Atheros Communications Inc.
	3	* Copyright (c) 2010 Bruno Randolf <br1@einfach.org>
	4	*
	5	* Permission to use, copy, modify, and/or distribute this software for any
	6	* purpose with or without fee is hereby granted, provided that the above
	7	* copyright notice and this permission notice appear in all copies.
	8	*
	9	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	10	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	11	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	12	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	13	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	14	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	15	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	16	*/
	17
	18	#include <asm/unaligned.h>
	19	#include <net/mac80211.h>
	20
	21	#include "ath.h"
	22	#include "reg.h"
1bba5b73 BR	23
	24	#define REG_READ (common->ops->read)
	25	#define REG_WRITE(_ah, _reg, _val) (common->ops->write)(_ah, _val, _reg)
	26
	27	#define IEEE80211_WEP_NKID 4 /* number of key ids */
	28
	29	/************************/
	30	/* Key Cache Management */
	31	/************************/
	32
	33	bool ath_hw_keyreset(struct ath_common *common, u16 entry)
	34	{
	35	u32 keyType;
	36	void *ah = common->ah;
	37
	38	if (entry >= common->keymax) {
3800276a	39	ath_err(common, "keycache entry %u out of range\n", entry);
1bba5b73 BR	40	return false;
	41	}
	42
	43	keyType = REG_READ(ah, AR_KEYTABLE_TYPE(entry));
	44
	45	REG_WRITE(ah, AR_KEYTABLE_KEY0(entry), 0);
	46	REG_WRITE(ah, AR_KEYTABLE_KEY1(entry), 0);
	47	REG_WRITE(ah, AR_KEYTABLE_KEY2(entry), 0);
	48	REG_WRITE(ah, AR_KEYTABLE_KEY3(entry), 0);
	49	REG_WRITE(ah, AR_KEYTABLE_KEY4(entry), 0);
	50	REG_WRITE(ah, AR_KEYTABLE_TYPE(entry), AR_KEYTABLE_TYPE_CLR);
	51	REG_WRITE(ah, AR_KEYTABLE_MAC0(entry), 0);
	52	REG_WRITE(ah, AR_KEYTABLE_MAC1(entry), 0);
	53
	54	if (keyType == AR_KEYTABLE_TYPE_TKIP) {
	55	u16 micentry = entry + 64;
	56
	57	REG_WRITE(ah, AR_KEYTABLE_KEY0(micentry), 0);
	58	REG_WRITE(ah, AR_KEYTABLE_KEY1(micentry), 0);
	59	REG_WRITE(ah, AR_KEYTABLE_KEY2(micentry), 0);
	60	REG_WRITE(ah, AR_KEYTABLE_KEY3(micentry), 0);
8e546104	61	if (common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED) {
998d516d	62	REG_WRITE(ah, AR_KEYTABLE_KEY4(micentry), 0);
8e546104 JM	63	REG_WRITE(ah, AR_KEYTABLE_TYPE(micentry),
	64	AR_KEYTABLE_TYPE_CLR);
	65	}
1bba5b73 BR	66
	67	}
	68
	69	return true;
	70	}
	71	EXPORT_SYMBOL(ath_hw_keyreset);
	72
a3685d11 LR	73	static bool ath_hw_keysetmac(struct ath_common *common,
a3685d11 LR	74	u16 entry, const u8 *mac)
1bba5b73 BR	75	{
	76	u32 macHi, macLo;
	77	u32 unicast_flag = AR_KEYTABLE_VALID;
	78	void *ah = common->ah;
	79
	80	if (entry >= common->keymax) {
3800276a	81	ath_err(common, "keycache entry %u out of range\n", entry);
1bba5b73 BR	82	return false;
	83	}
	84
	85	if (mac != NULL) {
	86	/*
	87	* AR_KEYTABLE_VALID indicates that the address is a unicast
	88	* address, which must match the transmitter address for
	89	* decrypting frames.
	90	* Not setting this bit allows the hardware to use the key
	91	* for multicast frame decryption.
	92	*/
	93	if (mac[0] & 0x01)
	94	unicast_flag = 0;
	95
	96	macHi = (mac[5] << 8) \| mac[4];
	97	macLo = (mac[3] << 24) \|
	98	(mac[2] << 16) \|
	99	(mac[1] << 8) \|
	100	mac[0];
	101	macLo >>= 1;
	102	macLo \|= (macHi & 1) << 31;
	103	macHi >>= 1;
	104	} else {
	105	macLo = macHi = 0;
	106	}
	107	REG_WRITE(ah, AR_KEYTABLE_MAC0(entry), macLo);
	108	REG_WRITE(ah, AR_KEYTABLE_MAC1(entry), macHi \| unicast_flag);
	109
	110	return true;
	111	}
	112
f8c2a087 LR	113	static bool ath_hw_set_keycache_entry(struct ath_common *common, u16 entry,
	114	const struct ath_keyval *k,
	115	const u8 *mac)
1bba5b73 BR	116	{
	117	void *ah = common->ah;
	118	u32 key0, key1, key2, key3, key4;
	119	u32 keyType;
	120
	121	if (entry >= common->keymax) {
3800276a	122	ath_err(common, "keycache entry %u out of range\n", entry);
1bba5b73 BR	123	return false;
	124	}
	125
	126	switch (k->kv_type) {
	127	case ATH_CIPHER_AES_OCB:
	128	keyType = AR_KEYTABLE_TYPE_AES;
	129	break;
	130	case ATH_CIPHER_AES_CCM:
	131	if (!(common->crypt_caps & ATH_CRYPT_CAP_CIPHER_AESCCM)) {
226afe68 JP	132	ath_dbg(common, ATH_DBG_ANY,
226afe68 JP	133	"AES-CCM not supported by this mac rev\n");
1bba5b73 BR	134	return false;
	135	}
	136	keyType = AR_KEYTABLE_TYPE_CCM;
	137	break;
	138	case ATH_CIPHER_TKIP:
	139	keyType = AR_KEYTABLE_TYPE_TKIP;
	140	if (entry + 64 >= common->keymax) {
226afe68 JP	141	ath_dbg(common, ATH_DBG_ANY,
226afe68 JP	142	"entry %u inappropriate for TKIP\n", entry);
1bba5b73 BR	143	return false;
	144	}
	145	break;
	146	case ATH_CIPHER_WEP:
	147	if (k->kv_len < WLAN_KEY_LEN_WEP40) {
226afe68 JP	148	ath_dbg(common, ATH_DBG_ANY,
226afe68 JP	149	"WEP key length %u too small\n", k->kv_len);
1bba5b73 BR	150	return false;
	151	}
	152	if (k->kv_len <= WLAN_KEY_LEN_WEP40)
	153	keyType = AR_KEYTABLE_TYPE_40;
	154	else if (k->kv_len <= WLAN_KEY_LEN_WEP104)
	155	keyType = AR_KEYTABLE_TYPE_104;
	156	else
	157	keyType = AR_KEYTABLE_TYPE_128;
	158	break;
	159	case ATH_CIPHER_CLR:
	160	keyType = AR_KEYTABLE_TYPE_CLR;
	161	break;
	162	default:
3800276a	163	ath_err(common, "cipher %u not supported\n", k->kv_type);
1bba5b73 BR	164	return false;
	165	}
	166
	167	key0 = get_unaligned_le32(k->kv_val + 0);
	168	key1 = get_unaligned_le16(k->kv_val + 4);
	169	key2 = get_unaligned_le32(k->kv_val + 6);
	170	key3 = get_unaligned_le16(k->kv_val + 10);
	171	key4 = get_unaligned_le32(k->kv_val + 12);
	172	if (k->kv_len <= WLAN_KEY_LEN_WEP104)
	173	key4 &= 0xff;
	174
	175	/*
	176	* Note: Key cache registers access special memory area that requires
	177	* two 32-bit writes to actually update the values in the internal
	178	* memory. Consequently, the exact order and pairs used here must be
	179	* maintained.
	180	*/
	181
	182	if (keyType == AR_KEYTABLE_TYPE_TKIP) {
	183	u16 micentry = entry + 64;
	184
	185	/*
	186	* Write inverted key[47:0] first to avoid Michael MIC errors
	187	* on frames that could be sent or received at the same time.
	188	* The correct key will be written in the end once everything
	189	* else is ready.
	190	*/
	191	REG_WRITE(ah, AR_KEYTABLE_KEY0(entry), ~key0);
	192	REG_WRITE(ah, AR_KEYTABLE_KEY1(entry), ~key1);
	193
	194	/* Write key[95:48] */
	195	REG_WRITE(ah, AR_KEYTABLE_KEY2(entry), key2);
	196	REG_WRITE(ah, AR_KEYTABLE_KEY3(entry), key3);
	197
	198	/* Write key[127:96] and key type */
	199	REG_WRITE(ah, AR_KEYTABLE_KEY4(entry), key4);
	200	REG_WRITE(ah, AR_KEYTABLE_TYPE(entry), keyType);
	201
	202	/* Write MAC address for the entry */
	203	(void) ath_hw_keysetmac(common, entry, mac);
	204
117675d0	205	if (common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED) {
1bba5b73 BR	206	/*
	207	* TKIP uses two key cache entries:
	208	* Michael MIC TX/RX keys in the same key cache entry
	209	* (idx = main index + 64):
	210	* key0 [31:0] = RX key [31:0]
	211	* key1 [15:0] = TX key [31:16]
	212	* key1 [31:16] = reserved
	213	* key2 [31:0] = RX key [63:32]
	214	* key3 [15:0] = TX key [15:0]
	215	* key3 [31:16] = reserved
	216	* key4 [31:0] = TX key [63:32]
	217	*/
	218	u32 mic0, mic1, mic2, mic3, mic4;
	219
	220	mic0 = get_unaligned_le32(k->kv_mic + 0);
	221	mic2 = get_unaligned_le32(k->kv_mic + 4);
	222	mic1 = get_unaligned_le16(k->kv_txmic + 2) & 0xffff;
	223	mic3 = get_unaligned_le16(k->kv_txmic + 0) & 0xffff;
	224	mic4 = get_unaligned_le32(k->kv_txmic + 4);
	225
	226	/* Write RX[31:0] and TX[31:16] */
	227	REG_WRITE(ah, AR_KEYTABLE_KEY0(micentry), mic0);
	228	REG_WRITE(ah, AR_KEYTABLE_KEY1(micentry), mic1);
	229
	230	/* Write RX[63:32] and TX[15:0] */
	231	REG_WRITE(ah, AR_KEYTABLE_KEY2(micentry), mic2);
	232	REG_WRITE(ah, AR_KEYTABLE_KEY3(micentry), mic3);
	233
	234	/* Write TX[63:32] and keyType(reserved) */
	235	REG_WRITE(ah, AR_KEYTABLE_KEY4(micentry), mic4);
	236	REG_WRITE(ah, AR_KEYTABLE_TYPE(micentry),
	237	AR_KEYTABLE_TYPE_CLR);
	238
	239	} else {
	240	/*
	241	* TKIP uses four key cache entries (two for group
	242	* keys):
	243	* Michael MIC TX/RX keys are in different key cache
	244	* entries (idx = main index + 64 for TX and
	245	* main index + 32 + 96 for RX):
	246	* key0 [31:0] = TX/RX MIC key [31:0]
	247	* key1 [31:0] = reserved
	248	* key2 [31:0] = TX/RX MIC key [63:32]
	249	* key3 [31:0] = reserved
	250	* key4 [31:0] = reserved
	251	*
	252	* Upper layer code will call this function separately
	253	* for TX and RX keys when these registers offsets are
	254	* used.
	255	*/
	256	u32 mic0, mic2;
	257
	258	mic0 = get_unaligned_le32(k->kv_mic + 0);
	259	mic2 = get_unaligned_le32(k->kv_mic + 4);
	260
	261	/* Write MIC key[31:0] */
	262	REG_WRITE(ah, AR_KEYTABLE_KEY0(micentry), mic0);
	263	REG_WRITE(ah, AR_KEYTABLE_KEY1(micentry), 0);
	264
	265	/* Write MIC key[63:32] */
	266	REG_WRITE(ah, AR_KEYTABLE_KEY2(micentry), mic2);
	267	REG_WRITE(ah, AR_KEYTABLE_KEY3(micentry), 0);
	268
	269	/* Write TX[63:32] and keyType(reserved) */
270	REG_WRITE(ah, AR_KEYTABLE_KEY4(micentry), 0);
271	REG_WRITE(ah, AR_KEYTABLE_TYPE(micentry),
272	AR_KEYTABLE_TYPE_CLR);
273	}
274
275	/* MAC address registers are reserved for the MIC entry */
276	REG_WRITE(ah, AR_KEYTABLE_MAC0(micentry), 0);
277	REG_WRITE(ah, AR_KEYTABLE_MAC1(micentry), 0);
278
279	/*
280	* Write the correct (un-inverted) key[47:0] last to enable
281	* TKIP now that all other registers are set with correct
282	* values.
283	*/
284	REG_WRITE(ah, AR_KEYTABLE_KEY0(entry), key0);
285	REG_WRITE(ah, AR_KEYTABLE_KEY1(entry), key1);
286	} else {
287	/* Write key[47:0] */
288	REG_WRITE(ah, AR_KEYTABLE_KEY0(entry), key0);
289	REG_WRITE(ah, AR_KEYTABLE_KEY1(entry), key1);
290
291	/* Write key[95:48] */
292	REG_WRITE(ah, AR_KEYTABLE_KEY2(entry), key2);
293	REG_WRITE(ah, AR_KEYTABLE_KEY3(entry), key3);
294
295	/* Write key[127:96] and key type */
296	REG_WRITE(ah, AR_KEYTABLE_KEY4(entry), key4);
297	REG_WRITE(ah, AR_KEYTABLE_TYPE(entry), keyType);
298
299	/* Write MAC address for the entry */
300	(void) ath_hw_keysetmac(common, entry, mac);
301	}
302
303	return true;
304	}
305
306	static int ath_setkey_tkip(struct ath_common common, u16 keyix, const u8 key,
307	struct ath_keyval hk, const u8 addr,
308	bool authenticator)
309	{
310	const u8 *key_rxmic;
311	const u8 *key_txmic;
312
313	key_txmic = key + NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY;
314	key_rxmic = key + NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY;
315
316	if (addr == NULL) {
317	/*
318	* Group key installation - only two key cache entries are used
319	* regardless of splitmic capability since group key is only
320	* used either for TX or RX.
321	*/
322	if (authenticator) {
323	memcpy(hk->kv_mic, key_txmic, sizeof(hk->kv_mic));
324	memcpy(hk->kv_txmic, key_txmic, sizeof(hk->kv_mic));
325	} else {
326	memcpy(hk->kv_mic, key_rxmic, sizeof(hk->kv_mic));
327	memcpy(hk->kv_txmic, key_rxmic, sizeof(hk->kv_mic));
328	}
329	return ath_hw_set_keycache_entry(common, keyix, hk, addr);
330	}
117675d0	331	if (common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED) {
1bba5b73 BR	332	/* TX and RX keys share the same key cache entry. */
	333	memcpy(hk->kv_mic, key_rxmic, sizeof(hk->kv_mic));
	334	memcpy(hk->kv_txmic, key_txmic, sizeof(hk->kv_txmic));
	335	return ath_hw_set_keycache_entry(common, keyix, hk, addr);
	336	}
	337
	338	/* Separate key cache entries for TX and RX */
	339
	340	/* TX key goes at first index, RX key at +32. */
	341	memcpy(hk->kv_mic, key_txmic, sizeof(hk->kv_mic));
	342	if (!ath_hw_set_keycache_entry(common, keyix, hk, NULL)) {
	343	/* TX MIC entry failed. No need to proceed further */
3800276a	344	ath_err(common, "Setting TX MIC Key Failed\n");
1bba5b73 BR	345	return 0;
	346	}
	347
	348	memcpy(hk->kv_mic, key_rxmic, sizeof(hk->kv_mic));
	349	/* XXX delete tx key on failure? */
	350	return ath_hw_set_keycache_entry(common, keyix + 32, hk, addr);
	351	}
	352
	353	static int ath_reserve_key_cache_slot_tkip(struct ath_common *common)
	354	{
	355	int i;
	356
	357	for (i = IEEE80211_WEP_NKID; i < common->keymax / 2; i++) {
	358	if (test_bit(i, common->keymap) \|\|
	359	test_bit(i + 64, common->keymap))
	360	continue; /* At least one part of TKIP key allocated */
117675d0	361	if (!(common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED) &&
1bba5b73 BR	362	(test_bit(i + 32, common->keymap) \|\|
	363	test_bit(i + 64 + 32, common->keymap)))
	364	continue; /* At least one part of TKIP key allocated */
	365
	366	/* Found a free slot for a TKIP key */
	367	return i;
	368	}
	369	return -1;
	370	}
	371
	372	static int ath_reserve_key_cache_slot(struct ath_common *common,
	373	u32 cipher)
	374	{
	375	int i;
	376
	377	if (cipher == WLAN_CIPHER_SUITE_TKIP)
	378	return ath_reserve_key_cache_slot_tkip(common);
	379
	380	/* First, try to find slots that would not be available for TKIP. */
117675d0	381	if (!(common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED)) {
1bba5b73 BR	382	for (i = IEEE80211_WEP_NKID; i < common->keymax / 4; i++) {
	383	if (!test_bit(i, common->keymap) &&
	384	(test_bit(i + 32, common->keymap) \|\|
	385	test_bit(i + 64, common->keymap) \|\|
	386	test_bit(i + 64 + 32, common->keymap)))
	387	return i;
	388	if (!test_bit(i + 32, common->keymap) &&
	389	(test_bit(i, common->keymap) \|\|
	390	test_bit(i + 64, common->keymap) \|\|
	391	test_bit(i + 64 + 32, common->keymap)))
	392	return i + 32;
	393	if (!test_bit(i + 64, common->keymap) &&
	394	(test_bit(i , common->keymap) \|\|
	395	test_bit(i + 32, common->keymap) \|\|
	396	test_bit(i + 64 + 32, common->keymap)))
	397	return i + 64;
	398	if (!test_bit(i + 64 + 32, common->keymap) &&
	399	(test_bit(i, common->keymap) \|\|
	400	test_bit(i + 32, common->keymap) \|\|
	401	test_bit(i + 64, common->keymap)))
	402	return i + 64 + 32;
	403	}
	404	} else {
	405	for (i = IEEE80211_WEP_NKID; i < common->keymax / 2; i++) {
	406	if (!test_bit(i, common->keymap) &&
	407	test_bit(i + 64, common->keymap))
	408	return i;
	409	if (test_bit(i, common->keymap) &&
	410	!test_bit(i + 64, common->keymap))
	411	return i + 64;
	412	}
	413	}
	414
	415	/* No partially used TKIP slots, pick any available slot */
	416	for (i = IEEE80211_WEP_NKID; i < common->keymax; i++) {
	417	/* Do not allow slots that could be needed for TKIP group keys
	418	* to be used. This limitation could be removed if we know that
	419	* TKIP will not be used. */
	420	if (i >= 64 && i < 64 + IEEE80211_WEP_NKID)
	421	continue;
117675d0	422	if (!(common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED)) {
1bba5b73 BR	423	if (i >= 32 && i < 32 + IEEE80211_WEP_NKID)
	424	continue;
	425	if (i >= 64 + 32 && i < 64 + 32 + IEEE80211_WEP_NKID)
	426	continue;
	427	}
	428
	429	if (!test_bit(i, common->keymap))
	430	return i; /* Found a free slot for a key */
	431	}
	432
	433	/* No free slot found */
	434	return -1;
	435	}
	436
	437	/*
	438	* Configure encryption in the HW.
	439	*/
	440	int ath_key_config(struct ath_common *common,
	441	struct ieee80211_vif *vif,
	442	struct ieee80211_sta *sta,
	443	struct ieee80211_key_conf *key)
	444	{
	445	struct ath_keyval hk;
	446	const u8 *mac = NULL;
	447	u8 gmac[ETH_ALEN];
	448	int ret = 0;
	449	int idx;
	450
	451	memset(&hk, 0, sizeof(hk));
	452
	453	switch (key->cipher) {
	454	case WLAN_CIPHER_SUITE_WEP40:
	455	case WLAN_CIPHER_SUITE_WEP104:
	456	hk.kv_type = ATH_CIPHER_WEP;
	457	break;
	458	case WLAN_CIPHER_SUITE_TKIP:
	459	hk.kv_type = ATH_CIPHER_TKIP;
	460	break;
	461	case WLAN_CIPHER_SUITE_CCMP:
	462	hk.kv_type = ATH_CIPHER_AES_CCM;
	463	break;
	464	default:
	465	return -EOPNOTSUPP;
	466	}
	467
	468	hk.kv_len = key->keylen;
	469	memcpy(hk.kv_val, key->key, key->keylen);
	470
	471	if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
	472	switch (vif->type) {
	473	case NL80211_IFTYPE_AP:
	474	memcpy(gmac, vif->addr, ETH_ALEN);
	475	gmac[0] \|= 0x01;
	476	mac = gmac;
	477	idx = ath_reserve_key_cache_slot(common, key->cipher);
	478	break;
	479	case NL80211_IFTYPE_ADHOC:
	480	if (!sta) {
	481	idx = key->keyidx;
	482	break;
	483	}
	484	memcpy(gmac, sta->addr, ETH_ALEN);
	485	gmac[0] \|= 0x01;
	486	mac = gmac;
487	idx = ath_reserve_key_cache_slot(common, key->cipher);
488	break;
489	default:
490	idx = key->keyidx;
491	break;
492	}
493	} else if (key->keyidx) {
494	if (WARN_ON(!sta))
495	return -EOPNOTSUPP;
496	mac = sta->addr;
497
498	if (vif->type != NL80211_IFTYPE_AP) {
499	/* Only keyidx 0 should be used with unicast key, but
500	* allow this for client mode for now. */
501	idx = key->keyidx;
502	} else
503	return -EIO;
504	} else {
505	if (WARN_ON(!sta))
506	return -EOPNOTSUPP;
507	mac = sta->addr;
508
509	idx = ath_reserve_key_cache_slot(common, key->cipher);
510	}
511
512	if (idx < 0)
513	return -ENOSPC; /* no free key cache entries */
514
515	if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
516	ret = ath_setkey_tkip(common, idx, key->key, &hk, mac,
517	vif->type == NL80211_IFTYPE_AP);
518	else
519	ret = ath_hw_set_keycache_entry(common, idx, &hk, mac);
520
521	if (!ret)
522	return -EIO;
523
524	set_bit(idx, common->keymap);
525	if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
526	set_bit(idx + 64, common->keymap);
527	set_bit(idx, common->tkip_keymap);
528	set_bit(idx + 64, common->tkip_keymap);
117675d0	529	if (!(common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED)) {
1bba5b73 BR	530	set_bit(idx + 32, common->keymap);
	531	set_bit(idx + 64 + 32, common->keymap);
	532	set_bit(idx + 32, common->tkip_keymap);
	533	set_bit(idx + 64 + 32, common->tkip_keymap);
	534	}
	535	}
	536
	537	return idx;
	538	}
	539	EXPORT_SYMBOL(ath_key_config);
	540
	541	/*
	542	* Delete Key.
	543	*/
	544	void ath_key_delete(struct ath_common common, struct ieee80211_key_conf key)
	545	{
	546	ath_hw_keyreset(common, key->hw_key_idx);
	547	if (key->hw_key_idx < IEEE80211_WEP_NKID)
	548	return;
	549
	550	clear_bit(key->hw_key_idx, common->keymap);
	551	if (key->cipher != WLAN_CIPHER_SUITE_TKIP)
	552	return;
	553
	554	clear_bit(key->hw_key_idx + 64, common->keymap);
	555
	556	clear_bit(key->hw_key_idx, common->tkip_keymap);
	557	clear_bit(key->hw_key_idx + 64, common->tkip_keymap);
	558
117675d0	559	if (!(common->crypt_caps & ATH_CRYPT_CAP_MIC_COMBINED)) {
1bba5b73 BR	560	ath_hw_keyreset(common, key->hw_key_idx + 32);
	561	clear_bit(key->hw_key_idx + 32, common->keymap);
	562	clear_bit(key->hw_key_idx + 64 + 32, common->keymap);
	563
	564	clear_bit(key->hw_key_idx + 32, common->tkip_keymap);
	565	clear_bit(key->hw_key_idx + 64 + 32, common->tkip_keymap);
	566	}
	567	}
	568	EXPORT_SYMBOL(ath_key_delete);