2 * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer,
10 * without modification.
11 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
12 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
13 * redistribution must be conditioned upon including a substantially
14 * similar Disclaimer requirement for further binary redistribution.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
20 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
22 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
27 * THE POSSIBILITY OF SUCH DAMAGES.
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
34 * Driver for the Atheros Wireless LAN controller.
36 * This software is derived from work of Atsushi Onoe; his contribution
37 * is greatly appreciated.
44 #include <sys/param.h>
45 #include <sys/systm.h>
46 #include <sys/sysctl.h>
48 #include <sys/malloc.h>
50 #include <sys/mutex.h>
51 #include <sys/kernel.h>
52 #include <sys/socket.h>
53 #include <sys/sockio.h>
54 #include <sys/errno.h>
55 #include <sys/callout.h>
57 #include <sys/endian.h>
58 #include <sys/kthread.h>
59 #include <sys/taskqueue.h>
62 #include <machine/bus.h>
65 #include <net/if_dl.h>
66 #include <net/if_media.h>
67 #include <net/if_types.h>
68 #include <net/if_arp.h>
69 #include <net/ethernet.h>
70 #include <net/if_llc.h>
72 #include <net80211/ieee80211_var.h>
76 #include <dev/ath/if_athvar.h>
78 #include <dev/ath/if_ath_debug.h>
79 #include <dev/ath/if_ath_keycache.h>
83 ath_keyprint(struct ath_softc *sc, const char *tag, u_int ix,
84 const HAL_KEYVAL *hk, const u_int8_t mac[IEEE80211_ADDR_LEN])
86 static const char *ciphers[] = {
96 printf("%s: [%02u] %-7s ", tag, ix, ciphers[hk->kv_type]);
97 for (i = 0, n = hk->kv_len; i < n; i++)
98 printf("%02x", hk->kv_val[i]);
99 printf(" mac %s", ether_sprintf(mac));
100 if (hk->kv_type == HAL_CIPHER_TKIP) {
101 printf(" %s ", sc->sc_splitmic ? "mic" : "rxmic");
102 for (i = 0; i < sizeof(hk->kv_mic); i++)
103 printf("%02x", hk->kv_mic[i]);
104 if (!sc->sc_splitmic) {
106 for (i = 0; i < sizeof(hk->kv_txmic); i++)
107 printf("%02x", hk->kv_txmic[i]);
115 * Set a TKIP key into the hardware. This handles the
116 * potential distribution of key state to multiple key
117 * cache slots for TKIP.
120 ath_keyset_tkip(struct ath_softc *sc, const struct ieee80211_key *k,
121 HAL_KEYVAL *hk, const u_int8_t mac[IEEE80211_ADDR_LEN])
123 #define IEEE80211_KEY_XR (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV)
124 static const u_int8_t zerobssid[IEEE80211_ADDR_LEN];
125 struct ath_hal *ah = sc->sc_ah;
127 KASSERT(k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP,
128 ("got a non-TKIP key, cipher %u", k->wk_cipher->ic_cipher));
129 if ((k->wk_flags & IEEE80211_KEY_XR) == IEEE80211_KEY_XR) {
130 if (sc->sc_splitmic) {
132 * TX key goes at first index, RX key at the rx index.
133 * The hal handles the MIC keys at index+64.
135 memcpy(hk->kv_mic, k->wk_txmic, sizeof(hk->kv_mic));
136 KEYPRINTF(sc, k->wk_keyix, hk, zerobssid);
137 if (!ath_hal_keyset(ah, k->wk_keyix, hk, zerobssid))
140 memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
141 KEYPRINTF(sc, k->wk_keyix+32, hk, mac);
142 /* XXX delete tx key on failure? */
143 return ath_hal_keyset(ah, k->wk_keyix+32, hk, mac);
146 * Room for both TX+RX MIC keys in one key cache
147 * slot, just set key at the first index; the hal
148 * will handle the rest.
150 memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
151 memcpy(hk->kv_txmic, k->wk_txmic, sizeof(hk->kv_txmic));
152 KEYPRINTF(sc, k->wk_keyix, hk, mac);
153 return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
155 } else if (k->wk_flags & IEEE80211_KEY_XMIT) {
156 if (sc->sc_splitmic) {
158 * NB: must pass MIC key in expected location when
159 * the keycache only holds one MIC key per entry.
161 memcpy(hk->kv_mic, k->wk_txmic, sizeof(hk->kv_txmic));
163 memcpy(hk->kv_txmic, k->wk_txmic, sizeof(hk->kv_txmic));
164 KEYPRINTF(sc, k->wk_keyix, hk, mac);
165 return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
166 } else if (k->wk_flags & IEEE80211_KEY_RECV) {
167 memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
168 KEYPRINTF(sc, k->wk_keyix, hk, mac);
169 return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
172 #undef IEEE80211_KEY_XR
176 * Set a net80211 key into the hardware. This handles the
177 * potential distribution of key state to multiple key
178 * cache slots for TKIP with hardware MIC support.
181 ath_keyset(struct ath_softc *sc, const struct ieee80211_key *k,
182 struct ieee80211_node *bss)
184 #define N(a) (sizeof(a)/sizeof(a[0]))
185 static const u_int8_t ciphermap[] = {
186 HAL_CIPHER_WEP, /* IEEE80211_CIPHER_WEP */
187 HAL_CIPHER_TKIP, /* IEEE80211_CIPHER_TKIP */
188 HAL_CIPHER_AES_OCB, /* IEEE80211_CIPHER_AES_OCB */
189 HAL_CIPHER_AES_CCM, /* IEEE80211_CIPHER_AES_CCM */
190 (u_int8_t) -1, /* 4 is not allocated */
191 HAL_CIPHER_CKIP, /* IEEE80211_CIPHER_CKIP */
192 HAL_CIPHER_CLR, /* IEEE80211_CIPHER_NONE */
194 struct ath_hal *ah = sc->sc_ah;
195 const struct ieee80211_cipher *cip = k->wk_cipher;
196 u_int8_t gmac[IEEE80211_ADDR_LEN];
200 memset(&hk, 0, sizeof(hk));
202 * Software crypto uses a "clear key" so non-crypto
203 * state kept in the key cache are maintained and
204 * so that rx frames have an entry to match.
206 if ((k->wk_flags & IEEE80211_KEY_SWCRYPT) == 0) {
207 KASSERT(cip->ic_cipher < N(ciphermap),
208 ("invalid cipher type %u", cip->ic_cipher));
209 hk.kv_type = ciphermap[cip->ic_cipher];
210 hk.kv_len = k->wk_keylen;
211 memcpy(hk.kv_val, k->wk_key, k->wk_keylen);
213 hk.kv_type = HAL_CIPHER_CLR;
215 if ((k->wk_flags & IEEE80211_KEY_GROUP) && sc->sc_mcastkey) {
217 * Group keys on hardware that supports multicast frame
218 * key search use a MAC that is the sender's address with
219 * the multicast bit set instead of the app-specified address.
221 IEEE80211_ADDR_COPY(gmac, bss->ni_macaddr);
227 if (hk.kv_type == HAL_CIPHER_TKIP &&
228 (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
229 return ath_keyset_tkip(sc, k, &hk, mac);
231 KEYPRINTF(sc, k->wk_keyix, &hk, mac);
232 return ath_hal_keyset(ah, k->wk_keyix, &hk, mac);
238 * Allocate tx/rx key slots for TKIP. We allocate two slots for
239 * each key, one for decrypt/encrypt and the other for the MIC.
242 key_alloc_2pair(struct ath_softc *sc,
243 ieee80211_keyix *txkeyix, ieee80211_keyix *rxkeyix)
245 #define N(a) (sizeof(a)/sizeof(a[0]))
248 KASSERT(sc->sc_splitmic, ("key cache !split"));
249 /* XXX could optimize */
250 for (i = 0; i < N(sc->sc_keymap)/4; i++) {
251 u_int8_t b = sc->sc_keymap[i];
254 * One or more slots in this byte are free.
262 /* XXX IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV */
263 if (isset(sc->sc_keymap, keyix+32) ||
264 isset(sc->sc_keymap, keyix+64) ||
265 isset(sc->sc_keymap, keyix+32+64)) {
266 /* full pair unavailable */
268 if (keyix == (i+1)*NBBY) {
269 /* no slots were appropriate, advance */
274 setbit(sc->sc_keymap, keyix);
275 setbit(sc->sc_keymap, keyix+64);
276 setbit(sc->sc_keymap, keyix+32);
277 setbit(sc->sc_keymap, keyix+32+64);
278 DPRINTF(sc, ATH_DEBUG_KEYCACHE,
279 "%s: key pair %u,%u %u,%u\n",
280 __func__, keyix, keyix+64,
281 keyix+32, keyix+32+64);
287 DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of pair space\n", __func__);
293 * Allocate tx/rx key slots for TKIP. We allocate two slots for
294 * each key, one for decrypt/encrypt and the other for the MIC.
297 key_alloc_pair(struct ath_softc *sc,
298 ieee80211_keyix *txkeyix, ieee80211_keyix *rxkeyix)
300 #define N(a) (sizeof(a)/sizeof(a[0]))
303 KASSERT(!sc->sc_splitmic, ("key cache split"));
304 /* XXX could optimize */
305 for (i = 0; i < N(sc->sc_keymap)/4; i++) {
306 u_int8_t b = sc->sc_keymap[i];
309 * One or more slots in this byte are free.
317 if (isset(sc->sc_keymap, keyix+64)) {
318 /* full pair unavailable */
320 if (keyix == (i+1)*NBBY) {
321 /* no slots were appropriate, advance */
326 setbit(sc->sc_keymap, keyix);
327 setbit(sc->sc_keymap, keyix+64);
328 DPRINTF(sc, ATH_DEBUG_KEYCACHE,
329 "%s: key pair %u,%u\n",
330 __func__, keyix, keyix+64);
331 *txkeyix = *rxkeyix = keyix;
335 DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of pair space\n", __func__);
341 * Allocate a single key cache slot.
344 key_alloc_single(struct ath_softc *sc,
345 ieee80211_keyix *txkeyix, ieee80211_keyix *rxkeyix)
347 #define N(a) (sizeof(a)/sizeof(a[0]))
350 /* XXX try i,i+32,i+64,i+32+64 to minimize key pair conflicts */
351 for (i = 0; i < N(sc->sc_keymap); i++) {
352 u_int8_t b = sc->sc_keymap[i];
355 * One or more slots are free.
360 setbit(sc->sc_keymap, keyix);
361 DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: key %u\n",
363 *txkeyix = *rxkeyix = keyix;
367 DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of space\n", __func__);
373 * Allocate one or more key cache slots for a uniacst key. The
374 * key itself is needed only to identify the cipher. For hardware
375 * TKIP with split cipher+MIC keys we allocate two key cache slot
376 * pairs so that we can setup separate TX and RX MIC keys. Note
377 * that the MIC key for a TKIP key at slot i is assumed by the
378 * hardware to be at slot i+64. This limits TKIP keys to the first
382 ath_key_alloc(struct ieee80211vap *vap, struct ieee80211_key *k,
383 ieee80211_keyix *keyix, ieee80211_keyix *rxkeyix)
385 struct ath_softc *sc = vap->iv_ic->ic_ifp->if_softc;
388 * Group key allocation must be handled specially for
389 * parts that do not support multicast key cache search
390 * functionality. For those parts the key id must match
391 * the h/w key index so lookups find the right key. On
392 * parts w/ the key search facility we install the sender's
393 * mac address (with the high bit set) and let the hardware
394 * find the key w/o using the key id. This is preferred as
395 * it permits us to support multiple users for adhoc and/or
396 * multi-station operation.
398 if (k->wk_keyix != IEEE80211_KEYIX_NONE) {
400 * Only global keys should have key index assigned.
402 if (!(&vap->iv_nw_keys[0] <= k &&
403 k < &vap->iv_nw_keys[IEEE80211_WEP_NKID])) {
404 /* should not happen */
405 DPRINTF(sc, ATH_DEBUG_KEYCACHE,
406 "%s: bogus group key\n", __func__);
409 if (vap->iv_opmode != IEEE80211_M_HOSTAP ||
410 !(k->wk_flags & IEEE80211_KEY_GROUP) ||
413 * XXX we pre-allocate the global keys so
414 * have no way to check if they've already
417 *keyix = *rxkeyix = k - vap->iv_nw_keys;
421 * Group key and device supports multicast key search.
423 k->wk_keyix = IEEE80211_KEYIX_NONE;
427 * We allocate two pair for TKIP when using the h/w to do
428 * the MIC. For everything else, including software crypto,
429 * we allocate a single entry. Note that s/w crypto requires
430 * a pass-through slot on the 5211 and 5212. The 5210 does
431 * not support pass-through cache entries and we map all
432 * those requests to slot 0.
434 if (k->wk_flags & IEEE80211_KEY_SWCRYPT) {
435 return key_alloc_single(sc, keyix, rxkeyix);
436 } else if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP &&
437 (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
439 return key_alloc_2pair(sc, keyix, rxkeyix);
441 return key_alloc_pair(sc, keyix, rxkeyix);
443 return key_alloc_single(sc, keyix, rxkeyix);
448 * Delete an entry in the key cache allocated by ath_key_alloc.
451 ath_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k)
453 struct ath_softc *sc = vap->iv_ic->ic_ifp->if_softc;
454 struct ath_hal *ah = sc->sc_ah;
455 const struct ieee80211_cipher *cip = k->wk_cipher;
456 u_int keyix = k->wk_keyix;
458 DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: delete key %u\n", __func__, keyix);
460 ath_hal_keyreset(ah, keyix);
462 * Handle split tx/rx keying required for TKIP with h/w MIC.
464 if (cip->ic_cipher == IEEE80211_CIPHER_TKIP &&
465 (k->wk_flags & IEEE80211_KEY_SWMIC) == 0 && sc->sc_splitmic)
466 ath_hal_keyreset(ah, keyix+32); /* RX key */
467 if (keyix >= IEEE80211_WEP_NKID) {
469 * Don't touch keymap entries for global keys so
470 * they are never considered for dynamic allocation.
472 clrbit(sc->sc_keymap, keyix);
473 if (cip->ic_cipher == IEEE80211_CIPHER_TKIP &&
474 (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
475 clrbit(sc->sc_keymap, keyix+64); /* TX key MIC */
476 if (sc->sc_splitmic) {
477 /* +32 for RX key, +32+64 for RX key MIC */
478 clrbit(sc->sc_keymap, keyix+32);
479 clrbit(sc->sc_keymap, keyix+32+64);
487 * Set the key cache contents for the specified key. Key cache
488 * slot(s) must already have been allocated by ath_key_alloc.
491 ath_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k,
492 const u_int8_t mac[IEEE80211_ADDR_LEN])
494 struct ath_softc *sc = vap->iv_ic->ic_ifp->if_softc;
496 return ath_keyset(sc, k, vap->iv_bss);