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