279fc7cb8f030057962877a09b00dec4546cb8c6
[dragonfly.git] / sys / dev / netif / ath / ath / if_ath.c
1 /*-
2  * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
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.
15  *
16  * NO WARRANTY
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.
28  *
29  * $FreeBSD: head/sys/dev/ath/if_ath.c 203751 2010-02-10 11:12:39Z rpaulo $");
30  */
31
32 /*
33  * Driver for the Atheros Wireless LAN controller.
34  *
35  * This software is derived from work of Atsushi Onoe; his contribution
36  * is greatly appreciated.
37  */
38
39 #include "opt_inet.h"
40 #include "opt_ath.h"
41 #include "opt_wlan.h"
42
43 #include <sys/param.h>
44 #include <sys/systm.h> 
45 #include <sys/sysctl.h>
46 #include <sys/mbuf.h>   
47 #include <sys/malloc.h>
48 #include <sys/lock.h>
49 #include <sys/mutex.h>
50 #include <sys/kernel.h>
51 #include <sys/socket.h>
52 #include <sys/sockio.h>
53 #include <sys/errno.h>
54 #include <sys/callout.h>
55 #include <sys/bus.h>
56 #include <sys/endian.h>
57 #include <sys/kthread.h>
58 #include <sys/taskqueue.h>
59 #include <sys/priv.h>
60
61 #include <net/if.h>
62 #include <net/if_dl.h>
63 #include <net/if_media.h>
64 #include <net/if_types.h>
65 #include <net/if_arp.h>
66 #include <net/if_llc.h>
67 #include <net/ifq_var.h>
68
69 #include <netproto/802_11/ieee80211_var.h>
70 #include <netproto/802_11/ieee80211_regdomain.h>
71 #ifdef IEEE80211_SUPPORT_SUPERG
72 #include <netproto/802_11/ieee80211_superg.h>
73 #endif
74 #ifdef IEEE80211_SUPPORT_TDMA
75 #include <netproto/802_11/ieee80211_tdma.h>
76 #endif
77
78 #include <net/bpf.h>
79
80 #ifdef INET
81 #include <netinet/in.h> 
82 #include <netinet/if_ether.h>
83 #endif
84
85 #include <dev/netif/ath/ath/if_athvar.h>
86 #include <dev/netif/ath/hal/ath_hal/ah_devid.h>         /* XXX for softled */
87
88 #ifdef ATH_TX99_DIAG
89 #include <dev/netif/ath_tx99/ath_tx99.h>
90 #endif
91
92 /*
93  * ATH_BCBUF determines the number of vap's that can transmit
94  * beacons and also (currently) the number of vap's that can
95  * have unique mac addresses/bssid.  When staggering beacons
96  * 4 is probably a good max as otherwise the beacons become
97  * very closely spaced and there is limited time for cab q traffic
98  * to go out.  You can burst beacons instead but that is not good
99  * for stations in power save and at some point you really want
100  * another radio (and channel).
101  *
102  * The limit on the number of mac addresses is tied to our use of
103  * the U/L bit and tracking addresses in a byte; it would be
104  * worthwhile to allow more for applications like proxy sta.
105  */
106 CTASSERT(ATH_BCBUF <= 8);
107
108 /* unaligned little endian access */
109 #define LE_READ_2(p)                                                    \
110         ((u_int16_t)                                                    \
111          ((((u_int8_t *)(p))[0]      ) | (((u_int8_t *)(p))[1] <<  8)))
112 #define LE_READ_4(p)                                                    \
113         ((u_int32_t)                                                    \
114          ((((u_int8_t *)(p))[0]      ) | (((u_int8_t *)(p))[1] <<  8) | \
115           (((u_int8_t *)(p))[2] << 16) | (((u_int8_t *)(p))[3] << 24)))
116
117 static struct ieee80211vap *ath_vap_create(struct ieee80211com *,
118                     const char name[IFNAMSIZ], int unit, int opmode,
119                     int flags, const uint8_t bssid[IEEE80211_ADDR_LEN],
120                     const uint8_t mac[IEEE80211_ADDR_LEN]);
121 static void     ath_vap_delete(struct ieee80211vap *);
122 static void     ath_init(void *);
123 static void     ath_stop_locked(struct ifnet *);
124 static void     ath_stop(struct ifnet *);
125 static void     ath_start(struct ifnet *);
126 static int      ath_reset(struct ifnet *);
127 static int      ath_reset_vap(struct ieee80211vap *, u_long);
128 static int      ath_media_change(struct ifnet *);
129 static void     ath_watchdog_callout(void *);
130 static int      ath_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
131 static void     ath_fatal_proc(void *, int);
132 static void     ath_bmiss_vap(struct ieee80211vap *);
133 static void     ath_bmiss_task(void *, int);
134 static int      ath_keyset(struct ath_softc *, const struct ieee80211_key *,
135                         struct ieee80211_node *);
136 static int      ath_key_alloc(struct ieee80211vap *,
137                         struct ieee80211_key *,
138                         ieee80211_keyix *, ieee80211_keyix *);
139 static int      ath_key_delete(struct ieee80211vap *,
140                         const struct ieee80211_key *);
141 static int      ath_key_set(struct ieee80211vap *, const struct ieee80211_key *,
142                         const u_int8_t mac[IEEE80211_ADDR_LEN]);
143 static void     ath_key_update_begin(struct ieee80211vap *);
144 static void     ath_key_update_end(struct ieee80211vap *);
145 static void     ath_update_mcast(struct ifnet *);
146 static void     ath_update_promisc(struct ifnet *);
147 static void     ath_mode_init(struct ath_softc *);
148 static void     ath_setslottime(struct ath_softc *);
149 static void     ath_updateslot(struct ifnet *);
150 static int      ath_beaconq_setup(struct ath_hal *);
151 static int      ath_beacon_alloc(struct ath_softc *, struct ieee80211_node *);
152 static void     ath_beacon_update(struct ieee80211vap *, int item);
153 static void     ath_beacon_setup(struct ath_softc *, struct ath_buf *);
154 static void     ath_beacon_proc(void *, int);
155 static struct ath_buf *ath_beacon_generate(struct ath_softc *,
156                         struct ieee80211vap *);
157 static void     ath_bstuck_task(void *, int);
158 static void     ath_beacon_return(struct ath_softc *, struct ath_buf *);
159 static void     ath_beacon_free(struct ath_softc *);
160 static void     ath_beacon_config(struct ath_softc *, struct ieee80211vap *);
161 static void     ath_descdma_cleanup(struct ath_softc *sc,
162                         struct ath_descdma *, ath_bufhead *);
163 static int      ath_desc_alloc(struct ath_softc *);
164 static void     ath_desc_free(struct ath_softc *);
165 static struct ieee80211_node *ath_node_alloc(struct ieee80211vap *,
166                         const uint8_t [IEEE80211_ADDR_LEN]);
167 static void     ath_node_free(struct ieee80211_node *);
168 static void     ath_node_getsignal(const struct ieee80211_node *,
169                         int8_t *, int8_t *);
170 static int      ath_rxbuf_init(struct ath_softc *, struct ath_buf *);
171 static void     ath_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m,
172                         int subtype, int rssi, int nf);
173 static void     ath_setdefantenna(struct ath_softc *, u_int);
174 static void     ath_rx_task(void *, int);
175 static void     ath_txq_init(struct ath_softc *sc, struct ath_txq *, int);
176 static struct ath_txq *ath_txq_setup(struct ath_softc*, int qtype, int subtype);
177 static int      ath_tx_setup(struct ath_softc *, int, int);
178 static int      ath_wme_update(struct ieee80211com *);
179 static void     ath_tx_cleanupq(struct ath_softc *, struct ath_txq *);
180 static void     ath_tx_cleanup(struct ath_softc *);
181 static void     ath_freetx(struct mbuf *);
182 static int      ath_tx_start(struct ath_softc *, struct ieee80211_node *,
183                              struct ath_buf *, struct mbuf *);
184 static void     ath_tx_task_q0(void *, int);
185 static void     ath_tx_task_q0123(void *, int);
186 static void     ath_tx_task(void *, int);
187 static void     ath_tx_draintxq(struct ath_softc *, struct ath_txq *);
188 static int      ath_chan_set(struct ath_softc *, struct ieee80211_channel *);
189 static void     ath_draintxq(struct ath_softc *);
190 static void     ath_stoprecv(struct ath_softc *);
191 static int      ath_startrecv(struct ath_softc *);
192 static void     ath_chan_change(struct ath_softc *, struct ieee80211_channel *);
193 static void     ath_scan_start(struct ieee80211com *);
194 static void     ath_scan_end(struct ieee80211com *);
195 static void     ath_set_channel(struct ieee80211com *);
196 static void     ath_calibrate_callout(void *);
197 static int      ath_newstate(struct ieee80211vap *, enum ieee80211_state, int);
198 static void     ath_setup_stationkey(struct ieee80211_node *);
199 static void     ath_newassoc(struct ieee80211_node *, int);
200 static int      ath_setregdomain(struct ieee80211com *,
201                     struct ieee80211_regdomain *, int,
202                     struct ieee80211_channel []);
203 static void     ath_getradiocaps(struct ieee80211com *, int, int *,
204                     struct ieee80211_channel []);
205 static int      ath_getchannels(struct ath_softc *);
206 static void     ath_led_event(struct ath_softc *, int);
207
208 static int      ath_rate_setup(struct ath_softc *, u_int mode);
209 static void     ath_setcurmode(struct ath_softc *, enum ieee80211_phymode);
210
211 static void     ath_sysctlattach(struct ath_softc *);
212 static int      ath_raw_xmit(struct ieee80211_node *,
213                         struct mbuf *, const struct ieee80211_bpf_params *);
214 static void     ath_announce(struct ath_softc *);
215
216 #ifdef IEEE80211_SUPPORT_TDMA
217 static void     ath_tdma_settimers(struct ath_softc *sc, u_int32_t nexttbtt,
218                     u_int32_t bintval);
219 static void     ath_tdma_bintvalsetup(struct ath_softc *sc,
220                     const struct ieee80211_tdma_state *tdma);
221 static void     ath_tdma_config(struct ath_softc *sc, struct ieee80211vap *vap);
222 static void     ath_tdma_update(struct ieee80211_node *ni,
223                     const struct ieee80211_tdma_param *tdma, int);
224 static void     ath_tdma_beacon_send(struct ath_softc *sc,
225                     struct ieee80211vap *vap);
226
227 static __inline void
228 ath_hal_setcca(struct ath_hal *ah, int ena)
229 {
230         /*
231          * NB: fill me in; this is not provided by default because disabling
232          *     CCA in most locales violates regulatory.
233          */
234 }
235
236 static __inline int
237 ath_hal_getcca(struct ath_hal *ah)
238 {
239         u_int32_t diag;
240         if (ath_hal_getcapability(ah, HAL_CAP_DIAG, 0, &diag) != HAL_OK)
241                 return 1;
242         return ((diag & 0x500000) == 0);
243 }
244
245 #define TDMA_EP_MULTIPLIER      (1<<10) /* pow2 to optimize out * and / */
246 #define TDMA_LPF_LEN            6
247 #define TDMA_DUMMY_MARKER       0x127
248 #define TDMA_EP_MUL(x, mul)     ((x) * (mul))
249 #define TDMA_IN(x)              (TDMA_EP_MUL((x), TDMA_EP_MULTIPLIER))
250 #define TDMA_LPF(x, y, len) \
251     ((x != TDMA_DUMMY_MARKER) ? (((x) * ((len)-1) + (y)) / (len)) : (y))
252 #define TDMA_SAMPLE(x, y) do {                                  \
253         x = TDMA_LPF((x), TDMA_IN(y), TDMA_LPF_LEN);            \
254 } while (0)
255 #define TDMA_EP_RND(x,mul) \
256         ((((x)%(mul)) >= ((mul)/2)) ? ((x) + ((mul) - 1)) / (mul) : (x)/(mul))
257 #define TDMA_AVG(x)             TDMA_EP_RND(x, TDMA_EP_MULTIPLIER)
258 #endif /* IEEE80211_SUPPORT_TDMA */
259
260 SYSCTL_DECL(_hw_ath);
261
262 /* XXX validate sysctl values */
263 static  int ath_longcalinterval = 30;           /* long cals every 30 secs */
264 SYSCTL_INT(_hw_ath, OID_AUTO, longcal, CTLFLAG_RW, &ath_longcalinterval,
265             0, "long chip calibration interval (secs)");
266 static  int ath_shortcalinterval = 100;         /* short cals every 100 ms */
267 SYSCTL_INT(_hw_ath, OID_AUTO, shortcal, CTLFLAG_RW, &ath_shortcalinterval,
268             0, "short chip calibration interval (msecs)");
269 static  int ath_resetcalinterval = 20*60;       /* reset cal state 20 mins */
270 SYSCTL_INT(_hw_ath, OID_AUTO, resetcal, CTLFLAG_RW, &ath_resetcalinterval,
271             0, "reset chip calibration results (secs)");
272
273 static  int ath_rxbuf = ATH_RXBUF;              /* # rx buffers to allocate */
274 SYSCTL_INT(_hw_ath, OID_AUTO, rxbuf, CTLFLAG_RW, &ath_rxbuf,
275             0, "rx buffers allocated");
276 TUNABLE_INT("hw.ath.rxbuf", &ath_rxbuf);
277 static  int ath_txbuf = ATH_TXBUF;              /* # tx buffers to allocate */
278 SYSCTL_INT(_hw_ath, OID_AUTO, txbuf, CTLFLAG_RW, &ath_txbuf,
279             0, "tx buffers allocated");
280 TUNABLE_INT("hw.ath.txbuf", &ath_txbuf);
281
282 static  int ath_bstuck_threshold = 4;           /* max missed beacons */
283 SYSCTL_INT(_hw_ath, OID_AUTO, bstuck, CTLFLAG_RW, &ath_bstuck_threshold,
284             0, "max missed beacon xmits before chip reset");
285
286 #ifdef ATH_DEBUG
287 enum {
288         ATH_DEBUG_XMIT          = 0x00000001,   /* basic xmit operation */
289         ATH_DEBUG_XMIT_DESC     = 0x00000002,   /* xmit descriptors */
290         ATH_DEBUG_RECV          = 0x00000004,   /* basic recv operation */
291         ATH_DEBUG_RECV_DESC     = 0x00000008,   /* recv descriptors */
292         ATH_DEBUG_RATE          = 0x00000010,   /* rate control */
293         ATH_DEBUG_RESET         = 0x00000020,   /* reset processing */
294         ATH_DEBUG_MODE          = 0x00000040,   /* mode init/setup */
295         ATH_DEBUG_BEACON        = 0x00000080,   /* beacon handling */
296         ATH_DEBUG_WATCHDOG      = 0x00000100,   /* watchdog timeout */
297         ATH_DEBUG_INTR          = 0x00001000,   /* ISR */
298         ATH_DEBUG_TX_PROC       = 0x00002000,   /* tx ISR proc */
299         ATH_DEBUG_RX_PROC       = 0x00004000,   /* rx ISR proc */
300         ATH_DEBUG_BEACON_PROC   = 0x00008000,   /* beacon ISR proc */
301         ATH_DEBUG_CALIBRATE     = 0x00010000,   /* periodic calibration */
302         ATH_DEBUG_KEYCACHE      = 0x00020000,   /* key cache management */
303         ATH_DEBUG_STATE         = 0x00040000,   /* 802.11 state transitions */
304         ATH_DEBUG_NODE          = 0x00080000,   /* node management */
305         ATH_DEBUG_LED           = 0x00100000,   /* led management */
306         ATH_DEBUG_FF            = 0x00200000,   /* fast frames */
307         ATH_DEBUG_DFS           = 0x00400000,   /* DFS processing */
308         ATH_DEBUG_TDMA          = 0x00800000,   /* TDMA processing */
309         ATH_DEBUG_TDMA_TIMER    = 0x01000000,   /* TDMA timer processing */
310         ATH_DEBUG_REGDOMAIN     = 0x02000000,   /* regulatory processing */
311         ATH_DEBUG_FATAL         = 0x80000000,   /* fatal errors */
312         ATH_DEBUG_ANY           = 0xffffffff
313 };
314 static  int ath_debug = 0;
315 SYSCTL_INT(_hw_ath, OID_AUTO, debug, CTLFLAG_RW, &ath_debug,
316             0, "control debugging printfs");
317 TUNABLE_INT("hw.ath.debug", &ath_debug);
318
319 #define IFF_DUMPPKTS(sc, m) \
320         ((sc->sc_debug & (m)) || \
321             (sc->sc_ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) == (IFF_DEBUG|IFF_LINK2))
322 #define DPRINTF(sc, m, fmt, ...) do {                           \
323         if (sc->sc_debug & (m))                                 \
324                 kprintf(fmt, __VA_ARGS__);                      \
325 } while (0)
326 #define KEYPRINTF(sc, ix, hk, mac) do {                         \
327         if (sc->sc_debug & ATH_DEBUG_KEYCACHE)                  \
328                 ath_keyprint(sc, __func__, ix, hk, mac);        \
329 } while (0)
330 static  void ath_printrxbuf(struct ath_softc *, const struct ath_buf *bf,
331         u_int ix, int);
332 static  void ath_printtxbuf(struct ath_softc *, const struct ath_buf *bf,
333         u_int qnum, u_int ix, int done);
334 #else
335 #define IFF_DUMPPKTS(sc, m) \
336         ((sc->sc_ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) == (IFF_DEBUG|IFF_LINK2))
337 #define DPRINTF(sc, m, fmt, ...) do {                           \
338         (void) sc;                                              \
339 } while (0)
340 #define KEYPRINTF(sc, k, ix, mac) do {                          \
341         (void) sc;                                              \
342 } while (0)
343 #endif
344
345 MALLOC_DEFINE(M_ATHDEV, "athdev", "ath driver dma buffers");
346
347 int
348 ath_attach(u_int16_t devid, struct ath_softc *sc)
349 {
350         struct ifnet *ifp;
351         struct ieee80211com *ic;
352         struct ath_hal *ah = NULL;
353         HAL_STATUS status;
354         int error = 0, i;
355         u_int wmodes;
356         uint8_t macaddr[IEEE80211_ADDR_LEN];
357
358         DPRINTF(sc, ATH_DEBUG_ANY, "%s: devid 0x%x\n", __func__, devid);
359
360         ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211);
361         if (ifp == NULL) {
362                 device_printf(sc->sc_dev, "can not if_alloc()\n");
363                 error = ENOSPC;
364                 goto bad;
365         }
366         ic = ifp->if_l2com;
367
368         /* set these up early for if_printf use */
369         if_initname(ifp, device_get_name(sc->sc_dev),
370                 device_get_unit(sc->sc_dev));
371
372         /* prepare sysctl tree for use in sub modules */
373         sysctl_ctx_init(&sc->sc_sysctl_ctx);
374         sc->sc_sysctl_tree = SYSCTL_ADD_NODE(&sc->sc_sysctl_ctx,
375                 SYSCTL_STATIC_CHILDREN(_hw),
376                 OID_AUTO,
377                 device_get_nameunit(sc->sc_dev),
378                 CTLFLAG_RD, 0, "");
379
380         ah = ath_hal_attach(devid, sc, sc->sc_st, sc->sc_sh, &status);
381         if (ah == NULL) {
382                 if_printf(ifp, "unable to attach hardware; HAL status %u\n",
383                         status);
384                 error = ENXIO;
385                 goto bad;
386         }
387         sc->sc_ah = ah;
388         sc->sc_invalid = 0;     /* ready to go, enable interrupt handling */
389 #ifdef  ATH_DEBUG
390         sc->sc_debug = ath_debug;
391 #endif
392
393         /*
394          * Check if the MAC has multi-rate retry support.
395          * We do this by trying to setup a fake extended
396          * descriptor.  MAC's that don't have support will
397          * return false w/o doing anything.  MAC's that do
398          * support it will return true w/o doing anything.
399          */
400         sc->sc_mrretry = ath_hal_setupxtxdesc(ah, NULL, 0,0, 0,0, 0,0);
401
402         /*
403          * Check if the device has hardware counters for PHY
404          * errors.  If so we need to enable the MIB interrupt
405          * so we can act on stat triggers.
406          */
407         if (ath_hal_hwphycounters(ah))
408                 sc->sc_needmib = 1;
409
410         /*
411          * Get the hardware key cache size.
412          */
413         sc->sc_keymax = ath_hal_keycachesize(ah);
414         if (sc->sc_keymax > ATH_KEYMAX) {
415                 if_printf(ifp, "Warning, using only %u of %u key cache slots\n",
416                         ATH_KEYMAX, sc->sc_keymax);
417                 sc->sc_keymax = ATH_KEYMAX;
418         }
419         /*
420          * Reset the key cache since some parts do not
421          * reset the contents on initial power up.
422          */
423         for (i = 0; i < sc->sc_keymax; i++)
424                 ath_hal_keyreset(ah, i);
425
426         /*
427          * Collect the default channel list.
428          */
429         error = ath_getchannels(sc);
430         if (error != 0)
431                 goto bad;
432
433         /*
434          * Setup rate tables for all potential media types.
435          */
436         ath_rate_setup(sc, IEEE80211_MODE_11A);
437         ath_rate_setup(sc, IEEE80211_MODE_11B);
438         ath_rate_setup(sc, IEEE80211_MODE_11G);
439         ath_rate_setup(sc, IEEE80211_MODE_TURBO_A);
440         ath_rate_setup(sc, IEEE80211_MODE_TURBO_G);
441         ath_rate_setup(sc, IEEE80211_MODE_STURBO_A);
442         ath_rate_setup(sc, IEEE80211_MODE_11NA);
443         ath_rate_setup(sc, IEEE80211_MODE_11NG);
444         ath_rate_setup(sc, IEEE80211_MODE_HALF);
445         ath_rate_setup(sc, IEEE80211_MODE_QUARTER);
446
447         /* NB: setup here so ath_rate_update is happy */
448         ath_setcurmode(sc, IEEE80211_MODE_11A);
449
450         /*
451          * Allocate tx+rx descriptors and populate the lists.
452          */
453         wlan_assert_serialized();
454         wlan_serialize_exit();
455         error = ath_desc_alloc(sc);
456         wlan_serialize_enter();
457         if (error != 0) {
458                 if_printf(ifp, "failed to allocate descriptors: %d\n", error);
459                 goto bad;
460         }
461         callout_init(&sc->sc_cal_ch);
462         callout_init(&sc->sc_wd_ch);
463
464         sc->sc_tq = taskqueue_create("ath_taskq", M_INTWAIT,
465                 taskqueue_thread_enqueue, &sc->sc_tq);
466         taskqueue_start_threads(&sc->sc_tq, 1, TDPRI_KERN_DAEMON, -1,
467                 "%s taskq", ifp->if_xname);
468
469         TASK_INIT(&sc->sc_rxtask, 0, ath_rx_task, sc);
470         TASK_INIT(&sc->sc_bmisstask, 0, ath_bmiss_task, sc);
471         TASK_INIT(&sc->sc_bstucktask,0, ath_bstuck_task, sc);
472
473         /*
474          * Allocate hardware transmit queues: one queue for
475          * beacon frames and one data queue for each QoS
476          * priority.  Note that the hal handles reseting
477          * these queues at the needed time.
478          *
479          * XXX PS-Poll
480          */
481         sc->sc_bhalq = ath_beaconq_setup(ah);
482         if (sc->sc_bhalq == (u_int) -1) {
483                 if_printf(ifp, "unable to setup a beacon xmit queue!\n");
484                 error = EIO;
485                 goto bad2;
486         }
487         sc->sc_cabq = ath_txq_setup(sc, HAL_TX_QUEUE_CAB, 0);
488         if (sc->sc_cabq == NULL) {
489                 if_printf(ifp, "unable to setup CAB xmit queue!\n");
490                 error = EIO;
491                 goto bad2;
492         }
493         /* NB: insure BK queue is the lowest priority h/w queue */
494         if (!ath_tx_setup(sc, WME_AC_BK, HAL_WME_AC_BK)) {
495                 if_printf(ifp, "unable to setup xmit queue for %s traffic!\n",
496                         ieee80211_wme_acnames[WME_AC_BK]);
497                 error = EIO;
498                 goto bad2;
499         }
500         if (!ath_tx_setup(sc, WME_AC_BE, HAL_WME_AC_BE) ||
501             !ath_tx_setup(sc, WME_AC_VI, HAL_WME_AC_VI) ||
502             !ath_tx_setup(sc, WME_AC_VO, HAL_WME_AC_VO)) {
503                 /*
504                  * Not enough hardware tx queues to properly do WME;
505                  * just punt and assign them all to the same h/w queue.
506                  * We could do a better job of this if, for example,
507                  * we allocate queues when we switch from station to
508                  * AP mode.
509                  */
510                 if (sc->sc_ac2q[WME_AC_VI] != NULL)
511                         ath_tx_cleanupq(sc, sc->sc_ac2q[WME_AC_VI]);
512                 if (sc->sc_ac2q[WME_AC_BE] != NULL)
513                         ath_tx_cleanupq(sc, sc->sc_ac2q[WME_AC_BE]);
514                 sc->sc_ac2q[WME_AC_BE] = sc->sc_ac2q[WME_AC_BK];
515                 sc->sc_ac2q[WME_AC_VI] = sc->sc_ac2q[WME_AC_BK];
516                 sc->sc_ac2q[WME_AC_VO] = sc->sc_ac2q[WME_AC_BK];
517         }
518
519         /*
520          * Special case certain configurations.  Note the
521          * CAB queue is handled by these specially so don't
522          * include them when checking the txq setup mask.
523          */
524         switch (sc->sc_txqsetup &~ (1<<sc->sc_cabq->axq_qnum)) {
525         case 0x01:
526                 TASK_INIT(&sc->sc_txtask, 0, ath_tx_task_q0, sc);
527                 break;
528         case 0x0f:
529                 TASK_INIT(&sc->sc_txtask, 0, ath_tx_task_q0123, sc);
530                 break;
531         default:
532                 TASK_INIT(&sc->sc_txtask, 0, ath_tx_task, sc);
533                 break;
534         }
535
536         /*
537          * Setup rate control.  Some rate control modules
538          * call back to change the anntena state so expose
539          * the necessary entry points.
540          * XXX maybe belongs in struct ath_ratectrl?
541          */
542         sc->sc_setdefantenna = ath_setdefantenna;
543         sc->sc_rc = ath_rate_attach(sc);
544         if (sc->sc_rc == NULL) {
545                 error = EIO;
546                 goto bad2;
547         }
548
549         sc->sc_blinking = 0;
550         sc->sc_ledstate = 1;
551         sc->sc_ledon = 0;                       /* low true */
552         sc->sc_ledidle = (2700*hz)/1000;        /* 2.7sec */
553         callout_init_mp(&sc->sc_ledtimer);
554         /*
555          * Auto-enable soft led processing for IBM cards and for
556          * 5211 minipci cards.  Users can also manually enable/disable
557          * support with a sysctl.
558          */
559         sc->sc_softled = (devid == AR5212_DEVID_IBM || devid == AR5211_DEVID);
560         if (sc->sc_softled) {
561                 ath_hal_gpioCfgOutput(ah, sc->sc_ledpin,
562                     HAL_GPIO_MUX_MAC_NETWORK_LED);
563                 ath_hal_gpioset(ah, sc->sc_ledpin, !sc->sc_ledon);
564         }
565
566         ifp->if_softc = sc;
567         ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
568         ifp->if_start = ath_start;
569         ifp->if_ioctl = ath_ioctl;
570         ifp->if_init = ath_init;
571         ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
572         ifq_set_ready(&ifp->if_snd);
573
574         ic->ic_ifp = ifp;
575         /* XXX not right but it's not used anywhere important */
576         ic->ic_phytype = IEEE80211_T_OFDM;
577         ic->ic_opmode = IEEE80211_M_STA;
578         ic->ic_caps =
579                   IEEE80211_C_STA               /* station mode */
580                 | IEEE80211_C_IBSS              /* ibss, nee adhoc, mode */
581                 | IEEE80211_C_HOSTAP            /* hostap mode */
582                 | IEEE80211_C_MONITOR           /* monitor mode */
583                 | IEEE80211_C_AHDEMO            /* adhoc demo mode */
584                 | IEEE80211_C_WDS               /* 4-address traffic works */
585                 | IEEE80211_C_MBSS              /* mesh point link mode */
586                 | IEEE80211_C_SHPREAMBLE        /* short preamble supported */
587                 | IEEE80211_C_SHSLOT            /* short slot time supported */
588                 | IEEE80211_C_WPA               /* capable of WPA1+WPA2 */
589                 | IEEE80211_C_BGSCAN            /* capable of bg scanning */
590                 | IEEE80211_C_TXFRAG            /* handle tx frags */
591                 ;
592         /*
593          * Query the hal to figure out h/w crypto support.
594          */
595         if (ath_hal_ciphersupported(ah, HAL_CIPHER_WEP))
596                 ic->ic_cryptocaps |= IEEE80211_CRYPTO_WEP;
597         if (ath_hal_ciphersupported(ah, HAL_CIPHER_AES_OCB))
598                 ic->ic_cryptocaps |= IEEE80211_CRYPTO_AES_OCB;
599         if (ath_hal_ciphersupported(ah, HAL_CIPHER_AES_CCM))
600                 ic->ic_cryptocaps |= IEEE80211_CRYPTO_AES_CCM;
601         if (ath_hal_ciphersupported(ah, HAL_CIPHER_CKIP))
602                 ic->ic_cryptocaps |= IEEE80211_CRYPTO_CKIP;
603         if (ath_hal_ciphersupported(ah, HAL_CIPHER_TKIP)) {
604                 ic->ic_cryptocaps |= IEEE80211_CRYPTO_TKIP;
605                 /*
606                  * Check if h/w does the MIC and/or whether the
607                  * separate key cache entries are required to
608                  * handle both tx+rx MIC keys.
609                  */
610                 if (ath_hal_ciphersupported(ah, HAL_CIPHER_MIC))
611                         ic->ic_cryptocaps |= IEEE80211_CRYPTO_TKIPMIC;
612                 /*
613                  * If the h/w supports storing tx+rx MIC keys
614                  * in one cache slot automatically enable use.
615                  */
616                 if (ath_hal_hastkipsplit(ah) ||
617                     !ath_hal_settkipsplit(ah, AH_FALSE))
618                         sc->sc_splitmic = 1;
619                 /*
620                  * If the h/w can do TKIP MIC together with WME then
621                  * we use it; otherwise we force the MIC to be done
622                  * in software by the net80211 layer.
623                  */
624                 if (ath_hal_haswmetkipmic(ah))
625                         sc->sc_wmetkipmic = 1;
626         }
627         sc->sc_hasclrkey = ath_hal_ciphersupported(ah, HAL_CIPHER_CLR);
628         /*
629          * Check for multicast key search support.
630          */
631         if (ath_hal_hasmcastkeysearch(sc->sc_ah) &&
632             !ath_hal_getmcastkeysearch(sc->sc_ah)) {
633                 ath_hal_setmcastkeysearch(sc->sc_ah, 1);
634         }
635         sc->sc_mcastkey = ath_hal_getmcastkeysearch(ah);
636         /*
637          * Mark key cache slots associated with global keys
638          * as in use.  If we knew TKIP was not to be used we
639          * could leave the +32, +64, and +32+64 slots free.
640          */
641         for (i = 0; i < IEEE80211_WEP_NKID; i++) {
642                 setbit(sc->sc_keymap, i);
643                 setbit(sc->sc_keymap, i+64);
644                 if (sc->sc_splitmic) {
645                         setbit(sc->sc_keymap, i+32);
646                         setbit(sc->sc_keymap, i+32+64);
647                 }
648         }
649         /*
650          * TPC support can be done either with a global cap or
651          * per-packet support.  The latter is not available on
652          * all parts.  We're a bit pedantic here as all parts
653          * support a global cap.
654          */
655         if (ath_hal_hastpc(ah) || ath_hal_hastxpowlimit(ah))
656                 ic->ic_caps |= IEEE80211_C_TXPMGT;
657
658         /*
659          * Mark WME capability only if we have sufficient
660          * hardware queues to do proper priority scheduling.
661          */
662         if (sc->sc_ac2q[WME_AC_BE] != sc->sc_ac2q[WME_AC_BK])
663                 ic->ic_caps |= IEEE80211_C_WME;
664         /*
665          * Check for misc other capabilities.
666          */
667         if (ath_hal_hasbursting(ah))
668                 ic->ic_caps |= IEEE80211_C_BURST;
669         sc->sc_hasbmask = ath_hal_hasbssidmask(ah);
670         sc->sc_hasbmatch = ath_hal_hasbssidmatch(ah);
671         sc->sc_hastsfadd = ath_hal_hastsfadjust(ah);
672         if (ath_hal_hasfastframes(ah))
673                 ic->ic_caps |= IEEE80211_C_FF;
674         wmodes = ath_hal_getwirelessmodes(ah);
675         if (wmodes & (HAL_MODE_108G|HAL_MODE_TURBO))
676                 ic->ic_caps |= IEEE80211_C_TURBOP;
677 #ifdef IEEE80211_SUPPORT_TDMA
678         if (ath_hal_macversion(ah) > 0x78) {
679                 ic->ic_caps |= IEEE80211_C_TDMA; /* capable of TDMA */
680                 ic->ic_tdma_update = ath_tdma_update;
681         }
682 #endif
683         /*
684          * Indicate we need the 802.11 header padded to a
685          * 32-bit boundary for 4-address and QoS frames.
686          */
687         ic->ic_flags |= IEEE80211_F_DATAPAD;
688
689         /*
690          * Query the hal about antenna support.
691          */
692         sc->sc_defant = ath_hal_getdefantenna(ah);
693
694         /*
695          * Not all chips have the VEOL support we want to
696          * use with IBSS beacons; check here for it.
697          */
698         sc->sc_hasveol = ath_hal_hasveol(ah);
699
700         /* get mac address from hardware */
701         ath_hal_getmac(ah, macaddr);
702         if (sc->sc_hasbmask)
703                 ath_hal_getbssidmask(ah, sc->sc_hwbssidmask);
704
705         /* NB: used to size node table key mapping array */
706         ic->ic_max_keyix = sc->sc_keymax;
707         /* call MI attach routine. */
708         ieee80211_ifattach(ic, macaddr);
709         ic->ic_setregdomain = ath_setregdomain;
710         ic->ic_getradiocaps = ath_getradiocaps;
711         sc->sc_opmode = HAL_M_STA;
712
713         /* override default methods */
714         ic->ic_newassoc = ath_newassoc;
715         ic->ic_updateslot = ath_updateslot;
716         ic->ic_wme.wme_update = ath_wme_update;
717         ic->ic_vap_create = ath_vap_create;
718         ic->ic_vap_delete = ath_vap_delete;
719         ic->ic_raw_xmit = ath_raw_xmit;
720         ic->ic_update_mcast = ath_update_mcast;
721         ic->ic_update_promisc = ath_update_promisc;
722         ic->ic_node_alloc = ath_node_alloc;
723         sc->sc_node_free = ic->ic_node_free;
724         ic->ic_node_free = ath_node_free;
725         ic->ic_node_getsignal = ath_node_getsignal;
726         ic->ic_scan_start = ath_scan_start;
727         ic->ic_scan_end = ath_scan_end;
728         ic->ic_set_channel = ath_set_channel;
729
730         ieee80211_radiotap_attach(ic,
731             &sc->sc_tx_th.wt_ihdr, sizeof(sc->sc_tx_th),
732                 ATH_TX_RADIOTAP_PRESENT,
733             &sc->sc_rx_th.wr_ihdr, sizeof(sc->sc_rx_th),
734                 ATH_RX_RADIOTAP_PRESENT);
735
736         /*
737          * Setup dynamic sysctl's now that country code and
738          * regdomain are available from the hal.
739          */
740         ath_sysctlattach(sc);
741
742         if (bootverbose)
743                 ieee80211_announce(ic);
744         ath_announce(sc);
745         return 0;
746 bad2:
747         ath_tx_cleanup(sc);
748         ath_desc_free(sc);
749 bad:
750         if (ah)
751                 ath_hal_detach(ah);
752         if (ifp != NULL)
753                 if_free(ifp);
754         sc->sc_invalid = 1;
755         return error;
756 }
757
758 int
759 ath_detach(struct ath_softc *sc)
760 {
761         struct ifnet *ifp = sc->sc_ifp;
762
763         DPRINTF(sc, ATH_DEBUG_ANY, "%s: if_flags %x\n",
764                 __func__, ifp->if_flags);
765
766         /* 
767          * NB: the order of these is important:
768          * o stop the chip so no more interrupts will fire
769          * o call the 802.11 layer before detaching the hal to
770          *   insure callbacks into the driver to delete global
771          *   key cache entries can be handled
772          * o free the taskqueue which drains any pending tasks
773          * o reclaim the tx queue data structures after calling
774          *   the 802.11 layer as we'll get called back to reclaim
775          *   node state and potentially want to use them
776          * o to cleanup the tx queues the hal is called, so detach
777          *   it last
778          * Other than that, it's straightforward...
779          */
780         ath_stop(ifp);
781         ieee80211_ifdetach(ifp->if_l2com);
782         taskqueue_free(sc->sc_tq);
783 #ifdef ATH_TX99_DIAG
784         if (sc->sc_tx99 != NULL)
785                 sc->sc_tx99->detach(sc->sc_tx99);
786 #endif
787         ath_rate_detach(sc->sc_rc);
788         ath_desc_free(sc);
789         ath_tx_cleanup(sc);
790         ath_hal_detach(sc->sc_ah);      /* NB: sets chip in full sleep */
791         if (sc->sc_sysctl_tree) {
792                 sysctl_ctx_free(&sc->sc_sysctl_ctx);
793                 sc->sc_sysctl_tree = NULL;
794         }
795         if_free(ifp);
796
797         return 0;
798 }
799
800 /*
801  * MAC address handling for multiple BSS on the same radio.
802  * The first vap uses the MAC address from the EEPROM.  For
803  * subsequent vap's we set the U/L bit (bit 1) in the MAC
804  * address and use the next six bits as an index.
805  */
806 static void
807 assign_address(struct ath_softc *sc, uint8_t mac[IEEE80211_ADDR_LEN], int clone)
808 {
809         int i;
810
811         if (clone && sc->sc_hasbmask) {
812                 /* NB: we only do this if h/w supports multiple bssid */
813                 for (i = 0; i < 8; i++)
814                         if ((sc->sc_bssidmask & (1<<i)) == 0)
815                                 break;
816                 if (i != 0)
817                         mac[0] |= (i << 2)|0x2;
818         } else
819                 i = 0;
820         sc->sc_bssidmask |= 1<<i;
821         sc->sc_hwbssidmask[0] &= ~mac[0];
822         if (i == 0)
823                 sc->sc_nbssid0++;
824 }
825
826 static void
827 reclaim_address(struct ath_softc *sc, const uint8_t mac[IEEE80211_ADDR_LEN])
828 {
829         int i = mac[0] >> 2;
830         uint8_t mask;
831
832         if (i != 0 || --sc->sc_nbssid0 == 0) {
833                 sc->sc_bssidmask &= ~(1<<i);
834                 /* recalculate bssid mask from remaining addresses */
835                 mask = 0xff;
836                 for (i = 1; i < 8; i++)
837                         if (sc->sc_bssidmask & (1<<i))
838                                 mask &= ~((i<<2)|0x2);
839                 sc->sc_hwbssidmask[0] |= mask;
840         }
841 }
842
843 /*
844  * Assign a beacon xmit slot.  We try to space out
845  * assignments so when beacons are staggered the
846  * traffic coming out of the cab q has maximal time
847  * to go out before the next beacon is scheduled.
848  */
849 static int
850 assign_bslot(struct ath_softc *sc)
851 {
852         u_int slot, free;
853
854         free = 0;
855         for (slot = 0; slot < ATH_BCBUF; slot++)
856                 if (sc->sc_bslot[slot] == NULL) {
857                         if (sc->sc_bslot[(slot+1)%ATH_BCBUF] == NULL &&
858                             sc->sc_bslot[(slot-1)%ATH_BCBUF] == NULL)
859                                 return slot;
860                         free = slot;
861                         /* NB: keep looking for a double slot */
862                 }
863         return free;
864 }
865
866 static struct ieee80211vap *
867 ath_vap_create(struct ieee80211com *ic,
868         const char name[IFNAMSIZ], int unit, int opmode, int flags,
869         const uint8_t bssid[IEEE80211_ADDR_LEN],
870         const uint8_t mac0[IEEE80211_ADDR_LEN])
871 {
872         struct ath_softc *sc = ic->ic_ifp->if_softc;
873         struct ath_vap *avp;
874         struct ieee80211vap *vap;
875         uint8_t mac[IEEE80211_ADDR_LEN];
876         int ic_opmode, needbeacon, error;
877
878         avp = (struct ath_vap *) kmalloc(sizeof(struct ath_vap),
879             M_80211_VAP, M_WAITOK | M_ZERO);
880         needbeacon = 0;
881         IEEE80211_ADDR_COPY(mac, mac0);
882
883         ic_opmode = opmode;             /* default to opmode of new vap */
884         switch (opmode) {
885         case IEEE80211_M_STA:
886                 if (sc->sc_nstavaps != 0) {     /* XXX only 1 for now */
887                         device_printf(sc->sc_dev, "only 1 sta vap supported\n");
888                         goto bad;
889                 }
890                 if (sc->sc_nvaps) {
891                         /*
892                          * With multiple vaps we must fall back
893                          * to s/w beacon miss handling.
894                          */
895                         flags |= IEEE80211_CLONE_NOBEACONS;
896                 }
897                 if (flags & IEEE80211_CLONE_NOBEACONS) {
898                         /*
899                          * Station mode w/o beacons are implemented w/ AP mode.
900                          */
901                         ic_opmode = IEEE80211_M_HOSTAP;
902                 }
903                 break;
904         case IEEE80211_M_IBSS:
905                 if (sc->sc_nvaps != 0) {        /* XXX only 1 for now */
906                         device_printf(sc->sc_dev,
907                             "only 1 ibss vap supported\n");
908                         goto bad;
909                 }
910                 needbeacon = 1;
911                 break;
912         case IEEE80211_M_AHDEMO:
913 #ifdef IEEE80211_SUPPORT_TDMA
914                 if (flags & IEEE80211_CLONE_TDMA) {
915                         if (sc->sc_nvaps != 0) {
916                                 device_printf(sc->sc_dev,
917                                     "only 1 tdma vap supported\n");
918                                 goto bad;
919                         }
920                         needbeacon = 1;
921                         flags |= IEEE80211_CLONE_NOBEACONS;
922                 }
923                 /* fall thru... */
924 #endif
925         case IEEE80211_M_MONITOR:
926                 if (sc->sc_nvaps != 0 && ic->ic_opmode != opmode) {
927                         /*
928                          * Adopt existing mode.  Adding a monitor or ahdemo
929                          * vap to an existing configuration is of dubious
930                          * value but should be ok.
931                          */
932                         /* XXX not right for monitor mode */
933                         ic_opmode = ic->ic_opmode;
934                 }
935                 break;
936         case IEEE80211_M_HOSTAP:
937         case IEEE80211_M_MBSS:
938                 needbeacon = 1;
939                 break;
940         case IEEE80211_M_WDS:
941                 if (sc->sc_nvaps != 0 && ic->ic_opmode == IEEE80211_M_STA) {
942                         device_printf(sc->sc_dev,
943                             "wds not supported in sta mode\n");
944                         goto bad;
945                 }
946                 /*
947                  * Silently remove any request for a unique
948                  * bssid; WDS vap's always share the local
949                  * mac address.
950                  */
951                 flags &= ~IEEE80211_CLONE_BSSID;
952                 if (sc->sc_nvaps == 0)
953                         ic_opmode = IEEE80211_M_HOSTAP;
954                 else
955                         ic_opmode = ic->ic_opmode;
956                 break;
957         default:
958                 device_printf(sc->sc_dev, "unknown opmode %d\n", opmode);
959                 goto bad;
960         }
961         /*
962          * Check that a beacon buffer is available; the code below assumes it.
963          */
964         if (needbeacon & STAILQ_EMPTY(&sc->sc_bbuf)) {
965                 device_printf(sc->sc_dev, "no beacon buffer available\n");
966                 goto bad;
967         }
968
969         /* STA, AHDEMO? */
970         if (opmode == IEEE80211_M_HOSTAP || opmode == IEEE80211_M_MBSS) {
971                 assign_address(sc, mac, flags & IEEE80211_CLONE_BSSID);
972                 ath_hal_setbssidmask(sc->sc_ah, sc->sc_hwbssidmask);
973         }
974
975         vap = &avp->av_vap;
976         /* XXX can't hold mutex across if_alloc */
977         error = ieee80211_vap_setup(ic, vap, name, unit, opmode, flags,
978             bssid, mac);
979         if (error != 0) {
980                 device_printf(sc->sc_dev, "%s: error %d creating vap\n",
981                     __func__, error);
982                 goto bad2;
983         }
984
985         /* h/w crypto support */
986         vap->iv_key_alloc = ath_key_alloc;
987         vap->iv_key_delete = ath_key_delete;
988         vap->iv_key_set = ath_key_set;
989         vap->iv_key_update_begin = ath_key_update_begin;
990         vap->iv_key_update_end = ath_key_update_end;
991
992         /* override various methods */
993         avp->av_recv_mgmt = vap->iv_recv_mgmt;
994         vap->iv_recv_mgmt = ath_recv_mgmt;
995         vap->iv_reset = ath_reset_vap;
996         vap->iv_update_beacon = ath_beacon_update;
997         avp->av_newstate = vap->iv_newstate;
998         vap->iv_newstate = ath_newstate;
999         avp->av_bmiss = vap->iv_bmiss;
1000         vap->iv_bmiss = ath_bmiss_vap;
1001
1002         avp->av_bslot = -1;
1003         if (needbeacon) {
1004                 /*
1005                  * Allocate beacon state and setup the q for buffered
1006                  * multicast frames.  We know a beacon buffer is
1007                  * available because we checked above.
1008                  */
1009                 avp->av_bcbuf = STAILQ_FIRST(&sc->sc_bbuf);
1010                 STAILQ_REMOVE_HEAD(&sc->sc_bbuf, bf_list);
1011                 if (opmode != IEEE80211_M_IBSS || !sc->sc_hasveol) {
1012                         /*
1013                          * Assign the vap to a beacon xmit slot.  As above
1014                          * this cannot fail to find a free one.
1015                          */
1016                         avp->av_bslot = assign_bslot(sc);
1017                         KASSERT(sc->sc_bslot[avp->av_bslot] == NULL,
1018                             ("beacon slot %u not empty", avp->av_bslot));
1019                         sc->sc_bslot[avp->av_bslot] = vap;
1020                         sc->sc_nbcnvaps++;
1021                 }
1022                 if (sc->sc_hastsfadd && sc->sc_nbcnvaps > 0) {
1023                         /*
1024                          * Multple vaps are to transmit beacons and we
1025                          * have h/w support for TSF adjusting; enable
1026                          * use of staggered beacons.
1027                          */
1028                         sc->sc_stagbeacons = 1;
1029                 }
1030                 ath_txq_init(sc, &avp->av_mcastq, ATH_TXQ_SWQ);
1031         }
1032
1033         ic->ic_opmode = ic_opmode;
1034         if (opmode != IEEE80211_M_WDS) {
1035                 sc->sc_nvaps++;
1036                 if (opmode == IEEE80211_M_STA)
1037                         sc->sc_nstavaps++;
1038                 if (opmode == IEEE80211_M_MBSS)
1039                         sc->sc_nmeshvaps++;
1040         }
1041         switch (ic_opmode) {
1042         case IEEE80211_M_IBSS:
1043                 sc->sc_opmode = HAL_M_IBSS;
1044                 break;
1045         case IEEE80211_M_STA:
1046                 sc->sc_opmode = HAL_M_STA;
1047                 break;
1048         case IEEE80211_M_AHDEMO:
1049 #ifdef IEEE80211_SUPPORT_TDMA
1050                 if (vap->iv_caps & IEEE80211_C_TDMA) {
1051                         sc->sc_tdma = 1;
1052                         /* NB: disable tsf adjust */
1053                         sc->sc_stagbeacons = 0;
1054                 }
1055                 /*
1056                  * NB: adhoc demo mode is a pseudo mode; to the hal it's
1057                  * just ap mode.
1058                  */
1059                 /* fall thru... */
1060 #endif
1061         case IEEE80211_M_HOSTAP:
1062         case IEEE80211_M_MBSS:
1063                 sc->sc_opmode = HAL_M_HOSTAP;
1064                 break;
1065         case IEEE80211_M_MONITOR:
1066                 sc->sc_opmode = HAL_M_MONITOR;
1067                 break;
1068         default:
1069                 /* XXX should not happen */
1070                 break;
1071         }
1072         if (sc->sc_hastsfadd) {
1073                 /*
1074                  * Configure whether or not TSF adjust should be done.
1075                  */
1076                 ath_hal_settsfadjust(sc->sc_ah, sc->sc_stagbeacons);
1077         }
1078         if (flags & IEEE80211_CLONE_NOBEACONS) {
1079                 /*
1080                  * Enable s/w beacon miss handling.
1081                  */
1082                 sc->sc_swbmiss = 1;
1083         }
1084
1085         /* complete setup */
1086         ieee80211_vap_attach(vap, ath_media_change, ieee80211_media_status);
1087         return vap;
1088 bad2:
1089         reclaim_address(sc, mac);
1090         ath_hal_setbssidmask(sc->sc_ah, sc->sc_hwbssidmask);
1091 bad:
1092         kfree(avp, M_80211_VAP);
1093         return NULL;
1094 }
1095
1096 static void
1097 ath_vap_delete(struct ieee80211vap *vap)
1098 {
1099         struct ieee80211com *ic = vap->iv_ic;
1100         struct ifnet *ifp = ic->ic_ifp;
1101         struct ath_softc *sc = ifp->if_softc;
1102         struct ath_hal *ah = sc->sc_ah;
1103         struct ath_vap *avp = ATH_VAP(vap);
1104
1105         if (ifp->if_flags & IFF_RUNNING) {
1106                 /*
1107                  * Quiesce the hardware while we remove the vap.  In
1108                  * particular we need to reclaim all references to
1109                  * the vap state by any frames pending on the tx queues.
1110                  */
1111                 ath_hal_intrset(ah, 0);         /* disable interrupts */
1112                 ath_draintxq(sc);               /* stop xmit side */
1113                 ath_stoprecv(sc);               /* stop recv side */
1114         }
1115
1116         ieee80211_vap_detach(vap);
1117         /*
1118          * Reclaim beacon state.  Note this must be done before
1119          * the vap instance is reclaimed as we may have a reference
1120          * to it in the buffer for the beacon frame.
1121          */
1122         if (avp->av_bcbuf != NULL) {
1123                 if (avp->av_bslot != -1) {
1124                         sc->sc_bslot[avp->av_bslot] = NULL;
1125                         sc->sc_nbcnvaps--;
1126                 }
1127                 ath_beacon_return(sc, avp->av_bcbuf);
1128                 avp->av_bcbuf = NULL;
1129                 if (sc->sc_nbcnvaps == 0) {
1130                         sc->sc_stagbeacons = 0;
1131                         if (sc->sc_hastsfadd)
1132                                 ath_hal_settsfadjust(sc->sc_ah, 0);
1133                 }
1134                 /*
1135                  * Reclaim any pending mcast frames for the vap.
1136                  */
1137                 ath_tx_draintxq(sc, &avp->av_mcastq);
1138         }
1139         /*
1140          * Update bookkeeping.
1141          */
1142         if (vap->iv_opmode == IEEE80211_M_STA) {
1143                 sc->sc_nstavaps--;
1144                 if (sc->sc_nstavaps == 0 && sc->sc_swbmiss)
1145                         sc->sc_swbmiss = 0;
1146         } else if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
1147             vap->iv_opmode == IEEE80211_M_MBSS) {
1148                 reclaim_address(sc, vap->iv_myaddr);
1149                 ath_hal_setbssidmask(ah, sc->sc_hwbssidmask);
1150                 if (vap->iv_opmode == IEEE80211_M_MBSS)
1151                         sc->sc_nmeshvaps--;
1152         }
1153         if (vap->iv_opmode != IEEE80211_M_WDS)
1154                 sc->sc_nvaps--;
1155 #ifdef IEEE80211_SUPPORT_TDMA
1156         /* TDMA operation ceases when the last vap is destroyed */
1157         if (sc->sc_tdma && sc->sc_nvaps == 0) {
1158                 sc->sc_tdma = 0;
1159                 sc->sc_swbmiss = 0;
1160         }
1161 #endif
1162         kfree(avp, M_80211_VAP);
1163
1164         if (ifp->if_flags & IFF_RUNNING) {
1165                 /*
1166                  * Restart rx+tx machines if still running (RUNNING will
1167                  * be reset if we just destroyed the last vap).
1168                  */
1169                 if (ath_startrecv(sc) != 0)
1170                         if_printf(ifp, "%s: unable to restart recv logic\n",
1171                             __func__);
1172                 if (sc->sc_beacons) {           /* restart beacons */
1173 #ifdef IEEE80211_SUPPORT_TDMA
1174                         if (sc->sc_tdma)
1175                                 ath_tdma_config(sc, NULL);
1176                         else
1177 #endif
1178                                 ath_beacon_config(sc, NULL);
1179                 }
1180                 ath_hal_intrset(ah, sc->sc_imask);
1181         }
1182 }
1183
1184 void
1185 ath_suspend(struct ath_softc *sc)
1186 {
1187         struct ifnet *ifp = sc->sc_ifp;
1188         struct ieee80211com *ic = ifp->if_l2com;
1189
1190         DPRINTF(sc, ATH_DEBUG_ANY, "%s: if_flags %x\n",
1191                 __func__, ifp->if_flags);
1192
1193         sc->sc_resume_up = (ifp->if_flags & IFF_UP) != 0;
1194         if (ic->ic_opmode == IEEE80211_M_STA)
1195                 ath_stop(ifp);
1196         else
1197                 ieee80211_suspend_all(ic);
1198         /*
1199          * NB: don't worry about putting the chip in low power
1200          * mode; pci will power off our socket on suspend and
1201          * CardBus detaches the device.
1202          */
1203 }
1204
1205 /*
1206  * Reset the key cache since some parts do not reset the
1207  * contents on resume.  First we clear all entries, then
1208  * re-load keys that the 802.11 layer assumes are setup
1209  * in h/w.
1210  */
1211 static void
1212 ath_reset_keycache(struct ath_softc *sc)
1213 {
1214         struct ifnet *ifp = sc->sc_ifp;
1215         struct ieee80211com *ic = ifp->if_l2com;
1216         struct ath_hal *ah = sc->sc_ah;
1217         int i;
1218
1219         for (i = 0; i < sc->sc_keymax; i++)
1220                 ath_hal_keyreset(ah, i);
1221         ieee80211_crypto_reload_keys(ic);
1222 }
1223
1224 void
1225 ath_resume(struct ath_softc *sc)
1226 {
1227         struct ifnet *ifp = sc->sc_ifp;
1228         struct ieee80211com *ic = ifp->if_l2com;
1229         struct ath_hal *ah = sc->sc_ah;
1230         HAL_STATUS status;
1231
1232         DPRINTF(sc, ATH_DEBUG_ANY, "%s: if_flags %x\n",
1233                 __func__, ifp->if_flags);
1234
1235         /*
1236          * Must reset the chip before we reload the
1237          * keycache as we were powered down on suspend.
1238          */
1239         ath_hal_reset(ah, sc->sc_opmode,
1240             sc->sc_curchan != NULL ? sc->sc_curchan : ic->ic_curchan,
1241             AH_FALSE, &status);
1242         ath_reset_keycache(sc);
1243         if (sc->sc_resume_up) {
1244                 if (ic->ic_opmode == IEEE80211_M_STA) {
1245                         ath_init(sc);
1246                         /*
1247                          * Program the beacon registers using the last rx'd
1248                          * beacon frame and enable sync on the next beacon
1249                          * we see.  This should handle the case where we
1250                          * wakeup and find the same AP and also the case where
1251                          * we wakeup and need to roam.  For the latter we
1252                          * should get bmiss events that trigger a roam.
1253                          */
1254                         ath_beacon_config(sc, NULL);
1255                         sc->sc_syncbeacon = 1;
1256                 } else
1257                         ieee80211_resume_all(ic);
1258         }
1259         if (sc->sc_softled) {
1260                 ath_hal_gpioCfgOutput(ah, sc->sc_ledpin,
1261                     HAL_GPIO_MUX_MAC_NETWORK_LED);
1262                 ath_hal_gpioset(ah, sc->sc_ledpin, !sc->sc_ledon);
1263         }
1264 }
1265
1266 void
1267 ath_shutdown(struct ath_softc *sc)
1268 {
1269         struct ifnet *ifp = sc->sc_ifp;
1270
1271         DPRINTF(sc, ATH_DEBUG_ANY, "%s: if_flags %x\n",
1272                 __func__, ifp->if_flags);
1273
1274         ath_stop(ifp);
1275         /* NB: no point powering down chip as we're about to reboot */
1276 }
1277
1278 /*
1279  * Interrupt handler.  Most of the actual processing is deferred.
1280  */
1281 void
1282 ath_intr(void *arg)
1283 {
1284         struct ath_softc *sc = arg;
1285         struct ifnet *ifp = sc->sc_ifp;
1286         struct ath_hal *ah = sc->sc_ah;
1287         HAL_INT status;
1288         HAL_INT ostatus;
1289
1290         if (sc->sc_invalid) {
1291                 /*
1292                  * The hardware is not ready/present, don't touch anything.
1293                  * Note this can happen early on if the IRQ is shared.
1294                  */
1295                 DPRINTF(sc, ATH_DEBUG_ANY, "%s: invalid; ignored\n", __func__);
1296                 return;
1297         }
1298
1299         if (!ath_hal_intrpend(ah))              /* shared irq, not for us */
1300                 return;
1301         if ((ifp->if_flags & IFF_UP) == 0 ||
1302             (ifp->if_flags & IFF_RUNNING) == 0) {
1303                 HAL_INT status;
1304
1305                 DPRINTF(sc, ATH_DEBUG_ANY, "%s: if_flags 0x%x\n",
1306                         __func__, ifp->if_flags);
1307                 ath_hal_getisr(ah, &status);    /* clear ISR */
1308                 ath_hal_intrset(ah, 0);         /* disable further intr's */
1309                 return;
1310         }
1311         /*
1312          * Figure out the reason(s) for the interrupt.  Note
1313          * that the hal returns a pseudo-ISR that may include
1314          * bits we haven't explicitly enabled so we mask the
1315          * value to insure we only process bits we requested.
1316          */
1317         ath_hal_getisr(ah, &ostatus);           /* NB: clears ISR too */
1318         DPRINTF(sc, ATH_DEBUG_INTR, "%s: status 0x%x\n", __func__, ostatus);
1319         status = ostatus & sc->sc_imask;        /* discard unasked for bits */
1320         if (status & HAL_INT_FATAL) {
1321                 sc->sc_stats.ast_hardware++;
1322                 ath_hal_intrset(ah, 0);         /* disable intr's until reset */
1323                 ath_fatal_proc(sc, 0);
1324         } else {
1325                 if (status & HAL_INT_SWBA) {
1326                         /*
1327                          * Software beacon alert--time to send a beacon.
1328                          * Handle beacon transmission directly; deferring
1329                          * this is too slow to meet timing constraints
1330                          * under load.
1331                          */
1332 #ifdef IEEE80211_SUPPORT_TDMA
1333                         if (sc->sc_tdma) {
1334                                 if (sc->sc_tdmaswba == 0) {
1335                                         struct ieee80211com *ic = ifp->if_l2com;
1336                                         struct ieee80211vap *vap =
1337                                             TAILQ_FIRST(&ic->ic_vaps);
1338                                         ath_tdma_beacon_send(sc, vap);
1339                                         sc->sc_tdmaswba =
1340                                             vap->iv_tdma->tdma_bintval;
1341                                 } else
1342                                         sc->sc_tdmaswba--;
1343                         } else
1344 #endif
1345                         {
1346                                 ath_beacon_proc(sc, 0);
1347 #ifdef IEEE80211_SUPPORT_SUPERG
1348                                 /*
1349                                  * Schedule the rx taskq in case there's no
1350                                  * traffic so any frames held on the staging
1351                                  * queue are aged and potentially flushed.
1352                                  */
1353                                 taskqueue_enqueue(sc->sc_tq, &sc->sc_rxtask);
1354 #endif
1355                         }
1356                 }
1357
1358                 /*
1359                  * NB: The hardware should re-read the link when the RXE
1360                  *     bit is written, but it doesn't work at least on
1361                  *     older chipsets.
1362                  */
1363                 if (status & HAL_INT_RXEOL) {
1364                         sc->sc_stats.ast_rxeol++;
1365                         sc->sc_rxlink = NULL;
1366                 }
1367
1368                 if (status & HAL_INT_TXURN) {
1369                         sc->sc_stats.ast_txurn++;
1370                         /* bump tx trigger level */
1371                         ath_hal_updatetxtriglevel(ah, AH_TRUE);
1372                 }
1373
1374                 if (status & HAL_INT_RX)
1375                         taskqueue_enqueue(sc->sc_tq, &sc->sc_rxtask);
1376
1377                 if (status & HAL_INT_TX)
1378                         taskqueue_enqueue(sc->sc_tq, &sc->sc_txtask);
1379
1380                 if (status & HAL_INT_BMISS) {
1381                         sc->sc_stats.ast_bmiss++;
1382                         taskqueue_enqueue(sc->sc_tq, &sc->sc_bmisstask);
1383                 }
1384
1385                 if (status & HAL_INT_MIB) {
1386                         sc->sc_stats.ast_mib++;
1387                         /*
1388                          * Disable interrupts until we service the MIB
1389                          * interrupt; otherwise it will continue to fire.
1390                          */
1391                         ath_hal_intrset(ah, 0);
1392                         /*
1393                          * Let the hal handle the event.  We assume it will
1394                          * clear whatever condition caused the interrupt.
1395                          */
1396                         ath_hal_mibevent(ah, &sc->sc_halstats);
1397                         ath_hal_intrset(ah, sc->sc_imask);
1398                 }
1399
1400                 if (status & HAL_INT_RXORN) {
1401                         /* NB: hal marks HAL_INT_FATAL when RXORN is fatal */
1402                         sc->sc_stats.ast_rxorn++;
1403                 }
1404         }
1405 }
1406
1407 static void
1408 ath_fatal_proc(void *arg, int pending)
1409 {
1410         struct ath_softc *sc = arg;
1411         struct ifnet *ifp = sc->sc_ifp;
1412         u_int32_t *state;
1413         u_int32_t len;
1414         void *sp;
1415
1416         if_printf(ifp, "hardware error; resetting\n");
1417         /*
1418          * Fatal errors are unrecoverable.  Typically these
1419          * are caused by DMA errors.  Collect h/w state from
1420          * the hal so we can diagnose what's going on.
1421          */
1422         if (ath_hal_getfatalstate(sc->sc_ah, &sp, &len)) {
1423                 KASSERT(len >= 6*sizeof(u_int32_t), ("len %u bytes", len));
1424                 state = sp;
1425                 if_printf(ifp, "0x%08x 0x%08x 0x%08x, 0x%08x 0x%08x 0x%08x\n",
1426                     state[0], state[1] , state[2], state[3],
1427                     state[4], state[5]);
1428         }
1429         ath_reset(ifp);
1430 }
1431
1432 static void
1433 ath_bmiss_vap(struct ieee80211vap *vap)
1434 {
1435         /*
1436          * Workaround phantom bmiss interrupts by sanity-checking
1437          * the time of our last rx'd frame.  If it is within the
1438          * beacon miss interval then ignore the interrupt.  If it's
1439          * truly a bmiss we'll get another interrupt soon and that'll
1440          * be dispatched up for processing.  Note this applies only
1441          * for h/w beacon miss events.
1442          */
1443         if ((vap->iv_flags_ext & IEEE80211_FEXT_SWBMISS) == 0) {
1444                 struct ifnet *ifp = vap->iv_ic->ic_ifp;
1445                 struct ath_softc *sc = ifp->if_softc;
1446                 u_int64_t lastrx = sc->sc_lastrx;
1447                 u_int64_t tsf = ath_hal_gettsf64(sc->sc_ah);
1448                 u_int bmisstimeout =
1449                         vap->iv_bmissthreshold * vap->iv_bss->ni_intval * 1024;
1450
1451                 DPRINTF(sc, ATH_DEBUG_BEACON,
1452                     "%s: tsf %llu lastrx %lld (%llu) bmiss %u\n",
1453                     __func__, (unsigned long long) tsf,
1454                     (unsigned long long)(tsf - lastrx),
1455                     (unsigned long long) lastrx, bmisstimeout);
1456
1457                 if (tsf - lastrx <= bmisstimeout) {
1458                         sc->sc_stats.ast_bmiss_phantom++;
1459                         return;
1460                 }
1461         }
1462         ATH_VAP(vap)->av_bmiss(vap);
1463 }
1464
1465 static int
1466 ath_hal_gethangstate(struct ath_hal *ah, uint32_t mask, uint32_t *hangs)
1467 {
1468         uint32_t rsize;
1469         void *sp;
1470
1471         if (!ath_hal_getdiagstate(ah, 32, &mask, sizeof(mask), &sp, &rsize))
1472                 return 0;
1473         KASSERT(rsize == sizeof(uint32_t), ("resultsize %u", rsize));
1474         *hangs = *(uint32_t *)sp;
1475         return 1;
1476 }
1477
1478 static void
1479 ath_bmiss_task(void *arg, int pending)
1480 {
1481         struct ath_softc *sc = arg;
1482         struct ifnet *ifp = sc->sc_ifp;
1483         uint32_t hangs;
1484
1485         wlan_serialize_enter();
1486         DPRINTF(sc, ATH_DEBUG_ANY, "%s: pending %u\n", __func__, pending);
1487
1488         if (ath_hal_gethangstate(sc->sc_ah, 0xff, &hangs) && hangs != 0) {
1489                 if_printf(ifp, "bb hang detected (0x%x), reseting\n", hangs); 
1490                 ath_reset(ifp);
1491         } else {
1492                 ieee80211_beacon_miss(ifp->if_l2com);
1493         }
1494         wlan_serialize_exit();
1495 }
1496
1497 /*
1498  * Handle TKIP MIC setup to deal hardware that doesn't do MIC
1499  * calcs together with WME.  If necessary disable the crypto
1500  * hardware and mark the 802.11 state so keys will be setup
1501  * with the MIC work done in software.
1502  */
1503 static void
1504 ath_settkipmic(struct ath_softc *sc)
1505 {
1506         struct ifnet *ifp = sc->sc_ifp;
1507         struct ieee80211com *ic = ifp->if_l2com;
1508
1509         if ((ic->ic_cryptocaps & IEEE80211_CRYPTO_TKIP) && !sc->sc_wmetkipmic) {
1510                 if (ic->ic_flags & IEEE80211_F_WME) {
1511                         ath_hal_settkipmic(sc->sc_ah, AH_FALSE);
1512                         ic->ic_cryptocaps &= ~IEEE80211_CRYPTO_TKIPMIC;
1513                 } else {
1514                         ath_hal_settkipmic(sc->sc_ah, AH_TRUE);
1515                         ic->ic_cryptocaps |= IEEE80211_CRYPTO_TKIPMIC;
1516                 }
1517         }
1518 }
1519
1520 static void
1521 ath_init(void *arg)
1522 {
1523         struct ath_softc *sc = (struct ath_softc *) arg;
1524         struct ifnet *ifp = sc->sc_ifp;
1525         struct ieee80211com *ic = ifp->if_l2com;
1526         struct ath_hal *ah = sc->sc_ah;
1527         HAL_STATUS status;
1528
1529         DPRINTF(sc, ATH_DEBUG_ANY, "%s: if_flags 0x%x\n",
1530                 __func__, ifp->if_flags);
1531
1532         /*
1533          * Stop anything previously setup.  This is safe
1534          * whether this is the first time through or not.
1535          */
1536         ath_stop_locked(ifp);
1537
1538         /*
1539          * The basic interface to setting the hardware in a good
1540          * state is ``reset''.  On return the hardware is known to
1541          * be powered up and with interrupts disabled.  This must
1542          * be followed by initialization of the appropriate bits
1543          * and then setup of the interrupt mask.
1544          */
1545         ath_settkipmic(sc);
1546         if (!ath_hal_reset(ah, sc->sc_opmode, ic->ic_curchan, AH_FALSE, &status)) {
1547                 if_printf(ifp, "unable to reset hardware; hal status %u\n",
1548                         status);
1549                 return;
1550         }
1551         ath_chan_change(sc, ic->ic_curchan);
1552
1553         /*
1554          * Likewise this is set during reset so update
1555          * state cached in the driver.
1556          */
1557         sc->sc_diversity = ath_hal_getdiversity(ah);
1558         sc->sc_lastlongcal = 0;
1559         sc->sc_resetcal = 1;
1560         sc->sc_lastcalreset = 0;
1561
1562         /*
1563          * Setup the hardware after reset: the key cache
1564          * is filled as needed and the receive engine is
1565          * set going.  Frame transmit is handled entirely
1566          * in the frame output path; there's nothing to do
1567          * here except setup the interrupt mask.
1568          */
1569         if (ath_startrecv(sc) != 0) {
1570                 if_printf(ifp, "unable to start recv logic\n");
1571                 return;
1572         }
1573
1574         /*
1575          * Enable interrupts.
1576          */
1577         sc->sc_imask = HAL_INT_RX | HAL_INT_TX
1578                   | HAL_INT_RXEOL | HAL_INT_RXORN
1579                   | HAL_INT_FATAL | HAL_INT_GLOBAL;
1580         /*
1581          * Enable MIB interrupts when there are hardware phy counters.
1582          * Note we only do this (at the moment) for station mode.
1583          */
1584         if (sc->sc_needmib && ic->ic_opmode == IEEE80211_M_STA)
1585                 sc->sc_imask |= HAL_INT_MIB;
1586
1587         ifp->if_flags |= IFF_RUNNING;
1588         callout_reset(&sc->sc_wd_ch, hz, ath_watchdog_callout, sc);
1589         ath_hal_intrset(ah, sc->sc_imask);
1590
1591
1592 #ifdef ATH_TX99_DIAG
1593         if (sc->sc_tx99 != NULL)
1594                 sc->sc_tx99->start(sc->sc_tx99);
1595         else
1596 #endif
1597         ieee80211_start_all(ic);                /* start all vap's */
1598 }
1599
1600 static void
1601 ath_stop_locked(struct ifnet *ifp)
1602 {
1603         struct ath_softc *sc = ifp->if_softc;
1604         struct ath_hal *ah = sc->sc_ah;
1605
1606         DPRINTF(sc, ATH_DEBUG_ANY, "%s: invalid %u if_flags 0x%x\n",
1607                 __func__, sc->sc_invalid, ifp->if_flags);
1608
1609         if (ifp->if_flags & IFF_RUNNING) {
1610                 /*
1611                  * Shutdown the hardware and driver:
1612                  *    reset 802.11 state machine
1613                  *    turn off timers
1614                  *    disable interrupts
1615                  *    turn off the radio
1616                  *    clear transmit machinery
1617                  *    clear receive machinery
1618                  *    drain and release tx queues
1619                  *    reclaim beacon resources
1620                  *    power down hardware
1621                  *
1622                  * Note that some of this work is not possible if the
1623                  * hardware is gone (invalid).
1624                  */
1625 #ifdef ATH_TX99_DIAG
1626                 if (sc->sc_tx99 != NULL)
1627                         sc->sc_tx99->stop(sc->sc_tx99);
1628 #endif
1629                 callout_stop(&sc->sc_wd_ch);
1630                 sc->sc_wd_timer = 0;
1631                 ifp->if_flags &= ~IFF_RUNNING;
1632                 if (!sc->sc_invalid) {
1633                         if (sc->sc_softled) {
1634                                 callout_stop(&sc->sc_ledtimer);
1635                                 ath_hal_gpioset(ah, sc->sc_ledpin,
1636                                         !sc->sc_ledon);
1637                                 sc->sc_blinking = 0;
1638                         }
1639                         ath_hal_intrset(ah, 0);
1640                 }
1641                 ath_draintxq(sc);
1642                 if (!sc->sc_invalid) {
1643                         ath_stoprecv(sc);
1644                         ath_hal_phydisable(ah);
1645                 } else
1646                         sc->sc_rxlink = NULL;
1647                 ath_beacon_free(sc);    /* XXX not needed */
1648         }
1649 }
1650
1651 static void
1652 ath_stop(struct ifnet *ifp)
1653 {
1654         struct ath_softc *sc __unused = ifp->if_softc;
1655
1656         ath_stop_locked(ifp);
1657 }
1658
1659 /*
1660  * Reset the hardware w/o losing operational state.  This is
1661  * basically a more efficient way of doing ath_stop, ath_init,
1662  * followed by state transitions to the current 802.11
1663  * operational state.  Used to recover from various errors and
1664  * to reset or reload hardware state.
1665  */
1666 static int
1667 ath_reset(struct ifnet *ifp)
1668 {
1669         struct ath_softc *sc = ifp->if_softc;
1670         struct ieee80211com *ic = ifp->if_l2com;
1671         struct ath_hal *ah = sc->sc_ah;
1672         HAL_STATUS status;
1673
1674         ath_hal_intrset(ah, 0);         /* disable interrupts */
1675         ath_draintxq(sc);               /* stop xmit side */
1676         ath_stoprecv(sc);               /* stop recv side */
1677         ath_settkipmic(sc);             /* configure TKIP MIC handling */
1678         /* NB: indicate channel change so we do a full reset */
1679         if (!ath_hal_reset(ah, sc->sc_opmode, ic->ic_curchan, AH_TRUE, &status))
1680                 if_printf(ifp, "%s: unable to reset hardware; hal status %u\n",
1681                         __func__, status);
1682         sc->sc_diversity = ath_hal_getdiversity(ah);
1683         if (ath_startrecv(sc) != 0)     /* restart recv */
1684                 if_printf(ifp, "%s: unable to start recv logic\n", __func__);
1685         /*
1686          * We may be doing a reset in response to an ioctl
1687          * that changes the channel so update any state that
1688          * might change as a result.
1689          */
1690         ath_chan_change(sc, ic->ic_curchan);
1691         if (sc->sc_beacons) {           /* restart beacons */
1692 #ifdef IEEE80211_SUPPORT_TDMA
1693                 if (sc->sc_tdma)
1694                         ath_tdma_config(sc, NULL);
1695                 else
1696 #endif
1697                         ath_beacon_config(sc, NULL);
1698         }
1699         ath_hal_intrset(ah, sc->sc_imask);
1700
1701         ath_start(ifp);                 /* restart xmit */
1702         return 0;
1703 }
1704
1705 static int
1706 ath_reset_vap(struct ieee80211vap *vap, u_long cmd)
1707 {
1708         struct ieee80211com *ic = vap->iv_ic;
1709         struct ifnet *ifp = ic->ic_ifp;
1710         struct ath_softc *sc = ifp->if_softc;
1711         struct ath_hal *ah = sc->sc_ah;
1712
1713         switch (cmd) {
1714         case IEEE80211_IOC_TXPOWER:
1715                 /*
1716                  * If per-packet TPC is enabled, then we have nothing
1717                  * to do; otherwise we need to force the global limit.
1718                  * All this can happen directly; no need to reset.
1719                  */
1720                 if (!ath_hal_gettpc(ah))
1721                         ath_hal_settxpowlimit(ah, ic->ic_txpowlimit);
1722                 return 0;
1723         }
1724         return ath_reset(ifp);
1725 }
1726
1727 static struct ath_buf *
1728 _ath_getbuf_locked(struct ath_softc *sc)
1729 {
1730         struct ath_buf *bf;
1731
1732         bf = STAILQ_FIRST(&sc->sc_txbuf);
1733         if (bf != NULL && (bf->bf_flags & ATH_BUF_BUSY) == 0)
1734                 STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);
1735         else
1736                 bf = NULL;
1737         if (bf == NULL) {
1738                 kprintf("ath: ran out of descriptors\n");
1739                 DPRINTF(sc, ATH_DEBUG_XMIT, "%s: %s\n", __func__,
1740                     STAILQ_FIRST(&sc->sc_txbuf) == NULL ?
1741                         "out of xmit buffers" : "xmit buffer busy");
1742         }
1743         return bf;
1744 }
1745
1746 static struct ath_buf *
1747 ath_getbuf(struct ath_softc *sc)
1748 {
1749         struct ath_buf *bf;
1750
1751         bf = _ath_getbuf_locked(sc);
1752         if (bf == NULL) {
1753                 struct ifnet *ifp = sc->sc_ifp;
1754
1755                 DPRINTF(sc, ATH_DEBUG_XMIT, "%s: stop queue\n", __func__);
1756                 sc->sc_stats.ast_tx_qstop++;
1757                 ifp->if_flags |= IFF_OACTIVE;
1758         }
1759         return bf;
1760 }
1761
1762 /*
1763  * Cleanup driver resources when we run out of buffers
1764  * while processing fragments; return the tx buffers
1765  * allocated and drop node references.
1766  */
1767 static void
1768 ath_txfrag_cleanup(struct ath_softc *sc,
1769         ath_bufhead *frags, struct ieee80211_node *ni)
1770 {
1771         struct ath_buf *bf, *next;
1772
1773         STAILQ_FOREACH_MUTABLE(bf, frags, bf_list, next) {
1774                 /* NB: bf assumed clean */
1775                 STAILQ_REMOVE_HEAD(frags, bf_list);
1776                 STAILQ_INSERT_HEAD(&sc->sc_txbuf, bf, bf_list);
1777                 ieee80211_node_decref(ni);
1778         }
1779 }
1780
1781 /*
1782  * Setup xmit of a fragmented frame.  Allocate a buffer
1783  * for each frag and bump the node reference count to
1784  * reflect the held reference to be setup by ath_tx_start.
1785  */
1786 static int
1787 ath_txfrag_setup(struct ath_softc *sc, ath_bufhead *frags,
1788         struct mbuf *m0, struct ieee80211_node *ni)
1789 {
1790         struct mbuf *m;
1791         struct ath_buf *bf;
1792
1793         for (m = m0->m_nextpkt; m != NULL; m = m->m_nextpkt) {
1794                 bf = _ath_getbuf_locked(sc);
1795                 if (bf == NULL) {       /* out of buffers, cleanup */
1796                         ath_txfrag_cleanup(sc, frags, ni);
1797                         break;
1798                 }
1799                 ieee80211_node_incref(ni);
1800                 STAILQ_INSERT_TAIL(frags, bf, bf_list);
1801         }
1802
1803         return !STAILQ_EMPTY(frags);
1804 }
1805
1806 static void
1807 ath_start(struct ifnet *ifp)
1808 {
1809         struct ath_softc *sc = ifp->if_softc;
1810         struct ieee80211_node *ni;
1811         struct ath_buf *bf;
1812         struct mbuf *m, *next;
1813         ath_bufhead frags;
1814
1815         if ((ifp->if_flags & IFF_RUNNING) == 0 || sc->sc_invalid) {
1816                 ifq_purge(&ifp->if_snd);
1817                 return;
1818         }
1819         for (;;) {
1820                 /*
1821                  * Grab a TX buffer and associated resources.
1822                  */
1823                 bf = ath_getbuf(sc);
1824                 if (bf == NULL)
1825                         break;
1826
1827                 IF_DEQUEUE(&ifp->if_snd, m);
1828                 if (m == NULL) {
1829                         STAILQ_INSERT_HEAD(&sc->sc_txbuf, bf, bf_list);
1830                         break;
1831                 }
1832                 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
1833                 /*
1834                  * Check for fragmentation.  If this frame
1835                  * has been broken up verify we have enough
1836                  * buffers to send all the fragments so all
1837                  * go out or none...
1838                  */
1839                 STAILQ_INIT(&frags);
1840                 if ((m->m_flags & M_FRAG) && 
1841                     !ath_txfrag_setup(sc, &frags, m, ni)) {
1842                         DPRINTF(sc, ATH_DEBUG_XMIT,
1843                             "%s: out of txfrag buffers\n", __func__);
1844                         sc->sc_stats.ast_tx_nofrag++;
1845                         ifp->if_oerrors++;
1846                         ath_freetx(m);
1847                         goto bad;
1848                 }
1849                 ifp->if_opackets++;
1850         nextfrag:
1851                 /*
1852                  * Pass the frame to the h/w for transmission.
1853                  * Fragmented frames have each frag chained together
1854                  * with m_nextpkt.  We know there are sufficient ath_buf's
1855                  * to send all the frags because of work done by
1856                  * ath_txfrag_setup.  We leave m_nextpkt set while
1857                  * calling ath_tx_start so it can use it to extend the
1858                  * the tx duration to cover the subsequent frag and
1859                  * so it can reclaim all the mbufs in case of an error;
1860                  * ath_tx_start clears m_nextpkt once it commits to
1861                  * handing the frame to the hardware.
1862                  */
1863                 next = m->m_nextpkt;
1864                 if (ath_tx_start(sc, ni, bf, m)) {
1865         bad:
1866                         ifp->if_oerrors++;
1867         reclaim:
1868                         bf->bf_m = NULL;
1869                         bf->bf_node = NULL;
1870                         STAILQ_INSERT_HEAD(&sc->sc_txbuf, bf, bf_list);
1871                         ath_txfrag_cleanup(sc, &frags, ni);
1872                         if (ni != NULL)
1873                                 ieee80211_free_node(ni);
1874                         continue;
1875                 }
1876                 if (next != NULL) {
1877                         /*
1878                          * Beware of state changing between frags.
1879                          * XXX check sta power-save state?
1880                          */
1881                         if (ni->ni_vap->iv_state != IEEE80211_S_RUN) {
1882                                 DPRINTF(sc, ATH_DEBUG_XMIT,
1883                                     "%s: flush fragmented packet, state %s\n",
1884                                     __func__,
1885                                     ieee80211_state_name[ni->ni_vap->iv_state]);
1886                                 ath_freetx(next);
1887                                 goto reclaim;
1888                         }
1889                         m = next;
1890                         bf = STAILQ_FIRST(&frags);
1891                         KASSERT(bf != NULL, ("no buf for txfrag"));
1892                         STAILQ_REMOVE_HEAD(&frags, bf_list);
1893                         goto nextfrag;
1894                 }
1895
1896                 sc->sc_wd_timer = 5;
1897         }
1898 }
1899
1900 static int
1901 ath_media_change(struct ifnet *ifp)
1902 {
1903         int error = ieee80211_media_change(ifp);
1904         /* NB: only the fixed rate can change and that doesn't need a reset */
1905         return (error == ENETRESET ? 0 : error);
1906 }
1907
1908 #ifdef ATH_DEBUG
1909 static void
1910 ath_keyprint(struct ath_softc *sc, const char *tag, u_int ix,
1911         const HAL_KEYVAL *hk, const u_int8_t mac[IEEE80211_ADDR_LEN])
1912 {
1913         static const char *ciphers[] = {
1914                 "WEP",
1915                 "AES-OCB",
1916                 "AES-CCM",
1917                 "CKIP",
1918                 "TKIP",
1919                 "CLR",
1920         };
1921         int i, n;
1922
1923         kprintf("%s: [%02u] %-7s ", tag, ix, ciphers[hk->kv_type]);
1924         for (i = 0, n = hk->kv_len; i < n; i++)
1925                 kprintf("%02x", hk->kv_val[i]);
1926         kprintf(" mac %6D", mac, ":");
1927         if (hk->kv_type == HAL_CIPHER_TKIP) {
1928                 kprintf(" %s ", sc->sc_splitmic ? "mic" : "rxmic");
1929                 for (i = 0; i < sizeof(hk->kv_mic); i++)
1930                         kprintf("%02x", hk->kv_mic[i]);
1931                 if (!sc->sc_splitmic) {
1932                         kprintf(" txmic ");
1933                         for (i = 0; i < sizeof(hk->kv_txmic); i++)
1934                                 kprintf("%02x", hk->kv_txmic[i]);
1935                 }
1936         }
1937         kprintf("\n");
1938 }
1939 #endif
1940
1941 /*
1942  * Set a TKIP key into the hardware.  This handles the
1943  * potential distribution of key state to multiple key
1944  * cache slots for TKIP.
1945  */
1946 static int
1947 ath_keyset_tkip(struct ath_softc *sc, const struct ieee80211_key *k,
1948         HAL_KEYVAL *hk, const u_int8_t mac[IEEE80211_ADDR_LEN])
1949 {
1950 #define IEEE80211_KEY_XR        (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV)
1951         static const u_int8_t zerobssid[IEEE80211_ADDR_LEN];
1952         struct ath_hal *ah = sc->sc_ah;
1953
1954         KASSERT(k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP,
1955                 ("got a non-TKIP key, cipher %u", k->wk_cipher->ic_cipher));
1956         if ((k->wk_flags & IEEE80211_KEY_XR) == IEEE80211_KEY_XR) {
1957                 if (sc->sc_splitmic) {
1958                         /*
1959                          * TX key goes at first index, RX key at the rx index.
1960                          * The hal handles the MIC keys at index+64.
1961                          */
1962                         memcpy(hk->kv_mic, k->wk_txmic, sizeof(hk->kv_mic));
1963                         KEYPRINTF(sc, k->wk_keyix, hk, zerobssid);
1964                         if (!ath_hal_keyset(ah, k->wk_keyix, hk, zerobssid))
1965                                 return 0;
1966
1967                         memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
1968                         KEYPRINTF(sc, k->wk_keyix+32, hk, mac);
1969                         /* XXX delete tx key on failure? */
1970                         return ath_hal_keyset(ah, k->wk_keyix+32, hk, mac);
1971                 } else {
1972                         /*
1973                          * Room for both TX+RX MIC keys in one key cache
1974                          * slot, just set key at the first index; the hal
1975                          * will handle the rest.
1976                          */
1977                         memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
1978                         memcpy(hk->kv_txmic, k->wk_txmic, sizeof(hk->kv_txmic));
1979                         KEYPRINTF(sc, k->wk_keyix, hk, mac);
1980                         return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
1981                 }
1982         } else if (k->wk_flags & IEEE80211_KEY_XMIT) {
1983                 if (sc->sc_splitmic) {
1984                         /*
1985                          * NB: must pass MIC key in expected location when
1986                          * the keycache only holds one MIC key per entry.
1987                          */
1988                         memcpy(hk->kv_mic, k->wk_txmic, sizeof(hk->kv_txmic));
1989                 } else
1990                         memcpy(hk->kv_txmic, k->wk_txmic, sizeof(hk->kv_txmic));
1991                 KEYPRINTF(sc, k->wk_keyix, hk, mac);
1992                 return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
1993         } else if (k->wk_flags & IEEE80211_KEY_RECV) {
1994                 memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
1995                 KEYPRINTF(sc, k->wk_keyix, hk, mac);
1996                 return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
1997         }
1998         return 0;
1999 #undef IEEE80211_KEY_XR
2000 }
2001
2002 /*
2003  * Set a net80211 key into the hardware.  This handles the
2004  * potential distribution of key state to multiple key
2005  * cache slots for TKIP with hardware MIC support.
2006  */
2007 static int
2008 ath_keyset(struct ath_softc *sc, const struct ieee80211_key *k,
2009         struct ieee80211_node *bss)
2010 {
2011 #define N(a)    (sizeof(a)/sizeof(a[0]))
2012         static const u_int8_t ciphermap[] = {
2013                 HAL_CIPHER_WEP,         /* IEEE80211_CIPHER_WEP */
2014                 HAL_CIPHER_TKIP,        /* IEEE80211_CIPHER_TKIP */
2015                 HAL_CIPHER_AES_OCB,     /* IEEE80211_CIPHER_AES_OCB */
2016                 HAL_CIPHER_AES_CCM,     /* IEEE80211_CIPHER_AES_CCM */
2017                 (u_int8_t) -1,          /* 4 is not allocated */
2018                 HAL_CIPHER_CKIP,        /* IEEE80211_CIPHER_CKIP */
2019                 HAL_CIPHER_CLR,         /* IEEE80211_CIPHER_NONE */
2020         };
2021         struct ath_hal *ah = sc->sc_ah;
2022         const struct ieee80211_cipher *cip = k->wk_cipher;
2023         u_int8_t gmac[IEEE80211_ADDR_LEN];
2024         const u_int8_t *mac;
2025         HAL_KEYVAL hk;
2026
2027         memset(&hk, 0, sizeof(hk));
2028         /*
2029          * Software crypto uses a "clear key" so non-crypto
2030          * state kept in the key cache are maintained and
2031          * so that rx frames have an entry to match.
2032          */
2033         if ((k->wk_flags & IEEE80211_KEY_SWCRYPT) == 0) {
2034                 KASSERT(cip->ic_cipher < N(ciphermap),
2035                         ("invalid cipher type %u", cip->ic_cipher));
2036                 hk.kv_type = ciphermap[cip->ic_cipher];
2037                 hk.kv_len = k->wk_keylen;
2038                 memcpy(hk.kv_val, k->wk_key, k->wk_keylen);
2039         } else
2040                 hk.kv_type = HAL_CIPHER_CLR;
2041
2042         if ((k->wk_flags & IEEE80211_KEY_GROUP) && sc->sc_mcastkey) {
2043                 /*
2044                  * Group keys on hardware that supports multicast frame
2045                  * key search use a MAC that is the sender's address with
2046                  * the high bit set instead of the app-specified address.
2047                  */
2048                 IEEE80211_ADDR_COPY(gmac, bss->ni_macaddr);
2049                 gmac[0] |= 0x80;
2050                 mac = gmac;
2051         } else
2052                 mac = k->wk_macaddr;
2053
2054         if (hk.kv_type == HAL_CIPHER_TKIP &&
2055             (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
2056                 return ath_keyset_tkip(sc, k, &hk, mac);
2057         } else {
2058                 KEYPRINTF(sc, k->wk_keyix, &hk, mac);
2059                 return ath_hal_keyset(ah, k->wk_keyix, &hk, mac);
2060         }
2061 #undef N
2062 }
2063
2064 /*
2065  * Allocate tx/rx key slots for TKIP.  We allocate two slots for
2066  * each key, one for decrypt/encrypt and the other for the MIC.
2067  */
2068 static u_int16_t
2069 key_alloc_2pair(struct ath_softc *sc,
2070         ieee80211_keyix *txkeyix, ieee80211_keyix *rxkeyix)
2071 {
2072 #define N(a)    (sizeof(a)/sizeof(a[0]))
2073         u_int i, keyix;
2074
2075         KASSERT(sc->sc_splitmic, ("key cache !split"));
2076         /* XXX could optimize */
2077         for (i = 0; i < N(sc->sc_keymap)/4; i++) {
2078                 u_int8_t b = sc->sc_keymap[i];
2079                 if (b != 0xff) {
2080                         /*
2081                          * One or more slots in this byte are free.
2082                          */
2083                         keyix = i*NBBY;
2084                         while (b & 1) {
2085                 again:
2086                                 keyix++;
2087                                 b >>= 1;
2088                         }
2089                         /* XXX IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV */
2090                         if (isset(sc->sc_keymap, keyix+32) ||
2091                             isset(sc->sc_keymap, keyix+64) ||
2092                             isset(sc->sc_keymap, keyix+32+64)) {
2093                                 /* full pair unavailable */
2094                                 /* XXX statistic */
2095                                 if (keyix == (i+1)*NBBY) {
2096                                         /* no slots were appropriate, advance */
2097                                         continue;
2098                                 }
2099                                 goto again;
2100                         }
2101                         setbit(sc->sc_keymap, keyix);
2102                         setbit(sc->sc_keymap, keyix+64);
2103                         setbit(sc->sc_keymap, keyix+32);
2104                         setbit(sc->sc_keymap, keyix+32+64);
2105                         DPRINTF(sc, ATH_DEBUG_KEYCACHE,
2106                                 "%s: key pair %u,%u %u,%u\n",
2107                                 __func__, keyix, keyix+64,
2108                                 keyix+32, keyix+32+64);
2109                         *txkeyix = keyix;
2110                         *rxkeyix = keyix+32;
2111                         return 1;
2112                 }
2113         }
2114         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of pair space\n", __func__);
2115         return 0;
2116 #undef N
2117 }
2118
2119 /*
2120  * Allocate tx/rx key slots for TKIP.  We allocate two slots for
2121  * each key, one for decrypt/encrypt and the other for the MIC.
2122  */
2123 static u_int16_t
2124 key_alloc_pair(struct ath_softc *sc,
2125         ieee80211_keyix *txkeyix, ieee80211_keyix *rxkeyix)
2126 {
2127 #define N(a)    (sizeof(a)/sizeof(a[0]))
2128         u_int i, keyix;
2129
2130         KASSERT(!sc->sc_splitmic, ("key cache split"));
2131         /* XXX could optimize */
2132         for (i = 0; i < N(sc->sc_keymap)/4; i++) {
2133                 u_int8_t b = sc->sc_keymap[i];
2134                 if (b != 0xff) {
2135                         /*
2136                          * One or more slots in this byte are free.
2137                          */
2138                         keyix = i*NBBY;
2139                         while (b & 1) {
2140                 again:
2141                                 keyix++;
2142                                 b >>= 1;
2143                         }
2144                         if (isset(sc->sc_keymap, keyix+64)) {
2145                                 /* full pair unavailable */
2146                                 /* XXX statistic */
2147                                 if (keyix == (i+1)*NBBY) {
2148                                         /* no slots were appropriate, advance */
2149                                         continue;
2150                                 }
2151                                 goto again;
2152                         }
2153                         setbit(sc->sc_keymap, keyix);
2154                         setbit(sc->sc_keymap, keyix+64);
2155                         DPRINTF(sc, ATH_DEBUG_KEYCACHE,
2156                                 "%s: key pair %u,%u\n",
2157                                 __func__, keyix, keyix+64);
2158                         *txkeyix = *rxkeyix = keyix;
2159                         return 1;
2160                 }
2161         }
2162         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of pair space\n", __func__);
2163         return 0;
2164 #undef N
2165 }
2166
2167 /*
2168  * Allocate a single key cache slot.
2169  */
2170 static int
2171 key_alloc_single(struct ath_softc *sc,
2172         ieee80211_keyix *txkeyix, ieee80211_keyix *rxkeyix)
2173 {
2174 #define N(a)    (sizeof(a)/sizeof(a[0]))
2175         u_int i, keyix;
2176
2177         /* XXX try i,i+32,i+64,i+32+64 to minimize key pair conflicts */
2178         for (i = 0; i < N(sc->sc_keymap); i++) {
2179                 u_int8_t b = sc->sc_keymap[i];
2180                 if (b != 0xff) {
2181                         /*
2182                          * One or more slots are free.
2183                          */
2184                         keyix = i*NBBY;
2185                         while (b & 1)
2186                                 keyix++, b >>= 1;
2187                         setbit(sc->sc_keymap, keyix);
2188                         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: key %u\n",
2189                                 __func__, keyix);
2190                         *txkeyix = *rxkeyix = keyix;
2191                         return 1;
2192                 }
2193         }
2194         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of space\n", __func__);
2195         return 0;
2196 #undef N
2197 }
2198
2199 /*
2200  * Allocate one or more key cache slots for a uniacst key.  The
2201  * key itself is needed only to identify the cipher.  For hardware
2202  * TKIP with split cipher+MIC keys we allocate two key cache slot
2203  * pairs so that we can setup separate TX and RX MIC keys.  Note
2204  * that the MIC key for a TKIP key at slot i is assumed by the
2205  * hardware to be at slot i+64.  This limits TKIP keys to the first
2206  * 64 entries.
2207  */
2208 static int
2209 ath_key_alloc(struct ieee80211vap *vap, struct ieee80211_key *k,
2210         ieee80211_keyix *keyix, ieee80211_keyix *rxkeyix)
2211 {
2212         struct ath_softc *sc = vap->iv_ic->ic_ifp->if_softc;
2213
2214         /*
2215          * Group key allocation must be handled specially for
2216          * parts that do not support multicast key cache search
2217          * functionality.  For those parts the key id must match
2218          * the h/w key index so lookups find the right key.  On
2219          * parts w/ the key search facility we install the sender's
2220          * mac address (with the high bit set) and let the hardware
2221          * find the key w/o using the key id.  This is preferred as
2222          * it permits us to support multiple users for adhoc and/or
2223          * multi-station operation.
2224          */
2225         if (k->wk_keyix != IEEE80211_KEYIX_NONE) {
2226                 /*
2227                  * Only global keys should have key index assigned.
2228                  */
2229                 if (!(&vap->iv_nw_keys[0] <= k &&
2230                       k < &vap->iv_nw_keys[IEEE80211_WEP_NKID])) {
2231                         /* should not happen */
2232                         DPRINTF(sc, ATH_DEBUG_KEYCACHE,
2233                                 "%s: bogus group key\n", __func__);
2234                         return 0;
2235                 }
2236                 if (vap->iv_opmode != IEEE80211_M_HOSTAP ||
2237                     !(k->wk_flags & IEEE80211_KEY_GROUP) ||
2238                     !sc->sc_mcastkey) {
2239                         /*
2240                          * XXX we pre-allocate the global keys so
2241                          * have no way to check if they've already
2242                          * been allocated.
2243                          */
2244                         *keyix = *rxkeyix = k - vap->iv_nw_keys;
2245                         return 1;
2246                 }
2247                 /*
2248                  * Group key and device supports multicast key search.
2249                  */
2250                 k->wk_keyix = IEEE80211_KEYIX_NONE;
2251         }
2252
2253         /*
2254          * We allocate two pair for TKIP when using the h/w to do
2255          * the MIC.  For everything else, including software crypto,
2256          * we allocate a single entry.  Note that s/w crypto requires
2257          * a pass-through slot on the 5211 and 5212.  The 5210 does
2258          * not support pass-through cache entries and we map all
2259          * those requests to slot 0.
2260          */
2261         if (k->wk_flags & IEEE80211_KEY_SWCRYPT) {
2262                 return key_alloc_single(sc, keyix, rxkeyix);
2263         } else if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP &&
2264             (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
2265                 if (sc->sc_splitmic)
2266                         return key_alloc_2pair(sc, keyix, rxkeyix);
2267                 else
2268                         return key_alloc_pair(sc, keyix, rxkeyix);
2269         } else {
2270                 return key_alloc_single(sc, keyix, rxkeyix);
2271         }
2272 }
2273
2274 /*
2275  * Delete an entry in the key cache allocated by ath_key_alloc.
2276  */
2277 static int
2278 ath_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k)
2279 {
2280         struct ath_softc *sc = vap->iv_ic->ic_ifp->if_softc;
2281         struct ath_hal *ah = sc->sc_ah;
2282         const struct ieee80211_cipher *cip = k->wk_cipher;
2283         u_int keyix = k->wk_keyix;
2284
2285         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: delete key %u\n", __func__, keyix);
2286
2287         ath_hal_keyreset(ah, keyix);
2288         /*
2289          * Handle split tx/rx keying required for TKIP with h/w MIC.
2290          */
2291         if (cip->ic_cipher == IEEE80211_CIPHER_TKIP &&
2292             (k->wk_flags & IEEE80211_KEY_SWMIC) == 0 && sc->sc_splitmic)
2293                 ath_hal_keyreset(ah, keyix+32);         /* RX key */
2294         if (keyix >= IEEE80211_WEP_NKID) {
2295                 /*
2296                  * Don't touch keymap entries for global keys so
2297                  * they are never considered for dynamic allocation.
2298                  */
2299                 clrbit(sc->sc_keymap, keyix);
2300                 if (cip->ic_cipher == IEEE80211_CIPHER_TKIP &&
2301                     (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
2302                         clrbit(sc->sc_keymap, keyix+64);        /* TX key MIC */
2303                         if (sc->sc_splitmic) {
2304                                 /* +32 for RX key, +32+64 for RX key MIC */
2305                                 clrbit(sc->sc_keymap, keyix+32);
2306                                 clrbit(sc->sc_keymap, keyix+32+64);
2307                         }
2308                 }
2309         }
2310         return 1;
2311 }
2312
2313 /*
2314  * Set the key cache contents for the specified key.  Key cache
2315  * slot(s) must already have been allocated by ath_key_alloc.
2316  */
2317 static int
2318 ath_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k,
2319         const u_int8_t mac[IEEE80211_ADDR_LEN])
2320 {
2321         struct ath_softc *sc = vap->iv_ic->ic_ifp->if_softc;
2322
2323         return ath_keyset(sc, k, vap->iv_bss);
2324 }
2325
2326 /*
2327  * Block/unblock tx+rx processing while a key change is done.
2328  * We assume the caller serializes key management operations
2329  * so we only need to worry about synchronization with other
2330  * uses that originate in the driver.
2331  */
2332 static void
2333 ath_key_update_begin(struct ieee80211vap *vap)
2334 {
2335         struct ifnet *ifp = vap->iv_ic->ic_ifp;
2336         struct ath_softc *sc = ifp->if_softc;
2337
2338         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s:\n", __func__);
2339         taskqueue_block(sc->sc_tq);
2340 }
2341
2342 static void
2343 ath_key_update_end(struct ieee80211vap *vap)
2344 {
2345         struct ifnet *ifp = vap->iv_ic->ic_ifp;
2346         struct ath_softc *sc = ifp->if_softc;
2347
2348         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s:\n", __func__);
2349         taskqueue_unblock(sc->sc_tq);
2350 }
2351
2352 /*
2353  * Calculate the receive filter according to the
2354  * operating mode and state:
2355  *
2356  * o always accept unicast, broadcast, and multicast traffic
2357  * o accept PHY error frames when hardware doesn't have MIB support
2358  *   to count and we need them for ANI (sta mode only until recently)
2359  *   and we are not scanning (ANI is disabled)
2360  *   NB: older hal's add rx filter bits out of sight and we need to
2361  *       blindly preserve them
2362  * o probe request frames are accepted only when operating in
2363  *   hostap, adhoc, mesh, or monitor modes
2364  * o enable promiscuous mode
2365  *   - when in monitor mode
2366  *   - if interface marked PROMISC (assumes bridge setting is filtered)
2367  * o accept beacons:
2368  *   - when operating in station mode for collecting rssi data when
2369  *     the station is otherwise quiet, or
2370  *   - when operating in adhoc mode so the 802.11 layer creates
2371  *     node table entries for peers,
2372  *   - when scanning
2373  *   - when doing s/w beacon miss (e.g. for ap+sta)
2374  *   - when operating in ap mode in 11g to detect overlapping bss that
2375  *     require protection
2376  *   - when operating in mesh mode to detect neighbors
2377  * o accept control frames:
2378  *   - when in monitor mode
2379  * XXX BAR frames for 11n
2380  * XXX HT protection for 11n
2381  */
2382 static u_int32_t
2383 ath_calcrxfilter(struct ath_softc *sc)
2384 {
2385         struct ifnet *ifp = sc->sc_ifp;
2386         struct ieee80211com *ic = ifp->if_l2com;
2387         u_int32_t rfilt;
2388
2389         rfilt = HAL_RX_FILTER_UCAST | HAL_RX_FILTER_BCAST | HAL_RX_FILTER_MCAST;
2390         if (!sc->sc_needmib && !sc->sc_scanning)
2391                 rfilt |= HAL_RX_FILTER_PHYERR;
2392         if (ic->ic_opmode != IEEE80211_M_STA)
2393                 rfilt |= HAL_RX_FILTER_PROBEREQ;
2394         /* XXX ic->ic_monvaps != 0? */
2395         if (ic->ic_opmode == IEEE80211_M_MONITOR || (ifp->if_flags & IFF_PROMISC))
2396                 rfilt |= HAL_RX_FILTER_PROM;
2397         if (ic->ic_opmode == IEEE80211_M_STA ||
2398             ic->ic_opmode == IEEE80211_M_IBSS ||
2399             sc->sc_swbmiss || sc->sc_scanning)
2400                 rfilt |= HAL_RX_FILTER_BEACON;
2401         /*
2402          * NB: We don't recalculate the rx filter when
2403          * ic_protmode changes; otherwise we could do
2404          * this only when ic_protmode != NONE.
2405          */
2406         if (ic->ic_opmode == IEEE80211_M_HOSTAP &&
2407             IEEE80211_IS_CHAN_ANYG(ic->ic_curchan))
2408                 rfilt |= HAL_RX_FILTER_BEACON;
2409         if (sc->sc_nmeshvaps) {
2410                 rfilt |= HAL_RX_FILTER_BEACON;
2411                 if (sc->sc_hasbmatch)
2412                         rfilt |= HAL_RX_FILTER_BSSID;
2413                 else
2414                         rfilt |= HAL_RX_FILTER_PROM;
2415         }
2416         if (ic->ic_opmode == IEEE80211_M_MONITOR)
2417                 rfilt |= HAL_RX_FILTER_CONTROL;
2418         DPRINTF(sc, ATH_DEBUG_MODE, "%s: RX filter 0x%x, %s if_flags 0x%x\n",
2419             __func__, rfilt, ieee80211_opmode_name[ic->ic_opmode], ifp->if_flags);
2420         return rfilt;
2421 }
2422
2423 static void
2424 ath_update_promisc(struct ifnet *ifp)
2425 {
2426         struct ath_softc *sc = ifp->if_softc;
2427         u_int32_t rfilt;
2428
2429         /* configure rx filter */
2430         rfilt = ath_calcrxfilter(sc);
2431         ath_hal_setrxfilter(sc->sc_ah, rfilt);
2432
2433         DPRINTF(sc, ATH_DEBUG_MODE, "%s: RX filter 0x%x\n", __func__, rfilt);
2434 }
2435
2436 static void
2437 ath_update_mcast(struct ifnet *ifp)
2438 {
2439         struct ath_softc *sc = ifp->if_softc;
2440         u_int32_t mfilt[2];
2441
2442         /* calculate and install multicast filter */
2443         if ((ifp->if_flags & IFF_ALLMULTI) == 0) {
2444                 struct ifmultiaddr *ifma;
2445                 /*
2446                  * Merge multicast addresses to form the hardware filter.
2447                  */
2448                 mfilt[0] = mfilt[1] = 0;
2449 #ifdef __FreeBSD__
2450                 if_maddr_rlock(ifp);    /* XXX need some fiddling to remove? */
2451 #endif
2452                 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
2453                         caddr_t dl;
2454                         u_int32_t val;
2455                         u_int8_t pos;
2456
2457                         /* calculate XOR of eight 6bit values */
2458                         dl = LLADDR((struct sockaddr_dl *) ifma->ifma_addr);
2459                         val = LE_READ_4(dl + 0);
2460                         pos = (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
2461                         val = LE_READ_4(dl + 3);
2462                         pos ^= (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
2463                         pos &= 0x3f;
2464                         mfilt[pos / 32] |= (1 << (pos % 32));
2465                 }
2466 #ifdef __FreeBSD__
2467                 if_maddr_runlock(ifp);
2468 #endif
2469         } else
2470                 mfilt[0] = mfilt[1] = ~0;
2471         ath_hal_setmcastfilter(sc->sc_ah, mfilt[0], mfilt[1]);
2472         DPRINTF(sc, ATH_DEBUG_MODE, "%s: MC filter %08x:%08x\n",
2473                 __func__, mfilt[0], mfilt[1]);
2474 }
2475
2476 static void
2477 ath_mode_init(struct ath_softc *sc)
2478 {
2479         struct ifnet *ifp = sc->sc_ifp;
2480         struct ath_hal *ah = sc->sc_ah;
2481         u_int32_t rfilt;
2482
2483         /* configure rx filter */
2484         rfilt = ath_calcrxfilter(sc);
2485         ath_hal_setrxfilter(ah, rfilt);
2486
2487         /* configure operational mode */
2488         ath_hal_setopmode(ah);
2489
2490         /* handle any link-level address change */
2491         ath_hal_setmac(ah, IF_LLADDR(ifp));
2492
2493         /* calculate and install multicast filter */
2494         ath_update_mcast(ifp);
2495 }
2496
2497 /*
2498  * Set the slot time based on the current setting.
2499  */
2500 static void
2501 ath_setslottime(struct ath_softc *sc)
2502 {
2503         struct ieee80211com *ic = sc->sc_ifp->if_l2com;
2504         struct ath_hal *ah = sc->sc_ah;
2505         u_int usec;
2506
2507         if (IEEE80211_IS_CHAN_HALF(ic->ic_curchan))
2508                 usec = 13;
2509         else if (IEEE80211_IS_CHAN_QUARTER(ic->ic_curchan))
2510                 usec = 21;
2511         else if (IEEE80211_IS_CHAN_ANYG(ic->ic_curchan)) {
2512                 /* honor short/long slot time only in 11g */
2513                 /* XXX shouldn't honor on pure g or turbo g channel */
2514                 if (ic->ic_flags & IEEE80211_F_SHSLOT)
2515                         usec = HAL_SLOT_TIME_9;
2516                 else
2517                         usec = HAL_SLOT_TIME_20;
2518         } else
2519                 usec = HAL_SLOT_TIME_9;
2520
2521         DPRINTF(sc, ATH_DEBUG_RESET,
2522             "%s: chan %u MHz flags 0x%x %s slot, %u usec\n",
2523             __func__, ic->ic_curchan->ic_freq, ic->ic_curchan->ic_flags,
2524             ic->ic_flags & IEEE80211_F_SHSLOT ? "short" : "long", usec);
2525
2526         ath_hal_setslottime(ah, usec);
2527         sc->sc_updateslot = OK;
2528 }
2529
2530 /*
2531  * Callback from the 802.11 layer to update the
2532  * slot time based on the current setting.
2533  */
2534 static void
2535 ath_updateslot(struct ifnet *ifp)
2536 {
2537         struct ath_softc *sc = ifp->if_softc;
2538         struct ieee80211com *ic = ifp->if_l2com;
2539
2540         /*
2541          * When not coordinating the BSS, change the hardware
2542          * immediately.  For other operation we defer the change
2543          * until beacon updates have propagated to the stations.
2544          */
2545         if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
2546             ic->ic_opmode == IEEE80211_M_MBSS)
2547                 sc->sc_updateslot = UPDATE;
2548         else
2549                 ath_setslottime(sc);
2550 }
2551
2552 /*
2553  * Setup a h/w transmit queue for beacons.
2554  */
2555 static int
2556 ath_beaconq_setup(struct ath_hal *ah)
2557 {
2558         HAL_TXQ_INFO qi;
2559
2560         memset(&qi, 0, sizeof(qi));
2561         qi.tqi_aifs = HAL_TXQ_USEDEFAULT;
2562         qi.tqi_cwmin = HAL_TXQ_USEDEFAULT;
2563         qi.tqi_cwmax = HAL_TXQ_USEDEFAULT;
2564         /* NB: for dynamic turbo, don't enable any other interrupts */
2565         qi.tqi_qflags = HAL_TXQ_TXDESCINT_ENABLE;
2566         return ath_hal_setuptxqueue(ah, HAL_TX_QUEUE_BEACON, &qi);
2567 }
2568
2569 /*
2570  * Setup the transmit queue parameters for the beacon queue.
2571  */
2572 static int
2573 ath_beaconq_config(struct ath_softc *sc)
2574 {
2575 #define ATH_EXPONENT_TO_VALUE(v)        ((1<<(v))-1)
2576         struct ieee80211com *ic = sc->sc_ifp->if_l2com;
2577         struct ath_hal *ah = sc->sc_ah;
2578         HAL_TXQ_INFO qi;
2579
2580         ath_hal_gettxqueueprops(ah, sc->sc_bhalq, &qi);
2581         if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
2582             ic->ic_opmode == IEEE80211_M_MBSS) {
2583                 /*
2584                  * Always burst out beacon and CAB traffic.
2585                  */
2586                 qi.tqi_aifs = ATH_BEACON_AIFS_DEFAULT;
2587                 qi.tqi_cwmin = ATH_BEACON_CWMIN_DEFAULT;
2588                 qi.tqi_cwmax = ATH_BEACON_CWMAX_DEFAULT;
2589         } else {
2590                 struct wmeParams *wmep =
2591                         &ic->ic_wme.wme_chanParams.cap_wmeParams[WME_AC_BE];
2592                 /*
2593                  * Adhoc mode; important thing is to use 2x cwmin.
2594                  */
2595                 qi.tqi_aifs = wmep->wmep_aifsn;
2596                 qi.tqi_cwmin = 2*ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmin);
2597                 qi.tqi_cwmax = ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmax);
2598         }
2599
2600         if (!ath_hal_settxqueueprops(ah, sc->sc_bhalq, &qi)) {
2601                 device_printf(sc->sc_dev, "unable to update parameters for "
2602                         "beacon hardware queue!\n");
2603                 return 0;
2604         } else {
2605                 ath_hal_resettxqueue(ah, sc->sc_bhalq); /* push to h/w */
2606                 return 1;
2607         }
2608 #undef ATH_EXPONENT_TO_VALUE
2609 }
2610
2611 /*
2612  * Allocate and setup an initial beacon frame.
2613  */
2614 static int
2615 ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_node *ni)
2616 {
2617         struct ieee80211vap *vap = ni->ni_vap;
2618         struct ath_vap *avp = ATH_VAP(vap);
2619         struct ath_buf *bf;
2620         struct mbuf *m;
2621         int error;
2622
2623         bf = avp->av_bcbuf;
2624         if (bf->bf_m != NULL) {
2625                 bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap);
2626                 m_freem(bf->bf_m);
2627                 bf->bf_m = NULL;
2628         }
2629         if (bf->bf_node != NULL) {
2630                 ieee80211_free_node(bf->bf_node);
2631                 bf->bf_node = NULL;
2632         }
2633
2634         /*
2635          * NB: the beacon data buffer must be 32-bit aligned;
2636          * we assume the mbuf routines will return us something
2637          * with this alignment (perhaps should assert).
2638          */
2639         m = ieee80211_beacon_alloc(ni, &avp->av_boff);
2640         if (m == NULL) {
2641                 device_printf(sc->sc_dev, "%s: cannot get mbuf\n", __func__);
2642                 sc->sc_stats.ast_be_nombuf++;
2643                 return ENOMEM;
2644         }
2645         error = bus_dmamap_load_mbuf_segment(sc->sc_dmat, bf->bf_dmamap, m,
2646                                      bf->bf_segs, 1, &bf->bf_nseg,
2647                                      BUS_DMA_NOWAIT);
2648         if (error != 0) {
2649                 device_printf(sc->sc_dev,
2650                     "%s: cannot map mbuf, bus_dmamap_load_mbuf_segment returns %d\n",
2651                     __func__, error);
2652                 m_freem(m);
2653                 return error;
2654         }
2655
2656         /*
2657          * Calculate a TSF adjustment factor required for staggered
2658          * beacons.  Note that we assume the format of the beacon
2659          * frame leaves the tstamp field immediately following the
2660          * header.
2661          */
2662         if (sc->sc_stagbeacons && avp->av_bslot > 0) {
2663                 uint64_t tsfadjust;
2664                 struct ieee80211_frame *wh;
2665
2666                 /*
2667                  * The beacon interval is in TU's; the TSF is in usecs.
2668                  * We figure out how many TU's to add to align the timestamp
2669                  * then convert to TSF units and handle byte swapping before
2670                  * inserting it in the frame.  The hardware will then add this
2671                  * each time a beacon frame is sent.  Note that we align vap's
2672                  * 1..N and leave vap 0 untouched.  This means vap 0 has a
2673                  * timestamp in one beacon interval while the others get a
2674                  * timstamp aligned to the next interval.
2675                  */
2676                 tsfadjust = ni->ni_intval *
2677                     (ATH_BCBUF - avp->av_bslot) / ATH_BCBUF;
2678                 tsfadjust = htole64(tsfadjust << 10);   /* TU -> TSF */
2679
2680                 DPRINTF(sc, ATH_DEBUG_BEACON,
2681                     "%s: %s beacons bslot %d intval %u tsfadjust %llu\n",
2682                     __func__, sc->sc_stagbeacons ? "stagger" : "burst",
2683                     avp->av_bslot, ni->ni_intval,
2684                     (long long unsigned) le64toh(tsfadjust));
2685
2686                 wh = mtod(m, struct ieee80211_frame *);
2687                 memcpy(&wh[1], &tsfadjust, sizeof(tsfadjust));
2688         }
2689         bf->bf_m = m;
2690         bf->bf_node = ieee80211_ref_node(ni);
2691
2692         return 0;
2693 }
2694
2695 /*
2696  * Setup the beacon frame for transmit.
2697  */
2698 static void
2699 ath_beacon_setup(struct ath_softc *sc, struct ath_buf *bf)
2700 {
2701 #define USE_SHPREAMBLE(_ic) \
2702         (((_ic)->ic_flags & (IEEE80211_F_SHPREAMBLE | IEEE80211_F_USEBARKER))\
2703                 == IEEE80211_F_SHPREAMBLE)
2704         struct ieee80211_node *ni = bf->bf_node;
2705         struct ieee80211com *ic = ni->ni_ic;
2706         struct mbuf *m = bf->bf_m;
2707         struct ath_hal *ah = sc->sc_ah;
2708         struct ath_desc *ds;
2709         int flags, antenna;
2710         const HAL_RATE_TABLE *rt;
2711         u_int8_t rix, rate;
2712
2713         DPRINTF(sc, ATH_DEBUG_BEACON_PROC, "%s: m %p len %u\n",
2714                 __func__, m, m->m_len);
2715
2716         /* setup descriptors */
2717         ds = bf->bf_desc;
2718
2719         flags = HAL_TXDESC_NOACK;
2720         if (ic->ic_opmode == IEEE80211_M_IBSS && sc->sc_hasveol) {
2721                 ds->ds_link = bf->bf_daddr;     /* self-linked */
2722                 flags |= HAL_TXDESC_VEOL;
2723                 /*
2724                  * Let hardware handle antenna switching.
2725                  */
2726                 antenna = sc->sc_txantenna;
2727         } else {
2728                 ds->ds_link = 0;
2729                 /*
2730                  * Switch antenna every 4 beacons.
2731                  * XXX assumes two antenna
2732                  */
2733                 if (sc->sc_txantenna != 0)
2734                         antenna = sc->sc_txantenna;
2735                 else if (sc->sc_stagbeacons && sc->sc_nbcnvaps != 0)
2736                         antenna = ((sc->sc_stats.ast_be_xmit / sc->sc_nbcnvaps) & 4 ? 2 : 1);
2737                 else
2738                         antenna = (sc->sc_stats.ast_be_xmit & 4 ? 2 : 1);
2739         }
2740
2741         KASSERT(bf->bf_nseg == 1,
2742                 ("multi-segment beacon frame; nseg %u", bf->bf_nseg));
2743         ds->ds_data = bf->bf_segs[0].ds_addr;
2744         /*
2745          * Calculate rate code.
2746          * XXX everything at min xmit rate
2747          */
2748         rix = 0;
2749         rt = sc->sc_currates;
2750         rate = rt->info[rix].rateCode;
2751         if (USE_SHPREAMBLE(ic))
2752                 rate |= rt->info[rix].shortPreamble;
2753         ath_hal_setuptxdesc(ah, ds
2754                 , m->m_len + IEEE80211_CRC_LEN  /* frame length */
2755                 , sizeof(struct ieee80211_frame)/* header length */
2756                 , HAL_PKT_TYPE_BEACON           /* Atheros packet type */
2757                 , ni->ni_txpower                /* txpower XXX */
2758                 , rate, 1                       /* series 0 rate/tries */
2759                 , HAL_TXKEYIX_INVALID           /* no encryption */
2760                 , antenna                       /* antenna mode */
2761                 , flags                         /* no ack, veol for beacons */
2762                 , 0                             /* rts/cts rate */
2763                 , 0                             /* rts/cts duration */
2764         );
2765         /* NB: beacon's BufLen must be a multiple of 4 bytes */
2766         ath_hal_filltxdesc(ah, ds
2767                 , roundup(m->m_len, 4)          /* buffer length */
2768                 , AH_TRUE                       /* first segment */
2769                 , AH_TRUE                       /* last segment */
2770                 , ds                            /* first descriptor */
2771         );
2772 #if 0
2773         ath_desc_swap(ds);
2774 #endif
2775 #undef USE_SHPREAMBLE
2776 }
2777
2778 static void
2779 ath_beacon_update(struct ieee80211vap *vap, int item)
2780 {
2781         struct ieee80211_beacon_offsets *bo = &ATH_VAP(vap)->av_boff;
2782
2783         setbit(bo->bo_flags, item);
2784 }
2785
2786 /*
2787  * Append the contents of src to dst; both queues
2788  * are assumed to be locked.
2789  */
2790 static void
2791 ath_txqmove(struct ath_txq *dst, struct ath_txq *src)
2792 {
2793         STAILQ_CONCAT(&dst->axq_q, &src->axq_q);
2794         if (src->axq_depth)
2795                 dst->axq_link = src->axq_link;
2796         src->axq_link = NULL;
2797         dst->axq_depth += src->axq_depth;
2798         src->axq_depth = 0;
2799 }
2800
2801 /*
2802  * Transmit a beacon frame at SWBA.  Dynamic updates to the
2803  * frame contents are done as needed and the slot time is
2804  * also adjusted based on current state.
2805  */
2806 static void
2807 ath_beacon_proc(void *arg, int pending)
2808 {
2809         struct ath_softc *sc = arg;
2810         struct ath_hal *ah = sc->sc_ah;
2811         struct ieee80211vap *vap;
2812         struct ath_buf *bf;
2813         int slot, otherant;
2814         uint32_t bfaddr;
2815
2816         DPRINTF(sc, ATH_DEBUG_BEACON_PROC, "%s: pending %u\n",
2817                 __func__, pending);
2818         /*
2819          * Check if the previous beacon has gone out.  If
2820          * not don't try to post another, skip this period
2821          * and wait for the next.  Missed beacons indicate
2822          * a problem and should not occur.  If we miss too
2823          * many consecutive beacons reset the device.
2824          */
2825         if (ath_hal_numtxpending(ah, sc->sc_bhalq) != 0) {
2826                 sc->sc_bmisscount++;
2827                 DPRINTF(sc, ATH_DEBUG_BEACON,
2828                         "%s: missed %u consecutive beacons\n",
2829                         __func__, sc->sc_bmisscount);
2830                 if (sc->sc_bmisscount >= ath_bstuck_threshold)
2831                         taskqueue_enqueue(sc->sc_tq, &sc->sc_bstucktask);
2832                 return;
2833         }
2834         if (sc->sc_bmisscount != 0) {
2835                 DPRINTF(sc, ATH_DEBUG_BEACON,
2836                         "%s: resume beacon xmit after %u misses\n",
2837                         __func__, sc->sc_bmisscount);
2838                 sc->sc_bmisscount = 0;
2839         }
2840
2841         /*
2842          * Stop any current dma before messing with the beacon linkages.
2843          */
2844         if (!ath_hal_stoptxdma(ah, sc->sc_bhalq)) {
2845                 DPRINTF(sc, ATH_DEBUG_ANY,
2846                         "%s: beacon queue %u did not stop?\n",
2847                         __func__, sc->sc_bhalq);
2848         }
2849
2850         if (sc->sc_stagbeacons) {                       /* staggered beacons */
2851                 struct ieee80211com *ic = sc->sc_ifp->if_l2com;
2852                 uint32_t tsftu;
2853
2854                 tsftu = ath_hal_gettsf32(ah) >> 10;
2855                 /* XXX lintval */
2856                 slot = ((tsftu % ic->ic_lintval) * ATH_BCBUF) / ic->ic_lintval;
2857                 vap = sc->sc_bslot[(slot+1) % ATH_BCBUF];
2858                 bfaddr = 0;
2859                 if (vap != NULL && vap->iv_state >= IEEE80211_S_RUN) {
2860                         bf = ath_beacon_generate(sc, vap);
2861                         if (bf != NULL)
2862                                 bfaddr = bf->bf_daddr;
2863                 }
2864         } else {                                        /* burst'd beacons */
2865                 uint32_t *bflink = &bfaddr;
2866
2867                 for (slot = 0; slot < ATH_BCBUF; slot++) {
2868                         vap = sc->sc_bslot[slot];
2869                         if (vap != NULL && vap->iv_state >= IEEE80211_S_RUN) {
2870                                 bf = ath_beacon_generate(sc, vap);
2871                                 if (bf != NULL) {
2872                                         *bflink = bf->bf_daddr;
2873                                         bflink = &bf->bf_desc->ds_link;
2874                                 }
2875                         }
2876                 }
2877                 *bflink = 0;                            /* terminate list */
2878         }
2879
2880         /*
2881          * Handle slot time change when a non-ERP station joins/leaves
2882          * an 11g network.  The 802.11 layer notifies us via callback,
2883          * we mark updateslot, then wait one beacon before effecting
2884          * the change.  This gives associated stations at least one
2885          * beacon interval to note the state change.
2886          */
2887         /* XXX locking */
2888         if (sc->sc_updateslot == UPDATE) {
2889                 sc->sc_updateslot = COMMIT;     /* commit next beacon */
2890                 sc->sc_slotupdate = slot;
2891         } else if (sc->sc_updateslot == COMMIT && sc->sc_slotupdate == slot)
2892                 ath_setslottime(sc);            /* commit change to h/w */
2893
2894         /*
2895          * Check recent per-antenna transmit statistics and flip
2896          * the default antenna if noticeably more frames went out
2897          * on the non-default antenna.
2898          * XXX assumes 2 anntenae
2899          */
2900         if (!sc->sc_diversity && (!sc->sc_stagbeacons || slot == 0)) {
2901                 otherant = sc->sc_defant & 1 ? 2 : 1;
2902                 if (sc->sc_ant_tx[otherant] > sc->sc_ant_tx[sc->sc_defant] + 2)
2903                         ath_setdefantenna(sc, otherant);
2904                 sc->sc_ant_tx[1] = sc->sc_ant_tx[2] = 0;
2905         }
2906
2907         if (bfaddr != 0) {
2908                 /* NB: cabq traffic should already be queued and primed */
2909                 ath_hal_puttxbuf(ah, sc->sc_bhalq, bfaddr);
2910                 sc->sc_stats.ast_be_xmit++;
2911                 ath_hal_txstart(ah, sc->sc_bhalq);
2912         }
2913         /* else no beacon will be generated */
2914 }
2915
2916 static struct ath_buf *
2917 ath_beacon_generate(struct ath_softc *sc, struct ieee80211vap *vap)
2918 {
2919         struct ath_vap *avp = ATH_VAP(vap);
2920         struct ath_txq *cabq = sc->sc_cabq;
2921         struct ath_buf *bf;
2922         struct mbuf *m;
2923         int nmcastq, error;
2924
2925         KASSERT(vap->iv_state >= IEEE80211_S_RUN,
2926             ("not running, state %d", vap->iv_state));
2927         KASSERT(avp->av_bcbuf != NULL, ("no beacon buffer"));
2928
2929         /*
2930          * Update dynamic beacon contents.  If this returns
2931          * non-zero then we need to remap the memory because
2932          * the beacon frame changed size (probably because
2933          * of the TIM bitmap).
2934          */
2935         bf = avp->av_bcbuf;
2936         m = bf->bf_m;
2937         nmcastq = avp->av_mcastq.axq_depth;
2938         if (ieee80211_beacon_update(bf->bf_node, &avp->av_boff, m, nmcastq)) {
2939                 /* XXX too conservative? */
2940                 bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap);
2941                 error = bus_dmamap_load_mbuf_segment(sc->sc_dmat, bf->bf_dmamap, m,
2942                                              bf->bf_segs, 1, &bf->bf_nseg,
2943                                              BUS_DMA_NOWAIT);
2944                 if (error != 0) {
2945                         if_printf(vap->iv_ifp,
2946                             "%s: bus_dmamap_load_mbuf_segment failed, error %u\n",
2947                             __func__, error);
2948                         return NULL;
2949                 }
2950         }
2951         if ((avp->av_boff.bo_tim[4] & 1) && cabq->axq_depth) {
2952                 DPRINTF(sc, ATH_DEBUG_BEACON,
2953                     "%s: cabq did not drain, mcastq %u cabq %u\n",
2954                     __func__, nmcastq, cabq->axq_depth);
2955                 sc->sc_stats.ast_cabq_busy++;
2956                 if (sc->sc_nvaps > 1 && sc->sc_stagbeacons) {
2957                         /*
2958                          * CABQ traffic from a previous vap is still pending.
2959                          * We must drain the q before this beacon frame goes
2960                          * out as otherwise this vap's stations will get cab
2961                          * frames from a different vap.
2962                          * XXX could be slow causing us to miss DBA
2963                          */
2964                         ath_tx_draintxq(sc, cabq);
2965                 }
2966         }
2967         ath_beacon_setup(sc, bf);
2968         bus_dmamap_sync(sc->sc_dmat, bf->bf_dmamap, BUS_DMASYNC_PREWRITE);
2969
2970         /*
2971          * Enable the CAB queue before the beacon queue to
2972          * insure cab frames are triggered by this beacon.
2973          */
2974         if (avp->av_boff.bo_tim[4] & 1) {
2975                 struct ath_hal *ah = sc->sc_ah;
2976
2977                 /* NB: only at DTIM */
2978                 if (nmcastq) {
2979                         struct ath_buf *bfm;
2980                         int qbusy;
2981
2982                         /*
2983                          * Move frames from the s/w mcast q to the h/w cab q.
2984                          * XXX MORE_DATA bit
2985                          */
2986                         bfm = STAILQ_FIRST(&avp->av_mcastq.axq_q);
2987                         qbusy = ath_hal_txqenabled(ah, cabq->axq_qnum);
2988                         if (qbusy == 0) {
2989                                 if (cabq->axq_link != NULL) {
2990                                         cpu_sfence();
2991                                         *cabq->axq_link = bfm->bf_daddr;
2992                                         cabq->axq_flags |= ATH_TXQ_PUTPENDING;
2993                                 } else {
2994                                         cpu_sfence();
2995                                         ath_hal_puttxbuf(ah, cabq->axq_qnum,
2996                                                 bfm->bf_daddr);
2997                                 }
2998                         } else {
2999                                 if (cabq->axq_link != NULL) {
3000                                         cpu_sfence();
3001                                         *cabq->axq_link = bfm->bf_daddr;
3002                                 }
3003                                 cabq->axq_flags |= ATH_TXQ_PUTPENDING;
3004                         }
3005                         ath_txqmove(cabq, &avp->av_mcastq);
3006
3007                         sc->sc_stats.ast_cabq_xmit += nmcastq;
3008                 }
3009                 /* NB: gated by beacon so safe to start here */
3010                 ath_hal_txstart(ah, cabq->axq_qnum);
3011         }
3012         return bf;
3013 }
3014
3015 static void
3016 ath_beacon_start_adhoc(struct ath_softc *sc, struct ieee80211vap *vap)
3017 {
3018         struct ath_vap *avp = ATH_VAP(vap);
3019         struct ath_hal *ah = sc->sc_ah;
3020         struct ath_buf *bf;
3021         struct mbuf *m;
3022         int error;
3023
3024         KASSERT(avp->av_bcbuf != NULL, ("no beacon buffer"));
3025
3026         /*
3027          * Update dynamic beacon contents.  If this returns
3028          * non-zero then we need to remap the memory because
3029          * the beacon frame changed size (probably because
3030          * of the TIM bitmap).
3031          */
3032         bf = avp->av_bcbuf;
3033         m = bf->bf_m;
3034         if (ieee80211_beacon_update(bf->bf_node, &avp->av_boff, m, 0)) {
3035                 /* XXX too conservative? */
3036                 bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap);
3037                 error = bus_dmamap_load_mbuf_segment(sc->sc_dmat, bf->bf_dmamap, m,
3038                                              bf->bf_segs, 1, &bf->bf_nseg,
3039                                              BUS_DMA_NOWAIT);
3040                 if (error != 0) {
3041                         if_printf(vap->iv_ifp,
3042                             "%s: bus_dmamap_load_mbuf_segment failed, error %u\n",
3043                             __func__, error);
3044                         return;
3045                 }
3046         }
3047         ath_beacon_setup(sc, bf);
3048         bus_dmamap_sync(sc->sc_dmat, bf->bf_dmamap, BUS_DMASYNC_PREWRITE);
3049
3050         /* NB: caller is known to have already stopped tx dma */
3051         ath_hal_puttxbuf(ah, sc->sc_bhalq, bf->bf_daddr);
3052         ath_hal_txstart(ah, sc->sc_bhalq);
3053 }
3054
3055 /*
3056  * Reset the hardware after detecting beacons have stopped.
3057  */
3058 static void
3059 ath_bstuck_task(void *arg, int pending)
3060 {
3061         struct ath_softc *sc = arg;
3062         struct ifnet *ifp = sc->sc_ifp;
3063
3064         wlan_serialize_enter();
3065         if_printf(ifp, "stuck beacon; resetting (bmiss count %u)\n",
3066                   sc->sc_bmisscount);
3067         sc->sc_stats.ast_bstuck++;
3068         ath_reset(ifp);
3069         wlan_serialize_exit();
3070 }
3071
3072 /*
3073  * Reclaim beacon resources and return buffer to the pool.
3074  */
3075 static void
3076 ath_beacon_return(struct ath_softc *sc, struct ath_buf *bf)
3077 {
3078
3079         if (bf->bf_m != NULL) {
3080                 bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap);
3081                 m_freem(bf->bf_m);
3082                 bf->bf_m = NULL;
3083         }
3084         if (bf->bf_node != NULL) {
3085                 ieee80211_free_node(bf->bf_node);
3086                 bf->bf_node = NULL;
3087         }
3088         STAILQ_INSERT_TAIL(&sc->sc_bbuf, bf, bf_list);
3089 }
3090
3091 /*
3092  * Reclaim beacon resources.
3093  */
3094 static void
3095 ath_beacon_free(struct ath_softc *sc)
3096 {
3097         struct ath_buf *bf;
3098
3099         STAILQ_FOREACH(bf, &sc->sc_bbuf, bf_list) {
3100                 if (bf->bf_m != NULL) {
3101                         bus_dmamap_unload(sc->sc_dmat, bf->bf_dmamap);
3102                         m_freem(bf->bf_m);
3103                         bf->bf_m = NULL;
3104                 }
3105                 if (bf->bf_node != NULL) {
3106                         ieee80211_free_node(bf->bf_node);
3107                         bf->bf_node = NULL;
3108                 }
3109         }
3110 }
3111
3112 /*
3113  * Configure the beacon and sleep timers.
3114  *
3115  * When operating as an AP this resets the TSF and sets
3116  * up the hardware to notify us when we need to issue beacons.
3117  *
3118  * When operating in station mode this sets up the beacon
3119  * timers according to the timestamp of the last received
3120  * beacon and the current TSF, configures PCF and DTIM
3121  * handling, programs the sleep registers so the hardware
3122  * will wakeup in time to receive beacons, and configures
3123  * the beacon miss handling so we'll receive a BMISS
3124  * interrupt when we stop seeing beacons from the AP
3125  * we've associated with.
3126  */
3127 static void
3128 ath_beacon_config(struct ath_softc *sc, struct ieee80211vap *vap)
3129 {
3130 #define TSF_TO_TU(_h,_l) \
3131         ((((u_int32_t)(_h)) << 22) | (((u_int32_t)(_l)) >> 10))
3132 #define FUDGE   2
3133         struct ath_hal *ah = sc->sc_ah;
3134         struct ieee80211com *ic = sc->sc_ifp->if_l2com;
3135         struct ieee80211_node *ni;
3136         u_int32_t nexttbtt, intval, tsftu;
3137         u_int64_t tsf;
3138
3139         if (vap == NULL)
3140                 vap = TAILQ_FIRST(&ic->ic_vaps);        /* XXX */
3141         ni = vap->iv_bss;
3142
3143         /* extract tstamp from last beacon and convert to TU */
3144         nexttbtt = TSF_TO_TU(LE_READ_4(ni->ni_tstamp.data + 4),
3145                              LE_READ_4(ni->ni_tstamp.data));
3146         if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
3147             ic->ic_opmode == IEEE80211_M_MBSS) {
3148                 /*
3149                  * For multi-bss ap/mesh support beacons are either staggered
3150                  * evenly over N slots or burst together.  For the former
3151                  * arrange for the SWBA to be delivered for each slot.
3152                  * Slots that are not occupied will generate nothing.
3153                  */
3154                 /* NB: the beacon interval is kept internally in TU's */
3155                 intval = ni->ni_intval & HAL_BEACON_PERIOD;
3156                 if (sc->sc_stagbeacons)
3157                         intval /= ATH_BCBUF;
3158         } else {
3159                 /* NB: the beacon interval is kept internally in TU's */
3160                 intval = ni->ni_intval & HAL_BEACON_PERIOD;
3161         }
3162         if (nexttbtt == 0)              /* e.g. for ap mode */
3163                 nexttbtt = intval;
3164         else if (intval)                /* NB: can be 0 for monitor mode */
3165                 nexttbtt = roundup(nexttbtt, intval);
3166         DPRINTF(sc, ATH_DEBUG_BEACON, "%s: nexttbtt %u intval %u (%u)\n",
3167                 __func__, nexttbtt, intval, ni->ni_intval);
3168         if (ic->ic_opmode == IEEE80211_M_STA && !sc->sc_swbmiss) {
3169                 HAL_BEACON_STATE bs;
3170                 int dtimperiod, dtimcount;
3171                 int cfpperiod, cfpcount;
3172
3173                 /*
3174                  * Setup dtim and cfp parameters according to
3175                  * last beacon we received (which may be none).
3176                  */
3177                 dtimperiod = ni->ni_dtim_period;
3178                 if (dtimperiod <= 0)            /* NB: 0 if not known */
3179                         dtimperiod = 1;
3180                 dtimcount = ni->ni_dtim_count;
3181                 if (dtimcount >= dtimperiod)    /* NB: sanity check */
3182                         dtimcount = 0;          /* XXX? */
3183                 cfpperiod = 1;                  /* NB: no PCF support yet */
3184                 cfpcount = 0;
3185                 /*
3186                  * Pull nexttbtt forward to reflect the current
3187                  * TSF and calculate dtim+cfp state for the result.
3188                  */
3189                 tsf = ath_hal_gettsf64(ah);
3190                 tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE;
3191                 do {
3192                         nexttbtt += intval;
3193                         if (--dtimcount < 0) {
3194                                 dtimcount = dtimperiod - 1;
3195                                 if (--cfpcount < 0)
3196                                         cfpcount = cfpperiod - 1;
3197                         }
3198                 } while (nexttbtt < tsftu);
3199                 memset(&bs, 0, sizeof(bs));
3200                 bs.bs_intval = intval;
3201                 bs.bs_nexttbtt = nexttbtt;
3202                 bs.bs_dtimperiod = dtimperiod*intval;
3203                 bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount*intval;
3204                 bs.bs_cfpperiod = cfpperiod*bs.bs_dtimperiod;
3205                 bs.bs_cfpnext = bs.bs_nextdtim + cfpcount*bs.bs_dtimperiod;
3206                 bs.bs_cfpmaxduration = 0;
3207 #if 0
3208                 /*
3209                  * The 802.11 layer records the offset to the DTIM
3210                  * bitmap while receiving beacons; use it here to
3211                  * enable h/w detection of our AID being marked in
3212                  * the bitmap vector (to indicate frames for us are
3213                  * pending at the AP).
3214                  * XXX do DTIM handling in s/w to WAR old h/w bugs
3215                  * XXX enable based on h/w rev for newer chips
3216                  */
3217                 bs.bs_timoffset = ni->ni_timoff;
3218 #endif
3219                 /*
3220                  * Calculate the number of consecutive beacons to miss
3221                  * before taking a BMISS interrupt.
3222                  * Note that we clamp the result to at most 10 beacons.
3223                  */
3224                 bs.bs_bmissthreshold = vap->iv_bmissthreshold;
3225                 if (bs.bs_bmissthreshold > 10)
3226                         bs.bs_bmissthreshold = 10;
3227                 else if (bs.bs_bmissthreshold <= 0)
3228                         bs.bs_bmissthreshold = 1;
3229
3230                 /*
3231                  * Calculate sleep duration.  The configuration is
3232                  * given in ms.  We insure a multiple of the beacon
3233                  * period is used.  Also, if the sleep duration is
3234                  * greater than the DTIM period then it makes senses
3235                  * to make it a multiple of that.
3236                  *
3237                  * XXX fixed at 100ms
3238                  */
3239                 bs.bs_sleepduration =
3240                         roundup(IEEE80211_MS_TO_TU(100), bs.bs_intval);
3241                 if (bs.bs_sleepduration > bs.bs_dtimperiod)
3242                         bs.bs_sleepduration = roundup(bs.bs_sleepduration, bs.bs_dtimperiod);
3243
3244                 DPRINTF(sc, ATH_DEBUG_BEACON,
3245                         "%s: tsf %ju tsf:tu %u intval %u nexttbtt %u dtim %u nextdtim %u bmiss %u sleep %u cfp:period %u maxdur %u next %u timoffset %u\n"
3246                         , __func__
3247                         , tsf, tsftu
3248                         , bs.bs_intval
3249                         , bs.bs_nexttbtt
3250                         , bs.bs_dtimperiod
3251                         , bs.bs_nextdtim
3252                         , bs.bs_bmissthreshold
3253                         , bs.bs_sleepduration
3254                         , bs.bs_cfpperiod
3255                         , bs.bs_cfpmaxduration
3256                         , bs.bs_cfpnext
3257                         , bs.bs_timoffset
3258                 );
3259                 ath_hal_intrset(ah, 0);
3260                 ath_hal_beacontimers(ah, &bs);
3261                 sc->sc_imask |= HAL_INT_BMISS;
3262                 ath_hal_intrset(ah, sc->sc_imask);
3263         } else {
3264                 ath_hal_intrset(ah, 0);
3265                 if (nexttbtt == intval)
3266                         intval |= HAL_BEACON_RESET_TSF;
3267                 if (ic->ic_opmode == IEEE80211_M_IBSS) {
3268                         /*
3269                          * In IBSS mode enable the beacon timers but only
3270                          * enable SWBA interrupts if we need to manually
3271                          * prepare beacon frames.  Otherwise we use a
3272                          * self-linked tx descriptor and let the hardware
3273                          * deal with things.
3274                          */
3275                         intval |= HAL_BEACON_ENA;
3276                         if (!sc->sc_hasveol)
3277                                 sc->sc_imask |= HAL_INT_SWBA;
3278                         if ((intval & HAL_BEACON_RESET_TSF) == 0) {
3279                                 /*
3280                                  * Pull nexttbtt forward to reflect
3281                                  * the current TSF.
3282                                  */
3283                                 tsf = ath_hal_gettsf64(ah);
3284                                 tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE;
3285                                 do {
3286                                         nexttbtt += intval;
3287                                 } while (nexttbtt < tsftu);
3288                         }
3289                         ath_beaconq_config(sc);
3290                 } else if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
3291                     ic->ic_opmode == IEEE80211_M_MBSS) {
3292                         /*
3293                          * In AP/mesh mode we enable the beacon timers
3294                          * and SWBA interrupts to prepare beacon frames.
3295                          */
3296                         intval |= HAL_BEACON_ENA;
3297                         sc->sc_imask |= HAL_INT_SWBA;   /* beacon prepare */
3298                         ath_beaconq_config(sc);
3299                 }
3300                 ath_hal_beaconinit(ah, nexttbtt, intval);
3301                 sc->sc_bmisscount = 0;
3302                 ath_hal_intrset(ah, sc->sc_imask);
3303                 /*
3304                  * When using a self-linked beacon descriptor in
3305                  * ibss mode load it once here.
3306                  */
3307                 if (ic->ic_opmode == IEEE80211_M_IBSS && sc->sc_hasveol)
3308                         ath_beacon_start_adhoc(sc, vap);
3309         }
3310         sc->sc_syncbeacon = 0;
3311 #undef FUDGE
3312 #undef TSF_TO_TU
3313 }
3314
3315 static void
3316 ath_load_cb(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
3317 {
3318         bus_addr_t *paddr = (bus_addr_t*) arg;
3319         KASSERT(error == 0, ("error %u on bus_dma callback", error));
3320         *paddr = segs->ds_addr;
3321 }
3322
3323 static int
3324 ath_descdma_setup(struct ath_softc *sc,
3325         struct ath_descdma *dd, ath_bufhead *head,
3326         const char *name, int nbuf, int ndesc)
3327 {
3328 #define DS2PHYS(_dd, _ds) \
3329         ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc))
3330         struct ifnet *ifp = sc->sc_ifp;
3331         struct ath_desc *ds;
3332         struct ath_buf *bf;
3333         int i, bsize, error;
3334
3335         DPRINTF(sc, ATH_DEBUG_RESET, "%s: %s DMA: %u buffers %u desc/buf\n",
3336             __func__, name, nbuf, ndesc);
3337
3338         dd->dd_name = name;
3339         dd->dd_desc_len = sizeof(struct ath_desc) * nbuf * ndesc;
3340
3341         /*
3342          * Setup DMA descriptor area.
3343          */
3344         error = bus_dma_tag_create(dd->dd_dmat, /* parent */
3345                        PAGE_SIZE, 0,            /* alignment, bounds */
3346                        BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
3347                        BUS_SPACE_MAXADDR,       /* highaddr */
3348                        NULL, NULL,              /* filter, filterarg */
3349                        dd->dd_desc_len,         /* maxsize */
3350                        1,                       /* nsegments */
3351                        dd->dd_desc_len,         /* maxsegsize */
3352                        BUS_DMA_ALLOCNOW,        /* flags */
3353                        &dd->dd_dmat);
3354         if (error != 0) {
3355                 if_printf(ifp, "cannot allocate %s DMA tag\n", dd->dd_name);
3356                 return error;
3357         }
3358
3359         /* allocate descriptors */
3360         error = bus_dmamap_create(dd->dd_dmat, BUS_DMA_NOWAIT, &dd->dd_dmamap);
3361         if (error != 0) {
3362                 if_printf(ifp, "unable to create dmamap for %s descriptors, "
3363                         "error %u\n", dd->dd_name, error);
3364                 goto fail0;
3365         }
3366
3367         error = bus_dmamem_alloc(dd->dd_dmat, (void**) &dd->dd_desc,
3368                                  BUS_DMA_NOWAIT | BUS_DMA_COHERENT, 
3369                                  &dd->dd_dmamap);
3370         if (error != 0) {
3371                 if_printf(ifp, "unable to alloc memory for %u %s descriptors, "
3372                         "error %u\n", nbuf * ndesc, dd->dd_name, error);
3373                 goto fail1;
3374         }
3375
3376         error = bus_dmamap_load(dd->dd_dmat, dd->dd_dmamap,
3377                                 dd->dd_desc, dd->dd_desc_len,
3378                                 ath_load_cb, &dd->dd_desc_paddr,
3379                                 BUS_DMA_NOWAIT);
3380         if (error != 0) {
3381                 if_printf(ifp, "unable to map %s descriptors, error %u\n",
3382                         dd->dd_name, error);
3383                 goto fail2;
3384         }
3385
3386         ds = dd->dd_desc;
3387         DPRINTF(sc, ATH_DEBUG_RESET, "%s: %s DMA map: %p (%lu) -> %p (%lu)\n",
3388             __func__, dd->dd_name, ds, (u_long) dd->dd_desc_len,
3389             (caddr_t) dd->dd_desc_paddr, /*XXX*/ (u_long) dd->dd_desc_len);
3390
3391         /* allocate rx buffers */
3392         bsize = sizeof(struct ath_buf) * nbuf;
3393         bf = kmalloc(bsize, M_ATHDEV, M_INTWAIT | M_ZERO);
3394         if (bf == NULL) {
3395                 if_printf(ifp, "malloc of %s buffers failed, size %u\n",
3396                         dd->dd_name, bsize);
3397                 goto fail3;
3398         }
3399         dd->dd_bufptr = bf;
3400
3401         STAILQ_INIT(head);
3402         for (i = 0; i < nbuf; i++, bf++, ds += ndesc) {
3403                 bf->bf_desc = ds;
3404                 bf->bf_daddr = DS2PHYS(dd, ds);
3405                 error = bus_dmamap_create(sc->sc_dmat, BUS_DMA_NOWAIT,
3406                                 &bf->bf_dmamap);
3407                 if (error != 0) {
3408                         if_printf(ifp, "unable to create dmamap for %s "
3409                                 "buffer %u, error %u\n", dd->dd_name, i, error);
3410                         ath_descdma_cleanup(sc, dd, head);
3411                         return error;
3412                 }
3413                 STAILQ_INSERT_TAIL(head, bf, bf_list);
3414         }
3415         return 0;
3416 fail3:
3417         bus_dmamap_unload(dd->dd_dmat, dd->dd_dmamap);
3418 fail2:
3419         bus_dmamem_free(dd->dd_dmat, dd->dd_desc, dd->dd_dmamap);
3420 fail1:
3421         bus_dmamap_destroy(dd->dd_dmat, dd->dd_dmamap);
3422 fail0:
3423         bus_dma_tag_destroy(dd->dd_dmat);
3424         memset(dd, 0, sizeof(*dd));
3425         return error;
3426 #undef DS2PHYS
3427 }
3428
3429 static void
3430 ath_descdma_cleanup(struct ath_softc *sc,
3431         struct ath_descdma *dd, ath_bufhead *head)
3432 {
3433         struct ath_buf *bf;
3434         struct ieee80211_node *ni;
3435
3436         bus_dmamap_unload(dd->dd_dmat, dd->dd_dmamap);
3437         bus_dmamem_free(dd->dd_dmat, dd->dd_desc, dd->dd_dmamap);
3438         bus_dmamap_destroy(dd->dd_dmat, dd->dd_dmamap);
3439         bus_dma_tag_destroy(dd->dd_dmat);
3440
3441         STAILQ_FOREACH(bf, head, bf_list) {
3442                 if (bf->bf_m) {
3443                         m_freem(bf->bf_m);
3444                         bf->bf_m = NULL;
3445                 }
3446                 if (bf->bf_dmamap != NULL) {
3447                         bus_dmamap_destroy(sc->sc_dmat, bf->bf_dmamap);
3448                         bf->bf_dmamap = NULL;
3449                 }
3450                 ni = bf->bf_node;
3451                 bf->bf_node = NULL;
3452                 if (ni != NULL) {
3453                         /*
3454                          * Reclaim node reference.
3455                          */
3456                         ieee80211_free_node(ni);
3457                 }
3458         }
3459
3460         STAILQ_INIT(head);
3461         kfree(dd->dd_bufptr, M_ATHDEV);
3462         memset(dd, 0, sizeof(*dd));
3463 }
3464
3465 static int
3466 ath_desc_alloc(struct ath_softc *sc)
3467 {
3468         int error;
3469
3470         error = ath_descdma_setup(sc, &sc->sc_rxdma, &sc->sc_rxbuf,
3471                         "rx", ath_rxbuf, 1);
3472         if (error != 0)
3473                 return error;
3474
3475         error = ath_descdma_setup(sc, &sc->sc_txdma, &sc->sc_txbuf,
3476                         "tx", ath_txbuf, ATH_TXDESC);
3477         if (error != 0) {
3478                 ath_descdma_cleanup(sc, &sc->sc_rxdma, &sc->sc_rxbuf);
3479                 return error;
3480         }
3481
3482         error = ath_descdma_setup(sc, &sc->sc_bdma, &sc->sc_bbuf,
3483                         "beacon", ATH_BCBUF, 1);
3484         if (error != 0) {
3485                 ath_descdma_cleanup(sc, &sc->sc_txdma, &sc->sc_txbuf);
3486                 ath_descdma_cleanup(sc, &sc->sc_rxdma, &sc->sc_rxbuf);
3487                 return error;
3488         }
3489         return 0;
3490 }
3491
3492 static void
3493 ath_desc_free(struct ath_softc *sc)
3494 {
3495
3496         if (sc->sc_bdma.dd_desc_len != 0)
3497                 ath_descdma_cleanup(sc, &sc->sc_bdma, &sc->sc_bbuf);
3498         if (sc->sc_txdma.dd_desc_len != 0)
3499                 ath_descdma_cleanup(sc, &sc->sc_txdma, &sc->sc_txbuf);
3500         if (sc->sc_rxdma.dd_desc_len != 0)
3501                 ath_descdma_cleanup(sc, &sc->sc_rxdma, &sc->sc_rxbuf);
3502 }
3503
3504 static struct ieee80211_node *
3505 ath_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN])
3506 {
3507         struct ieee80211com *ic = vap->iv_ic;
3508         struct ath_softc *sc = ic->ic_ifp->if_softc;
3509         const size_t space = sizeof(struct ath_node) + sc->sc_rc->arc_space;
3510         struct ath_node *an;
3511
3512         an = kmalloc(space, M_80211_NODE, M_INTWAIT|M_ZERO);
3513         if (an == NULL) {
3514                 /* XXX stat+msg */
3515                 return NULL;
3516         }
3517         ath_rate_node_init(sc, an);
3518
3519         DPRINTF(sc, ATH_DEBUG_NODE, "%s: an %p\n", __func__, an);
3520         return &an->an_node;
3521 }
3522
3523 static void
3524 ath_node_free(struct ieee80211_node *ni)
3525 {
3526         struct ieee80211com *ic = ni->ni_ic;
3527         struct ath_softc *sc = ic->ic_ifp->if_softc;
3528
3529         DPRINTF(sc, ATH_DEBUG_NODE, "%s: ni %p\n", __func__, ni);
3530
3531         ath_rate_node_cleanup(sc, ATH_NODE(ni));
3532         sc->sc_node_free(ni);
3533 }
3534
3535 static void
3536 ath_node_getsignal(const struct ieee80211_node *ni, int8_t *rssi, int8_t *noise)
3537 {
3538         struct ieee80211com *ic = ni->ni_ic;
3539         struct ath_softc *sc = ic->ic_ifp->if_softc;
3540         struct ath_hal *ah = sc->sc_ah;
3541
3542         *rssi = ic->ic_node_getrssi(ni);
3543         if (ni->ni_chan != IEEE80211_CHAN_ANYC)
3544                 *noise = ath_hal_getchannoise(ah, ni->ni_chan);
3545         else
3546                 *noise = -95;           /* nominally correct */
3547 }
3548
3549 static int
3550 ath_rxbuf_init(struct ath_softc *sc, struct ath_buf *bf)
3551 {
3552         struct ath_hal *ah = sc->sc_ah;
3553         int error;
3554         struct mbuf *m;
3555         struct ath_desc *ds;
3556
3557         m = bf->bf_m;
3558         if (m == NULL) {
3559                 /*
3560                  * NB: by assigning a page to the rx dma buffer we
3561                  * implicitly satisfy the Atheros requirement that
3562                  * this buffer be cache-line-aligned and sized to be
3563                  * multiple of the cache line size.  Not doing this
3564                  * causes weird stuff to happen (for the 5210 at least).
3565                  */
3566                 m = m_getcl(MB_WAIT, MT_DATA, M_PKTHDR);
3567                 if (m == NULL) {
3568                         kprintf("ath_rxbuf_init: no mbuf\n");
3569                         DPRINTF(sc, ATH_DEBUG_ANY,
3570                                 "%s: no mbuf/cluster\n", __func__);
3571                         sc->sc_stats.ast_rx_nombuf++;
3572                         return ENOMEM;
3573                 }
3574                 m->m_pkthdr.len = m->m_len = m->m_ext.ext_size;
3575
3576                 error = bus_dmamap_load_mbuf_segment(sc->sc_dmat,
3577                                              bf->bf_dmamap, m,
3578                                              bf->bf_segs, 1, &bf->bf_nseg,
3579                                              BUS_DMA_NOWAIT);
3580                 if (error != 0) {
3581                         DPRINTF(sc, ATH_DEBUG_ANY,
3582                             "%s: bus_dmamap_load_mbuf_segment failed; error %d\n",
3583                             __func__, error);
3584                         sc->sc_stats.ast_rx_busdma++;
3585                         m_freem(m);
3586                         return error;
3587                 }
3588                 KASSERT(bf->bf_nseg == 1,
3589                         ("multi-segment packet; nseg %u", bf->bf_nseg));
3590                 bf->bf_m = m;
3591         }
3592         bus_dmamap_sync(sc->sc_dmat, bf->bf_dmamap, BUS_DMASYNC_PREREAD);
3593
3594         /*
3595          * Setup descriptors.  For receive we always terminate
3596          * the descriptor list with a self-linked entry so we'll
3597          * not get overrun under high load (as can happen with a
3598          * 5212 when ANI processing enables PHY error frames).
3599          *
3600          * To insure the last descriptor is self-linked we create
3601          * each descriptor as self-linked and add it to the end.  As
3602          * each additional descriptor is added the previous self-linked
3603          * entry is ``fixed'' naturally.  This should be safe even
3604          * if DMA is happening.  When processing RX interrupts we
3605          * never remove/process the last, self-linked, entry on the
3606          * descriptor list.  This insures the hardware always has
3607          * someplace to write a new frame.
3608          */
3609         ds = bf->bf_desc;
3610         ds->ds_link = bf->bf_daddr;     /* link to self */
3611         ds->ds_data = bf->bf_segs[0].ds_addr;
3612         ath_hal_setuprxdesc(ah, ds
3613                 , m->m_len              /* buffer size */
3614                 , 0
3615         );
3616
3617         if (sc->sc_rxlink != NULL)
3618                 *sc->sc_rxlink = bf->bf_daddr;
3619         sc->sc_rxlink = &ds->ds_link;
3620         return 0;
3621 }
3622
3623 /*
3624  * Extend 15-bit time stamp from rx descriptor to
3625  * a full 64-bit TSF using the specified TSF.
3626  */
3627 static __inline u_int64_t
3628 ath_extend_tsf(u_int32_t rstamp, u_int64_t tsf)
3629 {
3630         if ((tsf & 0x7fff) < rstamp)
3631                 tsf -= 0x8000;
3632         return ((tsf &~ 0x7fff) | rstamp);
3633 }
3634
3635 /*
3636  * Intercept management frames to collect beacon rssi data
3637  * and to do ibss merges.
3638  */
3639 static void
3640 ath_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m,
3641         int subtype, int rssi, int nf)
3642 {
3643         struct ieee80211vap *vap = ni->ni_vap;
3644         struct ath_softc *sc = vap->iv_ic->ic_ifp->if_softc;
3645
3646         /*
3647          * Call up first so subsequent work can use information
3648          * potentially stored in the node (e.g. for ibss merge).
3649          */
3650         ATH_VAP(vap)->av_recv_mgmt(ni, m, subtype, rssi, nf);
3651         switch (subtype) {
3652         case IEEE80211_FC0_SUBTYPE_BEACON:
3653                 /* update rssi statistics for use by the hal */
3654                 ATH_RSSI_LPF(sc->sc_halstats.ns_avgbrssi, rssi);
3655                 if (sc->sc_syncbeacon &&
3656                     ni == vap->iv_bss && vap->iv_state == IEEE80211_S_RUN) {
3657                         /*
3658                          * Resync beacon timers using the tsf of the beacon
3659                          * frame we just received.
3660                          */
3661                         ath_beacon_config(sc, vap);
3662                 }
3663                 /* fall thru... */
3664         case IEEE80211_FC0_SUBTYPE_PROBE_RESP:
3665                 if (vap->iv_opmode == IEEE80211_M_IBSS &&
3666                     vap->iv_state == IEEE80211_S_RUN) {
3667                         uint32_t rstamp = sc->sc_lastrs->rs_tstamp;
3668                         u_int64_t tsf = ath_extend_tsf(rstamp,
3669                                 ath_hal_gettsf64(sc->sc_ah));
3670                         /*
3671                          * Handle ibss merge as needed; check the tsf on the
3672                          * frame before attempting the merge.  The 802.11 spec
3673                          * says the station should change it's bssid to match
3674                          * the oldest station with the same ssid, where oldest
3675                          * is determined by the tsf.  Note that hardware
3676                          * reconfiguration happens through callback to
3677                          * ath_newstate as the state machine will go from
3678                          * RUN -> RUN when this happens.
3679                          */
3680                         if (le64toh(ni->ni_tstamp.tsf) >= tsf) {
3681                                 DPRINTF(sc, ATH_DEBUG_STATE,
3682                                     "ibss merge, rstamp %u tsf %ju "
3683                                     "tstamp %ju\n", rstamp, (uintmax_t)tsf,
3684                                     (uintmax_t)ni->ni_tstamp.tsf);
3685                                 (void) ieee80211_ibss_merge(ni);
3686                         }
3687                 }
3688                 break;
3689         }
3690 }
3691
3692 /*
3693  * Set the default antenna.
3694  */
3695 static void
3696 ath_setdefantenna(struct ath_softc *sc, u_int antenna)
3697 {
3698         struct ath_hal *ah = sc->sc_ah;
3699
3700         /* XXX block beacon interrupts */
3701         ath_hal_setdefantenna(ah, antenna);
3702         if (sc->sc_defant != antenna)
3703                 sc->sc_stats.ast_ant_defswitch++;
3704         sc->sc_defant = antenna;
3705         sc->sc_rxotherant = 0;
3706 }
3707
3708 static void
3709 ath_rx_tap(struct ifnet *ifp, struct mbuf *m,
3710         const struct ath_rx_status *rs, u_int64_t tsf, int16_t nf)
3711 {
3712 #define CHAN_HT20       htole32(IEEE80211_CHAN_HT20)
3713 #define CHAN_HT40U      htole32(IEEE80211_CHAN_HT40U)
3714 #define CHAN_HT40D      htole32(IEEE80211_CHAN_HT40D)
3715 #define CHAN_HT         (CHAN_HT20|CHAN_HT40U|CHAN_HT40D)
3716         struct ath_softc *sc = ifp->if_softc;
3717         const HAL_RATE_TABLE *rt;
3718         uint8_t rix;
3719
3720         rt = sc->sc_currates;
3721         KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode));
3722         rix = rt->rateCodeToIndex[rs->rs_rate];
3723         sc->sc_rx_th.wr_rate = sc->sc_hwmap[rix].ieeerate;
3724         sc->sc_rx_th.wr_flags = sc->sc_hwmap[rix].rxflags;
3725 #ifdef AH_SUPPORT_AR5416
3726         sc->sc_rx_th.wr_chan_flags &= ~CHAN_HT;
3727         if (sc->sc_rx_th.wr_rate & IEEE80211_RATE_MCS) {        /* HT rate */
3728                 struct ieee80211com *ic = ifp->if_l2com;
3729
3730                 if ((rs->rs_flags & HAL_RX_2040) == 0)
3731                         sc->sc_rx_th.wr_chan_flags |= CHAN_HT20;
3732                 else if (IEEE80211_IS_CHAN_HT40U(ic->ic_curchan))
3733                         sc->sc_rx_th.wr_chan_flags |= CHAN_HT40U;
3734                 else
3735                         sc->sc_rx_th.wr_chan_flags |= CHAN_HT40D;
3736                 if ((rs->rs_flags & HAL_RX_GI) == 0)
3737                         sc->sc_rx_th.wr_flags |= IEEE80211_RADIOTAP_F_SHORTGI;
3738         }
3739 #endif
3740         sc->sc_rx_th.wr_tsf = htole64(ath_extend_tsf(rs->rs_tstamp, tsf));
3741         if (rs->rs_status & HAL_RXERR_CRC)
3742                 sc->sc_rx_th.wr_flags |= IEEE80211_RADIOTAP_F_BADFCS;
3743         /* XXX propagate other error flags from descriptor */
3744         sc->sc_rx_th.wr_antnoise = nf;
3745         sc->sc_rx_th.wr_antsignal = nf + rs->rs_rssi;
3746         sc->sc_rx_th.wr_antenna = rs->rs_antenna;
3747 #undef CHAN_HT
3748 #undef CHAN_HT20
3749 #undef CHAN_HT40U
3750 #undef CHAN_HT40D
3751 }
3752
3753 static void
3754 ath_handle_micerror(struct ieee80211com *ic,
3755         struct ieee80211_frame *wh, int keyix)
3756 {
3757         struct ieee80211_node *ni;