[svn-upgrade] new version madwifi (0.9.4+r4139.20110504)
[debian/madwifi.git] / ath / if_ath.c
1 /*-
2  * Copyright (c) 2002-2005 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  * 3. Neither the names of the above-listed copyright holders nor the names
16  *    of any contributors may be used to endorse or promote products derived
17  *    from this software without specific prior written permission.
18  *
19  * Alternatively, this software may be distributed under the terms of the
20  * GNU General Public License ("GPL") version 2 as published by the Free
21  * Software Foundation.
22  *
23  * NO WARRANTY
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
27  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
28  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
29  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
32  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
34  * THE POSSIBILITY OF SUCH DAMAGES.
35  *
36  * $Id: if_ath.c 4139 2011-05-03 22:07:34Z proski $
37  */
38
39 /*
40  * Driver for the Atheros Wireless LAN controller.
41  *
42  * This software is derived from work of Atsushi Onoe; his contribution
43  * is greatly appreciated.
44  */
45 #include "opt_ah.h"
46
47 #if !defined(AUTOCONF_INCLUDED) && !defined(CONFIG_LOCALVERSION)
48 #include <linux/config.h>
49 #endif
50 #include <linux/version.h>
51 #include <linux/module.h>
52 #include <linux/init.h>
53 #include <linux/skbuff.h>
54 #include <linux/netdevice.h>
55 #include <linux/etherdevice.h>
56 #include <linux/random.h>
57 #include <linux/delay.h>
58 #include <linux/cache.h>
59 #include <linux/sysctl.h>
60 #include <linux/proc_fs.h>
61 #include <linux/if_arp.h>
62 #include <linux/rtnetlink.h>
63 #include <asm/uaccess.h>
64
65 #include "if_ethersubr.h"               /* for ETHER_IS_MULTICAST */
66 #include "if_media.h"
67 #include "if_llc.h"
68
69 #include <net80211/ieee80211_radiotap.h>
70 #include <net80211/ieee80211_var.h>
71 #include <net80211/ieee80211_monitor.h>
72 #include <net80211/ieee80211_rate.h>
73
74 #ifdef USE_HEADERLEN_RESV
75 #include <net80211/if_llc.h>
76 #endif
77
78 #define AR_DEBUG
79
80 #include "net80211/if_athproto.h"
81 #include "if_athvar.h"
82 #include "ah_desc.h"
83 #include "ah_devid.h"                   /* XXX to identify chipset */
84
85 #ifdef ATH_PCI          /* PCI BUS */
86 #include "if_ath_pci.h"
87 #endif                  /* PCI BUS */
88 #ifdef ATH_AHB          /* AHB BUS */
89 #include "if_ath_ahb.h"
90 #endif                  /* AHB BUS */
91
92 #ifdef ATH_TX99_DIAG
93 #include "ath_tx99.h"
94 #endif
95
96 /* unaligned little endian access */
97 #define LE_READ_2(p)                                                    \
98         ((u_int16_t)                                                    \
99          ((((u_int8_t *)(p))[0]      ) | (((u_int8_t *)(p))[1] <<  8)))
100 #define LE_READ_4(p)                                                    \
101         ((u_int32_t)                                                    \
102          ((((u_int8_t *)(p))[0]      ) | (((u_int8_t *)(p))[1] <<  8) | \
103           (((u_int8_t *)(p))[2] << 16) | (((u_int8_t *)(p))[3] << 24)))
104
105 /* Default rate control algorithm */
106 #ifdef CONFIG_ATHEROS_RATE_DEFAULT
107 #define DEF_RATE_CTL CONFIG_ATHEROS_RATE_DEFAULT
108 #else
109 #define DEF_RATE_CTL "sample"
110 #endif
111
112 enum {
113         ATH_LED_TX,
114         ATH_LED_RX,
115         ATH_LED_POLL,
116 };
117
118 static struct ieee80211vap *ath_vap_create(struct ieee80211com *,
119         const char *, int, int, int, struct net_device *);
120 static void ath_vap_delete(struct ieee80211vap *);
121 static int ath_init(struct net_device *);
122 static int ath_set_ack_bitrate(struct ath_softc *, int);
123 static int ath_reset(struct net_device *);
124 static void ath_fatal_tasklet(TQUEUE_ARG);
125 static void ath_rxorn_tasklet(TQUEUE_ARG);
126 static void ath_bmiss_tasklet(TQUEUE_ARG);
127 static void ath_bstuck_tasklet(TQUEUE_ARG);
128 static void ath_radar_task(struct work_struct *);
129 static void ath_dfs_test_return(unsigned long);
130
131 static int ath_stop_locked(struct net_device *);
132 static int ath_stop(struct net_device *);
133 #if 0
134 static void ath_initkeytable(struct ath_softc *);
135 #endif
136 static int ath_key_alloc(struct ieee80211vap *, const struct ieee80211_key *);
137 static int ath_key_delete(struct ieee80211vap *, const struct ieee80211_key *,
138         struct ieee80211_node *);
139 static int ath_key_set(struct ieee80211vap *, const struct ieee80211_key *,
140         const u_int8_t mac[IEEE80211_ADDR_LEN]);
141 static void ath_key_update_begin(struct ieee80211vap *);
142 static void ath_key_update_end(struct ieee80211vap *);
143 static void ath_mode_init(struct net_device *);
144 static void ath_setslottime(struct ath_softc *);
145 static void ath_updateslot(struct net_device *);
146 static int ath_beaconq_setup(struct ath_hal *);
147 static int ath_beacon_alloc(struct ath_softc *, struct ieee80211_node *);
148 #ifdef ATH_SUPERG_DYNTURBO
149 static void ath_beacon_dturbo_update(struct ieee80211vap *, int *, u_int8_t);
150 static void ath_beacon_dturbo_config(struct ieee80211vap *, u_int32_t);
151 static void ath_turbo_switch_mode(unsigned long);
152 static int ath_check_beacon_done(struct ath_softc *);
153 #endif
154 static void ath_beacon_send(struct ath_softc *, int *);
155 static void ath_beacon_start_adhoc(struct ath_softc *, struct ieee80211vap *);
156 static void ath_beacon_return(struct ath_softc *, struct ath_buf *);
157 static void ath_beacon_free(struct ath_softc *);
158 static void ath_beacon_config(struct ath_softc *, struct ieee80211vap *);
159 static int ath_desc_alloc(struct ath_softc *);
160 static void ath_desc_free(struct ath_softc *);
161 static void ath_desc_swap(struct ath_desc *);
162 static struct ieee80211_node *ath_node_alloc(struct ieee80211_node_table *,
163         struct ieee80211vap *);
164 static void ath_node_cleanup(struct ieee80211_node *);
165 static void ath_node_free(struct ieee80211_node *);
166 static u_int8_t ath_node_getrssi(const struct ieee80211_node *);
167 static int ath_rxbuf_init(struct ath_softc *, struct ath_buf *);
168 static void ath_recv_mgmt(struct ieee80211_node *, struct sk_buff *, int,
169         int, u_int32_t);
170 static void ath_setdefantenna(struct ath_softc *, u_int);
171 static struct ath_txq *ath_txq_setup(struct ath_softc *, int, int);
172 static void ath_rx_tasklet(TQUEUE_ARG);
173 static int ath_hardstart(struct sk_buff *, struct net_device *);
174 static int ath_mgtstart(struct ieee80211com *, struct sk_buff *);
175 #ifdef ATH_SUPERG_COMP
176 static u_int32_t ath_get_icvlen(struct ieee80211_key *);
177 static u_int32_t ath_get_ivlen(struct ieee80211_key *);
178 static void ath_setup_comp(struct ieee80211_node *, int);
179 static void ath_comp_set(struct ieee80211vap *, struct ieee80211_node *, int);  
180 #endif
181 static int ath_tx_setup(struct ath_softc *, int, int);
182 static int ath_wme_update(struct ieee80211com *);
183 static void ath_uapsd_flush(struct ieee80211_node *);
184 static void ath_tx_cleanupq(struct ath_softc *, struct ath_txq *);
185 static void ath_tx_cleanup(struct ath_softc *);
186 static void ath_tx_uapsdqueue(struct ath_softc *, struct ath_node *,
187         struct ath_buf *);
188
189 static int ath_tx_start(struct net_device *, struct ieee80211_node *,
190         struct ath_buf *, struct sk_buff *, int);
191 static void ath_tx_tasklet_q0(TQUEUE_ARG);
192 static void ath_tx_tasklet_q0123(TQUEUE_ARG);
193 static void ath_tx_tasklet(TQUEUE_ARG);
194 static void ath_tx_timeout(struct net_device *);
195 static void ath_tx_draintxq(struct ath_softc *, struct ath_txq *);
196 static int ath_chan_set(struct ath_softc *, struct ieee80211_channel *);
197 static void ath_draintxq(struct ath_softc *);
198 static __inline void ath_tx_txqaddbuf(struct ath_softc *, struct ieee80211_node *,
199         struct ath_txq *, struct ath_buf *, struct ath_desc *, int);
200 static void ath_stoprecv(struct ath_softc *);
201 static int ath_startrecv(struct ath_softc *);
202 static void ath_flushrecv(struct ath_softc *);
203 static void ath_chan_change(struct ath_softc *, struct ieee80211_channel *);
204 static void ath_calibrate(unsigned long);
205 static int ath_newstate(struct ieee80211vap *, enum ieee80211_state, int);
206
207 static void ath_scan_start(struct ieee80211com *);
208 static void ath_scan_end(struct ieee80211com *);
209 static void ath_set_channel(struct ieee80211com *);
210 static void ath_set_coverageclass(struct ieee80211com *);
211 static u_int ath_mhz2ieee(struct ieee80211com *, u_int, u_int);
212 #ifdef ATH_SUPERG_FF
213 static int athff_can_aggregate(struct ath_softc *, struct ether_header *,
214         struct ath_node *, struct sk_buff *, u_int16_t, int *);
215 #endif
216 static struct net_device_stats *ath_getstats(struct net_device *);
217 static void ath_setup_stationkey(struct ieee80211_node *);
218 static void ath_setup_stationwepkey(struct ieee80211_node *);
219 static void ath_setup_keycacheslot(struct ath_softc *, struct ieee80211_node *);
220 static void ath_newassoc(struct ieee80211_node *, int);
221 static int ath_getchannels(struct net_device *, u_int, HAL_BOOL, HAL_BOOL);
222 static void ath_led_event(struct ath_softc *, int);
223 static void ath_update_txpow(struct ath_softc *);
224
225 static int ath_set_mac_address(struct net_device *, void *);
226 static int ath_change_mtu(struct net_device *, int);
227 static int ath_ioctl(struct net_device *, struct ifreq *, int);
228
229 static int ath_rate_setup(struct net_device *, u_int);
230 static void ath_setup_subrates(struct net_device *);
231 #ifdef ATH_SUPERG_XR
232 static int ath_xr_rate_setup(struct net_device *);
233 static void ath_grppoll_txq_setup(struct ath_softc *, int, int);
234 static void ath_grppoll_start(struct ieee80211vap *, int);
235 static void ath_grppoll_stop(struct ieee80211vap *);
236 static u_int8_t ath_node_move_data(const struct ieee80211_node *);
237 static void ath_grppoll_txq_update(struct ath_softc *, int);
238 static void ath_grppoll_period_update(struct ath_softc *);
239 #endif
240 static void ath_setcurmode(struct ath_softc *, enum ieee80211_phymode);
241
242 static void ath_dynamic_sysctl_register(struct ath_softc *);
243 static void ath_dynamic_sysctl_unregister(struct ath_softc *);
244 static void ath_announce(struct net_device *);
245 static int ath_descdma_setup(struct ath_softc *, struct ath_descdma *,
246         ath_bufhead *, const char *, int, int);
247 static void ath_descdma_cleanup(struct ath_softc *, struct ath_descdma *,
248         ath_bufhead *, int);
249 static void ath_check_dfs_clear(unsigned long);
250 static const char *ath_get_hal_status_desc(HAL_STATUS status);
251 static int ath_rcv_dev_event(struct notifier_block *, unsigned long, void *);
252         
253 static int ath_calinterval = ATH_SHORT_CALINTERVAL;             /*
254                                                                  * calibrate every 30 secs in steady state
255                                                                  * but check every second at first.
256                                                                  */
257 static int ath_countrycode = CTRY_DEFAULT;      /* country code */
258 static int ath_outdoor = AH_FALSE;              /* enable outdoor use */
259 static int ath_xchanmode = AH_TRUE;             /* enable extended channels */
260 static int ath_maxvaps = ATH_MAXVAPS_DEFAULT;   /* set default maximum vaps */
261 static char *autocreate = NULL;
262 static char *ratectl = DEF_RATE_CTL;
263 static int rfkill = -1;
264 static int countrycode = -1;
265 static int maxvaps = -1;
266 static int outdoor = -1;
267 static int xchanmode = -1;
268
269 static const char *hal_status_desc[] = {
270         "No error",
271         "No hardware present or device not yet supported",
272         "Memory allocation failed",
273         "Hardware didn't respond as expected",
274         "EEPROM magic number invalid",
275         "EEPROM version invalid",
276         "EEPROM unreadable",
277         "EEPROM checksum invalid",
278         "EEPROM read problem",
279         "EEPROM mac address invalid",
280         "EEPROM size not supported",
281         "Attempt to change write-locked EEPROM",
282         "Invalid parameter to function",
283         "Hardware revision not supported",
284         "Hardware self-test failed",
285         "Operation incomplete"
286 };
287
288 static struct notifier_block ath_event_block = {
289         .notifier_call = ath_rcv_dev_event
290 };
291
292 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,52))
293 MODULE_PARM(countrycode, "i");
294 MODULE_PARM(maxvaps, "i");
295 MODULE_PARM(outdoor, "i");
296 MODULE_PARM(xchanmode, "i");
297 MODULE_PARM(rfkill, "i");
298 MODULE_PARM(autocreate, "s");
299 MODULE_PARM(ratectl, "s");
300 #else
301 #include <linux/moduleparam.h>
302 module_param(countrycode, int, 0600);
303 module_param(maxvaps, int, 0600);
304 module_param(outdoor, int, 0600);
305 module_param(xchanmode, int, 0600);
306 module_param(rfkill, int, 0600);
307 module_param(autocreate, charp, 0600);
308 module_param(ratectl, charp, 0600);
309 #endif
310 MODULE_PARM_DESC(countrycode, "Override default country code");
311 MODULE_PARM_DESC(maxvaps, "Maximum VAPs");
312 MODULE_PARM_DESC(outdoor, "Enable/disable outdoor use");
313 MODULE_PARM_DESC(xchanmode, "Enable/disable extended channel mode");
314 MODULE_PARM_DESC(rfkill, "Enable/disable RFKILL capability");
315 MODULE_PARM_DESC(autocreate, "Create ath device in [sta|ap|wds|adhoc|ahdemo|monitor] mode. defaults to sta, use 'none' to disable");
316 MODULE_PARM_DESC(ratectl, "Rate control algorithm [amrr|minstrel|onoe|sample], defaults to '" DEF_RATE_CTL "'");
317
318 static int      ath_debug = 0;
319 #ifdef AR_DEBUG
320 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,52))
321 MODULE_PARM(ath_debug, "i");
322 #else
323 module_param(ath_debug, int, 0600);
324 #endif
325 MODULE_PARM_DESC(ath_debug, "Load-time debug output enable");
326
327 #define IFF_DUMPPKTS(sc, _m) \
328         ((sc->sc_debug & _m))
329 static void ath_printrxbuf(struct ath_buf *, int);
330 static void ath_printtxbuf(struct ath_buf *, int);
331 enum {
332         ATH_DEBUG_XMIT          = 0x00000001,   /* basic xmit operation */
333         ATH_DEBUG_XMIT_DESC     = 0x00000002,   /* xmit descriptors */
334         ATH_DEBUG_RECV          = 0x00000004,   /* basic recv operation */
335         ATH_DEBUG_RECV_DESC     = 0x00000008,   /* recv descriptors */
336         ATH_DEBUG_RATE          = 0x00000010,   /* rate control */
337         ATH_DEBUG_RESET         = 0x00000020,   /* reset processing */
338         /* 0x00000040 was ATH_DEBUG_MODE */
339         ATH_DEBUG_BEACON        = 0x00000080,   /* beacon handling */
340         ATH_DEBUG_WATCHDOG      = 0x00000100,   /* watchdog timeout */
341         ATH_DEBUG_INTR          = 0x00001000,   /* ISR */
342         ATH_DEBUG_TX_PROC       = 0x00002000,   /* tx ISR proc */
343         ATH_DEBUG_RX_PROC       = 0x00004000,   /* rx ISR proc */
344         ATH_DEBUG_BEACON_PROC   = 0x00008000,   /* beacon ISR proc */
345         ATH_DEBUG_CALIBRATE     = 0x00010000,   /* periodic calibration */
346         ATH_DEBUG_KEYCACHE      = 0x00020000,   /* key cache management */
347         ATH_DEBUG_STATE         = 0x00040000,   /* 802.11 state transitions */
348         ATH_DEBUG_NODE          = 0x00080000,   /* node management */
349         ATH_DEBUG_LED           = 0x00100000,   /* led management */
350         ATH_DEBUG_FF            = 0x00200000,   /* fast frames */
351         ATH_DEBUG_TURBO         = 0x00400000,   /* turbo/dynamic turbo */
352         ATH_DEBUG_UAPSD         = 0x00800000,   /* uapsd */
353         ATH_DEBUG_DOTH          = 0x01000000,   /* 11.h */
354         ATH_DEBUG_FATAL         = 0x80000000,   /* fatal errors */
355         ATH_DEBUG_ANY           = 0xffffffff
356 };
357 #define DPRINTF(sc, _m, _fmt, ...) do {                         \
358         if (sc->sc_debug & (_m))                                \
359                 printk(_fmt, __VA_ARGS__);                      \
360 } while (0)
361 #define KEYPRINTF(sc, ix, hk, mac) do {                         \
362         if (sc->sc_debug & ATH_DEBUG_KEYCACHE)                  \
363                 ath_keyprint(sc, __func__, ix, hk, mac);        \
364 } while (0)
365 #else /* defined(AR_DEBUG) */
366 #define IFF_DUMPPKTS(sc, _m)    netif_msg_dumppkts(&sc->sc_ic)
367 #define DPRINTF(sc, _m, _fmt, ...)
368 #define KEYPRINTF(sc, k, ix, mac)
369 #endif /* defined(AR_DEBUG) */
370
371 #define ATH_SETUP_XR_VAP(sc,vap,rfilt) \
372         do { \
373                 if (sc->sc_curchan.privFlags & CHANNEL_4MS_LIMIT) \
374                         vap->iv_fragthreshold = XR_4MS_FRAG_THRESHOLD; \
375                 else \
376                         vap->iv_fragthreshold = vap->iv_xrvap->iv_fragthreshold; \
377                 if (!sc->sc_xrgrppoll) { \
378                         ath_grppoll_txq_setup(sc, HAL_TX_QUEUE_DATA, GRP_POLL_PERIOD_NO_XR_STA(sc)); \
379                         ath_grppoll_start(vap, sc->sc_xrpollcount); \
380                         ath_hal_setrxfilter(sc->sc_ah, rfilt|HAL_RX_FILTER_XRPOLL); \
381                 } \
382         } while(0)
383
384 /*
385  * Define the scheme that we select MAC address for multiple BSS on the same radio.
386  * The very first VAP will just use the MAC address from the EEPROM.
387  * For the next 3 VAPs, we set the U/L bit (bit 1) in MAC address,
388  * and use the next two bits as the index of the VAP.
389  */
390 #define ATH_SET_VAP_BSSID_MASK(bssid_mask)                              \
391         ((bssid_mask)[0] &= ~(((ath_maxvaps-1) << 2) | 0x02))
392 #define ATH_GET_VAP_ID(bssid)                   ((bssid)[0] >> 2)
393 #define ATH_SET_VAP_BSSID(bssid, id)                                    \
394         do {                                                            \
395                 if (id)                                                 \
396                         (bssid)[0] |= (((id) << 2) | 0x02);             \
397         } while(0)
398
399 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
400 static const struct net_device_ops ath_netdev_ops = {
401         .ndo_open               = ath_init,
402         .ndo_stop               = ath_stop,
403         .ndo_start_xmit         = ath_hardstart,
404         .ndo_tx_timeout         = ath_tx_timeout,
405         .ndo_set_multicast_list = ath_mode_init,
406         .ndo_do_ioctl           = ath_ioctl,
407         .ndo_get_stats          = ath_getstats,
408         .ndo_set_mac_address    = ath_set_mac_address,
409         .ndo_change_mtu         = ath_change_mtu,
410 };
411 #endif
412
413 int
414 ath_attach(u_int16_t devid, struct net_device *dev, HAL_BUS_TAG tag)
415 {
416         struct ath_softc *sc = netdev_priv(dev);
417         struct ieee80211com *ic = &sc->sc_ic;
418         struct ath_hal *ah;
419         HAL_STATUS status;
420         int error = 0, i;
421         int autocreatemode = IEEE80211_M_STA;
422         u_int8_t csz;
423
424         sc->devid = devid;
425         sc->sc_debug = ath_debug;
426         DPRINTF(sc, ATH_DEBUG_ANY, "%s: devid 0x%x\n", __func__, devid);
427
428         /* Allocate space for dynamically determined maximum VAP count */
429         sc->sc_bslot = kmalloc(ath_maxvaps * sizeof(struct ieee80211vap), GFP_KERNEL);
430         memset(sc->sc_bslot, 0, ath_maxvaps * sizeof(struct ieee80211vap));
431
432         /*
433          * Cache line size is used to size and align various
434          * structures used to communicate with the hardware.
435          */
436         bus_read_cachesize(sc, &csz);
437         /* XXX assert csz is non-zero */
438         sc->sc_cachelsz = csz << 2;             /* convert to bytes */
439
440         ATH_LOCK_INIT(sc);
441         ATH_TXBUF_LOCK_INIT(sc);
442         ATH_RXBUF_LOCK_INIT(sc);
443
444         ATH_INIT_TQUEUE(&sc->sc_rxtq,    ath_rx_tasklet,        dev);
445         ATH_INIT_TQUEUE(&sc->sc_txtq,    ath_tx_tasklet,        dev);
446         ATH_INIT_TQUEUE(&sc->sc_bmisstq, ath_bmiss_tasklet,     dev);
447         ATH_INIT_TQUEUE(&sc->sc_bstucktq,ath_bstuck_tasklet,    dev);
448         ATH_INIT_TQUEUE(&sc->sc_rxorntq, ath_rxorn_tasklet,     dev);
449         ATH_INIT_TQUEUE(&sc->sc_fataltq, ath_fatal_tasklet,     dev);
450         ATH_INIT_WORK(&sc->sc_radartask, ath_radar_task);
451
452         /*
453          * Attach the HAL and verify ABI compatibility by checking
454          * the HAL's ABI signature against the one the driver was
455          * compiled with.  A mismatch indicates the driver was
456          * built with an ah.h that does not correspond to the HAL
457          * module loaded in the kernel.
458          */
459         ah = _ath_hal_attach(devid, sc, tag, sc->sc_iobase, &status);
460         if (ah == NULL) {
461                 printk(KERN_ERR "%s: unable to attach hardware: '%s' (HAL status %u)\n",
462                         dev->name, ath_get_hal_status_desc(status), status);
463                 error = ENXIO;
464                 goto bad;
465         }
466         if (ah->ah_abi != HAL_ABI_VERSION) {
467                 printk(KERN_ERR "%s: HAL ABI mismatch; "
468                         "driver expects 0x%x, HAL reports 0x%x\n",
469                         dev->name, HAL_ABI_VERSION, ah->ah_abi);
470                 error = ENXIO;          /* XXX */
471                 goto bad;
472         }
473         sc->sc_ah = ah;
474
475         /*
476          * Check if the MAC has multi-rate retry support.
477          * We do this by trying to setup a fake extended
478          * descriptor.  MAC's that don't have support will
479          * return false w/o doing anything.  MAC's that do
480          * support it will return true w/o doing anything.
481          */
482         sc->sc_mrretry = ath_hal_setupxtxdesc(ah, NULL, 0,0, 0,0, 0,0);
483
484         /*
485          * Check if the device has hardware counters for PHY
486          * errors.  If so we need to enable the MIB interrupt
487          * so we can act on stat triggers.
488          */
489         if (ath_hal_hwphycounters(ah))
490                 sc->sc_needmib = 1;
491
492         /*
493          * Get the hardware key cache size.
494          */
495         sc->sc_keymax = ath_hal_keycachesize(ah);
496         if (sc->sc_keymax > ATH_KEYMAX) {
497                 printk("%s: Warning, using only %u entries in %u key cache\n",
498                         dev->name, ATH_KEYMAX, sc->sc_keymax);
499                 sc->sc_keymax = ATH_KEYMAX;
500         }
501         /*
502          * Reset the key cache since some parts do not
503          * reset the contents on initial power up.
504          */
505         for (i = 0; i < sc->sc_keymax; i++)
506                 ath_hal_keyreset(ah, i);
507
508         /*
509          * Collect the channel list using the default country
510          * code and including outdoor channels.  The 802.11 layer
511          * is responsible for filtering this list based on settings
512          * like the phy mode.
513          */
514         if (countrycode != -1)
515                 ath_countrycode = countrycode;
516         if (maxvaps != -1) {
517                 ath_maxvaps = maxvaps;
518                 if (ath_maxvaps < ATH_MAXVAPS_MIN)
519                         ath_maxvaps = ATH_MAXVAPS_MIN;
520                 if (ath_maxvaps > ATH_MAXVAPS_MAX)
521                         ath_maxvaps = ATH_MAXVAPS_MAX;
522         }
523         if (outdoor != -1)
524                 ath_outdoor = outdoor;
525         if (xchanmode != -1)
526                 ath_xchanmode = xchanmode;
527         error = ath_getchannels(dev, ath_countrycode,
528                         ath_outdoor, ath_xchanmode);
529         if (error != 0)
530                 goto bad;
531
532         ic->ic_country_code = ath_countrycode;
533         ic->ic_country_outdoor = ath_outdoor;
534
535         if (rfkill != -1) {
536                 printk(KERN_INFO "ath_pci: switching rfkill capability %s\n",
537                         rfkill ? "on" : "off"); 
538                 ath_hal_setrfsilent(ah, rfkill);
539         }
540
541         /*
542          * Setup rate tables for all potential media types.
543          */
544         ath_rate_setup(dev, IEEE80211_MODE_11A);
545         ath_rate_setup(dev, IEEE80211_MODE_11B);
546         ath_rate_setup(dev, IEEE80211_MODE_11G);
547         ath_rate_setup(dev, IEEE80211_MODE_TURBO_A);
548         ath_rate_setup(dev, IEEE80211_MODE_TURBO_G);
549
550         /* Setup for half/quarter rates */
551         ath_setup_subrates(dev);
552
553         /* NB: setup here so ath_rate_update is happy */
554         ath_setcurmode(sc, IEEE80211_MODE_11A);
555
556         /*
557          * Allocate tx+rx descriptors and populate the lists.
558          */
559         error = ath_desc_alloc(sc);
560         if (error != 0) {
561                 printk(KERN_ERR "%s: failed to allocate descriptors: %d\n",
562                         dev->name, error);
563                 goto bad;
564         }
565
566         /*
567          * Init ic_caps prior to queue init, since WME cap setting
568          * depends on queue setup.
569          */
570         ic->ic_caps = 0;
571
572         /*
573          * Allocate hardware transmit queues: one queue for
574          * beacon frames and one data queue for each QoS
575          * priority.  Note that the HAL handles resetting
576          * these queues at the needed time.
577          *
578          * XXX PS-Poll
579          */
580         sc->sc_bhalq = ath_beaconq_setup(ah);
581         if (sc->sc_bhalq == (u_int) -1) {
582                 printk(KERN_ERR "%s: unable to setup a beacon xmit queue!\n",
583                         dev->name);
584                 error = EIO;
585                 goto bad2;
586         }
587         sc->sc_cabq = ath_txq_setup(sc, HAL_TX_QUEUE_CAB, 0);
588         if (sc->sc_cabq == NULL) {
589                 printk(KERN_ERR "%s: unable to setup CAB xmit queue!\n",
590                         dev->name);
591                 error = EIO;
592                 goto bad2;
593         }
594         /* NB: ensure BK queue is the lowest priority h/w queue */
595         if (!ath_tx_setup(sc, WME_AC_BK, HAL_WME_AC_BK)) {
596                 printk(KERN_ERR "%s: unable to setup xmit queue for %s traffic!\n",
597                         dev->name, ieee80211_wme_acnames[WME_AC_BK]);
598                 error = EIO;
599                 goto bad2;
600         }
601         if (!ath_tx_setup(sc, WME_AC_BE, HAL_WME_AC_BE) ||
602             !ath_tx_setup(sc, WME_AC_VI, HAL_WME_AC_VI) ||
603             !ath_tx_setup(sc, WME_AC_VO, HAL_WME_AC_VO)) {
604                 /*
605                  * Not enough hardware tx queues to properly do WME;
606                  * just punt and assign them all to the same h/w queue.
607                  * We could do a better job of this if, for example,
608                  * we allocate queues when we switch from station to
609                  * AP mode.
610                  */
611                 if (sc->sc_ac2q[WME_AC_VI] != NULL)
612                         ath_tx_cleanupq(sc, sc->sc_ac2q[WME_AC_VI]);
613                 if (sc->sc_ac2q[WME_AC_BE] != NULL)
614                         ath_tx_cleanupq(sc, sc->sc_ac2q[WME_AC_BE]);
615                 sc->sc_ac2q[WME_AC_BE] = sc->sc_ac2q[WME_AC_BK];
616                 sc->sc_ac2q[WME_AC_VI] = sc->sc_ac2q[WME_AC_BK];
617                 sc->sc_ac2q[WME_AC_VO] = sc->sc_ac2q[WME_AC_BK];
618         } else {
619                 /*
620                  * Mark WME capability since we have sufficient
621                  * hardware queues to do proper priority scheduling.
622                  */
623                 ic->ic_caps |= IEEE80211_C_WME;
624                 sc->sc_uapsdq = ath_txq_setup(sc, HAL_TX_QUEUE_UAPSD, 0);
625                 if (sc->sc_uapsdq == NULL)
626                         DPRINTF(sc, ATH_DEBUG_UAPSD, "%s: unable to setup UAPSD xmit queue!\n",
627                                 __func__);
628                 else {
629                         ic->ic_caps |= IEEE80211_C_UAPSD;
630                         /*
631                          * default UAPSD on if HW capable
632                          */
633                         IEEE80211_COM_UAPSD_ENABLE(ic);
634                 }
635         }
636 #ifdef ATH_SUPERG_XR
637         ath_xr_rate_setup(dev);
638         sc->sc_xrpollint = XR_DEFAULT_POLL_INTERVAL;
639         sc->sc_xrpollcount = XR_DEFAULT_POLL_COUNT;
640         strcpy(sc->sc_grppoll_str, XR_DEFAULT_GRPPOLL_RATE_STR);
641         sc->sc_grpplq.axq_qnum = -1;
642         sc->sc_xrtxq = ath_txq_setup(sc, HAL_TX_QUEUE_DATA, HAL_XR_DATA);
643 #endif
644
645         /*
646          * Special case certain configurations.  Note the
647          * CAB queue is handled by these specially so don't
648          * include them when checking the txq setup mask.
649          */
650         switch (sc->sc_txqsetup &~ ((1<<sc->sc_cabq->axq_qnum) |
651                                 (sc->sc_uapsdq ? (1<<sc->sc_uapsdq->axq_qnum) : 0))) {
652         case 0x01:
653                 ATH_INIT_TQUEUE(&sc->sc_txtq, ath_tx_tasklet_q0, dev);
654                 break;
655         case 0x0f:
656                 ATH_INIT_TQUEUE(&sc->sc_txtq, ath_tx_tasklet_q0123, dev);
657                 break;
658         }
659
660         sc->sc_setdefantenna = ath_setdefantenna;
661         sc->sc_rc = ieee80211_rate_attach(sc, ratectl);
662         if (sc->sc_rc == NULL) {
663                 error = EIO;
664                 goto bad2;
665         }
666
667         init_timer(&sc->sc_cal_ch);
668         sc->sc_cal_ch.function = ath_calibrate;
669         sc->sc_cal_ch.data = (unsigned long) dev;
670
671 #ifdef ATH_SUPERG_DYNTURBO
672         init_timer(&sc->sc_dturbo_switch_mode);
673         sc->sc_dturbo_switch_mode.function = ath_turbo_switch_mode;
674         sc->sc_dturbo_switch_mode.data = (unsigned long) dev;
675 #endif
676
677         sc->sc_blinking = 0;
678         sc->sc_ledstate = 1;
679         sc->sc_ledon = 0;                       /* low true */
680         sc->sc_ledidle = msecs_to_jiffies(2700);        /* 2.7 sec */
681         sc->sc_dfstesttime = ATH_DFS_TEST_RETURN_PERIOD;
682         init_timer(&sc->sc_ledtimer);
683         init_timer(&sc->sc_dfswaittimer);
684         init_timer(&sc->sc_dfstesttimer);
685         sc->sc_ledtimer.data = (unsigned long) sc;
686         if (sc->sc_softled) {
687                 ath_hal_gpioCfgOutput(ah, sc->sc_ledpin);
688                 ath_hal_gpioset(ah, sc->sc_ledpin, !sc->sc_ledon);
689         }
690
691         /* NB: ether_setup is done by bus-specific code */
692 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)
693         dev->open = ath_init;
694         dev->stop = ath_stop;
695         dev->hard_start_xmit = ath_hardstart;
696         dev->tx_timeout = ath_tx_timeout;
697         dev->set_multicast_list = ath_mode_init;
698         dev->do_ioctl = ath_ioctl;
699         dev->get_stats = ath_getstats;
700         dev->set_mac_address = ath_set_mac_address;
701         dev->change_mtu = ath_change_mtu;
702 #else
703         dev->netdev_ops = &ath_netdev_ops;
704 #endif
705         dev->watchdog_timeo = 5 * HZ;
706         dev->tx_queue_len = ATH_TXBUF - 1;              /* 1 for mgmt frame */
707 #ifdef USE_HEADERLEN_RESV
708         dev->hard_header_len += sizeof(struct ieee80211_qosframe) +
709                                 sizeof(struct llc) +
710                                 IEEE80211_ADDR_LEN +
711                                 IEEE80211_WEP_IVLEN +
712                                 IEEE80211_WEP_KIDLEN;
713 #ifdef ATH_SUPERG_FF
714         dev->hard_header_len += ATH_FF_MAX_HDR;
715 #endif
716 #endif
717         ic->ic_dev = dev;
718         ic->ic_mgtstart = ath_mgtstart;
719         ic->ic_init = ath_init;
720         ic->ic_reset = ath_reset;
721         ic->ic_newassoc = ath_newassoc;
722         ic->ic_updateslot = ath_updateslot;
723
724         ic->ic_wme.wme_update = ath_wme_update;
725         ic->ic_uapsd_flush = ath_uapsd_flush;
726
727         /* XXX not right but it's not used anywhere important */
728         ic->ic_phytype = IEEE80211_T_OFDM;
729         ic->ic_opmode = IEEE80211_M_STA;
730         sc->sc_opmode = HAL_M_STA;
731         /* 
732          * Set the Atheros Advanced Capabilities from station config before 
733          * starting 802.11 state machine.  Currently, set only fast-frames 
734          * capability.
735          */
736         ic->ic_ath_cap = 0;
737         sc->sc_fftxqmin = ATH_FF_TXQMIN;
738 #ifdef ATH_SUPERG_FF
739         ic->ic_ath_cap |= (ath_hal_fastframesupported(ah) ? IEEE80211_ATHC_FF : 0);
740 #endif
741         ic->ic_ath_cap |= (ath_hal_burstsupported(ah) ? IEEE80211_ATHC_BURST : 0);
742
743 #ifdef ATH_SUPERG_COMP
744         ic->ic_ath_cap |= (ath_hal_compressionsupported(ah) ? IEEE80211_ATHC_COMP : 0); 
745 #endif
746
747 #ifdef ATH_SUPERG_DYNTURBO
748         ic->ic_ath_cap |= (ath_hal_turboagsupported(ah) ? (IEEE80211_ATHC_TURBOP |
749                                                         IEEE80211_ATHC_AR) : 0);
750 #endif
751 #ifdef ATH_SUPERG_XR
752         ic->ic_ath_cap |= (ath_hal_xrsupported(ah) ? IEEE80211_ATHC_XR : 0);
753 #endif
754
755         ic->ic_caps |=
756                   IEEE80211_C_IBSS              /* ibss, nee adhoc, mode */
757                 | IEEE80211_C_HOSTAP            /* hostap mode */
758                 | IEEE80211_C_MONITOR           /* monitor mode */
759                 | IEEE80211_C_AHDEMO            /* adhoc demo mode */
760                 | IEEE80211_C_SHPREAMBLE        /* short preamble supported */
761                 | IEEE80211_C_SHSLOT            /* short slot time supported */
762                 | IEEE80211_C_WPA               /* capable of WPA1+WPA2 */
763                 | IEEE80211_C_BGSCAN            /* capable of bg scanning */
764                 ;
765         /*
766          * Query the HAL to figure out h/w crypto support.
767          */
768         if (ath_hal_ciphersupported(ah, HAL_CIPHER_WEP))
769                 ic->ic_caps |= IEEE80211_C_WEP;
770         if (ath_hal_ciphersupported(ah, HAL_CIPHER_AES_OCB))
771                 ic->ic_caps |= IEEE80211_C_AES;
772         if (ath_hal_ciphersupported(ah, HAL_CIPHER_AES_CCM))
773                 ic->ic_caps |= IEEE80211_C_AES_CCM;
774         if (ath_hal_ciphersupported(ah, HAL_CIPHER_CKIP))
775                 ic->ic_caps |= IEEE80211_C_CKIP;
776         if (ath_hal_ciphersupported(ah, HAL_CIPHER_TKIP)) {
777                 ic->ic_caps |= IEEE80211_C_TKIP;
778                 /*
779                  * Check if h/w does the MIC and/or whether the
780                  * separate key cache entries are required to
781                  * handle both tx+rx MIC keys.
782                  */
783                 if (ath_hal_ciphersupported(ah, HAL_CIPHER_MIC)) {
784                         ic->ic_caps |= IEEE80211_C_TKIPMIC;
785                         /*
786                          * Check if h/w does MIC correctly when
787                          * WMM is turned on.
788                          */
789                         if (ath_hal_wmetkipmic(ah))
790                                 ic->ic_caps |= IEEE80211_C_WME_TKIPMIC;
791                 }
792
793                 /*
794                  * If the h/w supports storing tx+rx MIC keys
795                  * in one cache slot automatically enable use.
796                  */
797                 if (ath_hal_hastkipsplit(ah) ||
798                     !ath_hal_settkipsplit(ah, AH_FALSE))
799                         sc->sc_splitmic = 1;
800         }
801         sc->sc_hasclrkey = ath_hal_ciphersupported(ah, HAL_CIPHER_CLR);
802 #if 0
803         sc->sc_mcastkey = ath_hal_getmcastkeysearch(ah);
804 #endif
805         /*
806          * Mark key cache slots associated with global keys
807          * as in use.  If we knew TKIP was not to be used we
808          * could leave the +32, +64, and +32+64 slots free.
809          */
810         for (i = 0; i < IEEE80211_WEP_NKID; i++) {
811                 setbit(sc->sc_keymap, i);
812                 setbit(sc->sc_keymap, i+64);
813                 if (sc->sc_splitmic) {
814                         setbit(sc->sc_keymap, i+32);
815                         setbit(sc->sc_keymap, i+32+64);
816                 }
817         }
818         /*
819          * TPC support can be done either with a global cap or
820          * per-packet support.  The latter is not available on
821          * all parts.  We're a bit pedantic here as all parts
822          * support a global cap.
823          */
824         sc->sc_hastpc = ath_hal_hastpc(ah);
825         if (sc->sc_hastpc || ath_hal_hastxpowlimit(ah))
826                 ic->ic_caps |= IEEE80211_C_TXPMGT;
827
828         /*
829          * Default 11.h to start enabled.
830          */
831         ic->ic_flags |= IEEE80211_F_DOTH;
832         
833         /*
834          * Check for misc other capabilities.
835          */
836         if (ath_hal_hasbursting(ah))
837                 ic->ic_caps |= IEEE80211_C_BURST;
838         sc->sc_hasbmask = ath_hal_hasbssidmask(ah);
839         sc->sc_hastsfadd = ath_hal_hastsfadjust(ah);
840         /*
841          * Indicate we need the 802.11 header padded to a
842          * 32-bit boundary for 4-address and QoS frames.
843          */
844         ic->ic_flags |= IEEE80211_F_DATAPAD;
845
846         /*
847          * Query the HAL about antenna support
848          * Enable rx fast diversity if HAL has support
849          */
850         if (ath_hal_hasdiversity(ah)) {
851                 sc->sc_hasdiversity = 1;
852                 ath_hal_setdiversity(ah, AH_TRUE);
853                 sc->sc_diversity = 1;
854         } else {
855                 sc->sc_hasdiversity = 0;
856                 sc->sc_diversity = 0;
857                 ath_hal_setdiversity(ah, AH_FALSE);
858         }
859         sc->sc_defant = ath_hal_getdefantenna(ah);
860
861         /*
862          * Not all chips have the VEOL support we want to
863          * use with IBSS beacons; check here for it.
864          */
865         sc->sc_hasveol = ath_hal_hasveol(ah);
866
867        /* Interference Mitigation causes problems with recevive sensitivity
868         * for OFDM rates when we are in non-STA modes. We will turn this
869         * capability off in non-STA VAPs
870         */
871         sc->sc_hasintmit = ath_hal_hasintmit(ah);
872         sc->sc_useintmit = 1;
873
874         /* get mac address from hardware */
875         ath_hal_getmac(ah, ic->ic_myaddr);
876         if (sc->sc_hasbmask) {
877                 ath_hal_getbssidmask(ah, sc->sc_bssidmask);
878                 ATH_SET_VAP_BSSID_MASK(sc->sc_bssidmask);
879                 ath_hal_setbssidmask(ah, sc->sc_bssidmask);
880         }
881         IEEE80211_ADDR_COPY(dev->dev_addr, ic->ic_myaddr);
882
883         /* call MI attach routine. */
884         ieee80211_ifattach(ic);
885         /* override default methods */
886         ic->ic_node_alloc = ath_node_alloc;
887         sc->sc_node_free = ic->ic_node_free;
888         ic->ic_node_free = ath_node_free;
889         ic->ic_node_getrssi = ath_node_getrssi;
890 #ifdef ATH_SUPERG_XR
891         ic->ic_node_move_data = ath_node_move_data;
892 #endif
893         sc->sc_node_cleanup = ic->ic_node_cleanup;
894         ic->ic_node_cleanup = ath_node_cleanup;
895         sc->sc_recv_mgmt = ic->ic_recv_mgmt;
896         ic->ic_recv_mgmt = ath_recv_mgmt;
897
898         ic->ic_vap_create = ath_vap_create;
899         ic->ic_vap_delete = ath_vap_delete;
900
901         ic->ic_scan_start = ath_scan_start;
902         ic->ic_scan_end = ath_scan_end;
903         ic->ic_set_channel = ath_set_channel;
904
905         ic->ic_set_coverageclass = ath_set_coverageclass;
906         ic->ic_mhz2ieee = ath_mhz2ieee;
907
908         if (register_netdev(dev)) {
909                 printk(KERN_ERR "%s: unable to register device\n", dev->name);
910                 goto bad3;
911         }
912         /*
913          * Attach dynamic MIB vars and announce support
914          * now that we have a device name with unit number.
915          */
916         ath_dynamic_sysctl_register(sc);
917         ieee80211_announce(ic);
918         ath_announce(dev);
919 #ifdef ATH_TX99_DIAG
920         printk("%s: TX99 support enabled\n", dev->name);
921 #endif
922         sc->sc_invalid = 0;
923
924         if (autocreate) {
925                 if (!strcmp(autocreate, "none"))
926                         autocreatemode = -1;
927                 else if (!strcmp(autocreate, "sta"))
928                         autocreatemode = IEEE80211_M_STA;
929                 else if (!strcmp(autocreate, "ap"))
930                         autocreatemode = IEEE80211_M_HOSTAP;
931                 else if (!strcmp(autocreate, "adhoc"))
932                         autocreatemode = IEEE80211_M_IBSS;
933                 else if (!strcmp(autocreate, "ahdemo"))
934                         autocreatemode = IEEE80211_M_AHDEMO;
935                 else if (!strcmp(autocreate, "wds"))
936                         autocreatemode = IEEE80211_M_WDS;
937                 else if (!strcmp(autocreate, "monitor"))
938                         autocreatemode = IEEE80211_M_MONITOR;
939                 else {
940                         printk(KERN_INFO "Unknown autocreate mode: %s\n",
941                                 autocreate);
942                         autocreatemode = -1;
943                 }
944         }
945         
946         if (autocreatemode != -1) {
947                 rtnl_lock();
948                 error = ieee80211_create_vap(ic, "ath%d", dev,
949                                 autocreatemode, IEEE80211_CLONE_BSSID);
950                 rtnl_unlock();
951                 if (error)
952                         printk(KERN_ERR "%s: autocreation of VAP failed: %d\n",
953                                 dev->name, error);
954         }
955
956         return 0;
957 bad3:
958         ieee80211_ifdetach(ic);
959         ieee80211_rate_detach(sc->sc_rc);
960 bad2:
961         ath_tx_cleanup(sc);
962         ath_desc_free(sc);
963 bad:
964         if (ah)
965                 ath_hal_detach(ah);
966         ATH_TXBUF_LOCK_DESTROY(sc);
967         ATH_LOCK_DESTROY(sc);
968         sc->sc_invalid = 1;
969
970         return error;
971 }
972
973 int
974 ath_detach(struct net_device *dev)
975 {
976         struct ath_softc *sc = netdev_priv(dev);
977         struct ath_hal *ah = sc->sc_ah;
978
979         HAL_INT tmp;
980         DPRINTF(sc, ATH_DEBUG_ANY, "%s: flags %x\n", __func__, dev->flags);
981         ath_stop(dev);
982
983         ath_hal_setpower(sc->sc_ah, HAL_PM_AWAKE);
984         /* Flush the radar task if it's scheduled */
985         if (sc->sc_rtasksched == 1)
986                 flush_scheduled_work();
987
988         sc->sc_invalid = 1;
989
990         /*
991          * NB: the order of these is important:
992          * o call the 802.11 layer before detaching the HAL to
993          *   ensure callbacks into the driver to delete global
994          *   key cache entries can be handled
995          * o reclaim the tx queue data structures after calling
996          *   the 802.11 layer as we'll get called back to reclaim
997          *   node state and potentially want to use them
998          * o to cleanup the tx queues the HAL is called, so detach
999          *   it last
1000          * Other than that, it's straightforward...
1001          */
1002         ieee80211_ifdetach(&sc->sc_ic);
1003
1004         ath_hal_intrset(ah, 0);         /* disable further intr's */
1005         ath_hal_getisr(ah, &tmp);       /* clear ISR */
1006         if(dev->irq) {
1007                 free_irq(dev->irq, dev);
1008                 dev->irq = 0;
1009         }
1010 #ifdef ATH_TX99_DIAG
1011         if (sc->sc_tx99 != NULL)
1012                 sc->sc_tx99->detach(sc->sc_tx99);
1013 #endif
1014         ieee80211_rate_detach(sc->sc_rc);
1015         ath_desc_free(sc);
1016         ath_tx_cleanup(sc);
1017         ath_hal_detach(ah);
1018         kfree(sc->sc_bslot);
1019         sc->sc_bslot = NULL;
1020
1021         ath_dynamic_sysctl_unregister(sc);
1022         ATH_LOCK_DESTROY(sc);
1023         dev->flags &= ~IFF_RUNNING; /* mark as stopped */
1024         unregister_netdev(dev);
1025         return 0;
1026 }
1027
1028 static struct ieee80211vap *
1029 ath_vap_create(struct ieee80211com *ic, const char *name, int unit,
1030         int opmode, int flags, struct net_device *mdev)
1031 {
1032         struct ath_softc *sc = netdev_priv(ic->ic_dev);
1033         struct ath_hal *ah = sc->sc_ah;
1034         struct net_device *dev;
1035         struct ath_vap *avp;
1036         struct ieee80211vap *vap;
1037         int ic_opmode;
1038
1039         if (ic->ic_dev->flags & IFF_RUNNING) {
1040                 /* needs to disable hardware too */
1041                 ath_hal_intrset(ah, 0);         /* disable interrupts */
1042                 ath_draintxq(sc);               /* stop xmit side */
1043                 ath_stoprecv(sc);               /* stop recv side */
1044         }
1045         /* XXX ic unlocked and race against add */
1046         switch (opmode) {
1047         case IEEE80211_M_STA:   /* ap+sta for repeater application */
1048                 if (sc->sc_nstavaps != 0)  /* only one sta regardless */
1049                         return NULL;
1050                 if ((sc->sc_nvaps != 0) && (!(flags & IEEE80211_NO_STABEACONS)))
1051                         return NULL;   /* If using station beacons, must first up */
1052                 if (flags & IEEE80211_NO_STABEACONS) {
1053                         sc->sc_nostabeacons = 1;
1054                         ic_opmode = IEEE80211_M_HOSTAP; /* Run with chip in AP mode */
1055                 } else 
1056                         ic_opmode = opmode;
1057                 break;
1058         case IEEE80211_M_IBSS:
1059                 if (sc->sc_nvaps != 0)          /* only one */
1060                         return NULL;
1061                 ic_opmode = opmode;
1062                 break;
1063         case IEEE80211_M_AHDEMO:
1064         case IEEE80211_M_MONITOR:
1065                 if (sc->sc_nvaps != 0 && ic->ic_opmode != opmode) {
1066                         /* preserve existing mode */
1067                         ic_opmode = ic->ic_opmode;
1068                 } else
1069                         ic_opmode = opmode;
1070                 break;
1071         case IEEE80211_M_HOSTAP:
1072         case IEEE80211_M_WDS:
1073                 /* permit multiple ap's and/or wds links */
1074                 /* XXX sta+ap for repeater/bridge application */
1075                 if ((sc->sc_nvaps != 0) && (ic->ic_opmode == IEEE80211_M_STA))
1076                         return NULL;
1077                 /* XXX not right, beacon buffer is allocated on RUN trans */
1078                 if (opmode == IEEE80211_M_HOSTAP && STAILQ_EMPTY(&sc->sc_bbuf))
1079                         return NULL;
1080                 /*
1081                  * XXX Not sure if this is correct when operating only
1082                  * with WDS links.
1083                  */
1084                 ic_opmode = IEEE80211_M_HOSTAP;
1085
1086                 break;
1087         default:
1088                 return NULL;
1089         }
1090
1091         if (sc->sc_nvaps >= ath_maxvaps) {
1092                 printk(KERN_WARNING "too many virtual ap's (already got %d)\n", sc->sc_nvaps);
1093                 return NULL;
1094         }
1095
1096         dev = alloc_etherdev(sizeof(struct ath_vap) + sc->sc_rc->arc_vap_space);
1097         if (dev == NULL) {
1098                 /* XXX msg */
1099                 return NULL;
1100         }
1101         
1102         avp = netdev_priv(dev);
1103         ieee80211_vap_setup(ic, dev, name, unit, opmode, flags);
1104         /* override with driver methods */
1105         vap = &avp->av_vap;
1106         avp->av_newstate = vap->iv_newstate;
1107         vap->iv_newstate = ath_newstate;
1108         vap->iv_key_alloc = ath_key_alloc;
1109         vap->iv_key_delete = ath_key_delete;
1110         vap->iv_key_set = ath_key_set;
1111         vap->iv_key_update_begin = ath_key_update_begin;
1112         vap->iv_key_update_end = ath_key_update_end;
1113 #ifdef ATH_SUPERG_COMP
1114         vap->iv_comp_set = ath_comp_set;
1115 #endif
1116
1117         /* Let rate control register proc entries for the VAP */
1118         if (sc->sc_rc->ops->dynamic_proc_register)
1119                 sc->sc_rc->ops->dynamic_proc_register(vap);
1120
1121         /*
1122          * Change the interface type for monitor mode.
1123          */
1124         if (opmode == IEEE80211_M_MONITOR)
1125                 dev->type = ARPHRD_IEEE80211_RADIOTAP;
1126         if ((flags & IEEE80211_CLONE_BSSID) &&
1127             sc->sc_nvaps != 0 && opmode != IEEE80211_M_WDS && sc->sc_hasbmask) {
1128                 struct ieee80211vap *v;
1129                 uint64_t id_mask;
1130                 unsigned int id;
1131                 
1132                 /*
1133                  * Hardware supports the bssid mask and a unique
1134                  * bssid was requested.  Assign a new mac address
1135                  * and expand our bssid mask to cover the active
1136                  * virtual ap's with distinct addresses.
1137                  */
1138                 
1139                 /* do a full search to mark all the allocated VAPs */
1140                 id_mask = 0;
1141                 TAILQ_FOREACH(v, &ic->ic_vaps, iv_next)
1142                         id_mask |= (1 << ATH_GET_VAP_ID(v->iv_myaddr));
1143                 
1144                 for (id = 0; id < ath_maxvaps; id++) {
1145                         /* get the first available slot */
1146                         if ((id_mask & (1 << id)) == 0) {
1147                                 ATH_SET_VAP_BSSID(vap->iv_myaddr, id);
1148                                 break;
1149                         }
1150                 }
1151         }
1152         avp->av_bslot = -1;
1153         STAILQ_INIT(&avp->av_mcastq.axq_q);
1154         ATH_TXQ_LOCK_INIT(&avp->av_mcastq);
1155         if (opmode == IEEE80211_M_HOSTAP || opmode == IEEE80211_M_IBSS) {
1156                 /*
1157                  * Allocate beacon state for hostap/ibss.  We know
1158                  * a buffer is available because of the check above.
1159                  */
1160                 avp->av_bcbuf = STAILQ_FIRST(&sc->sc_bbuf);
1161                 STAILQ_REMOVE_HEAD(&sc->sc_bbuf, bf_list);
1162                 if (opmode == IEEE80211_M_HOSTAP || !sc->sc_hasveol) {
1163                         int slot;
1164                         /*
1165                          * Assign the VAP to a beacon xmit slot.  As
1166                          * above, this cannot fail to find one.
1167                          */
1168                         avp->av_bslot = 0;
1169                         for (slot = 0; slot < ath_maxvaps; slot++)
1170                                 if (sc->sc_bslot[slot] == NULL) {
1171                                         /*
1172                                          * XXX hack, space out slots to better
1173                                          * deal with misses
1174                                          */
1175                                         if (slot + 1 < ath_maxvaps &&
1176                                             sc->sc_bslot[slot+1] == NULL) {
1177                                                 avp->av_bslot = slot + 1;
1178                                                 break;
1179                                         }
1180                                         avp->av_bslot = slot;
1181                                         /* NB: keep looking for a double slot */
1182                                 }
1183                         KASSERT(sc->sc_bslot[avp->av_bslot] == NULL,
1184                                 ("beacon slot %u not empty?", avp->av_bslot));
1185                         sc->sc_bslot[avp->av_bslot] = vap;
1186                         sc->sc_nbcnvaps++;
1187                 }
1188                 if ((opmode == IEEE80211_M_HOSTAP) && (sc->sc_hastsfadd)) {
1189                         /*
1190                          * Multiple VAPs are to transmit beacons and we
1191                          * have h/w support for TSF adjusting; enable use
1192                          * of staggered beacons.
1193                          */
1194                         /* XXX check for beacon interval too small */
1195                         if (ath_maxvaps > 4) {
1196                                 DPRINTF(sc, ATH_DEBUG_BEACON,
1197                                         "Staggered beacons are not possible "
1198                                         "with maxvaps set to %d.\n",
1199                                         ath_maxvaps);
1200                                 sc->sc_stagbeacons = 0;
1201                         } else {
1202                                 sc->sc_stagbeacons = 1;
1203                         }
1204                 }
1205                 DPRINTF(sc, ATH_DEBUG_BEACON, "sc->stagbeacons %sabled\n",
1206                         (sc->sc_stagbeacons ? "en" : "dis"));
1207         }
1208         if (sc->sc_hastsfadd)
1209                 ath_hal_settsfadjust(sc->sc_ah, sc->sc_stagbeacons);
1210         SET_NETDEV_DEV(dev, ATH_GET_NETDEV_DEV(mdev));
1211         /* complete setup */
1212         (void) ieee80211_vap_attach(vap,
1213                 ieee80211_media_change, ieee80211_media_status);
1214
1215         ic->ic_opmode = ic_opmode;
1216         
1217         if (opmode != IEEE80211_M_WDS)
1218                 sc->sc_nvaps++;
1219                 
1220         if (opmode == IEEE80211_M_STA)
1221                 sc->sc_nstavaps++;
1222         else if (opmode == IEEE80211_M_MONITOR)
1223                 sc->sc_nmonvaps++;
1224         /*
1225          * Adhoc demo mode is a pseudo mode; to the HAL it's
1226          * just ibss mode and the driver doesn't use management
1227          * frames.  Other modes carry over directly to the HAL.
1228          */
1229         if (ic->ic_opmode == IEEE80211_M_AHDEMO)
1230                 sc->sc_opmode = HAL_M_IBSS;
1231         else
1232                 sc->sc_opmode = (HAL_OPMODE) ic->ic_opmode;     /* NB: compatible */
1233
1234 #ifdef ATH_SUPERG_XR
1235         if ( vap->iv_flags & IEEE80211_F_XR ) {
1236                 if (ath_descdma_setup(sc, &sc->sc_grppolldma, &sc->sc_grppollbuf,
1237                         "grppoll", (sc->sc_xrpollcount+1) * HAL_ANTENNA_MAX_MODE, 1) != 0)
1238                         printk("%s:grppoll Buf allocation failed \n",__func__);
1239                 if (!sc->sc_xrtxq)
1240                         sc->sc_xrtxq = ath_txq_setup(sc, HAL_TX_QUEUE_DATA, HAL_XR_DATA);
1241                 if (sc->sc_hasdiversity) {
1242                         /* Save current diversity state if user destroys XR VAP */
1243                         sc->sc_olddiversity = sc->sc_diversity;
1244                         ath_hal_setdiversity(sc->sc_ah, 0);
1245                         sc->sc_diversity = 0;
1246                 }
1247         }
1248 #endif
1249         if (ic->ic_dev->flags & IFF_RUNNING) {
1250                 /* restart hardware */
1251                 if (ath_startrecv(sc) != 0)     /* restart recv */
1252                         printk("%s: %s: unable to start recv logic\n",
1253                                 dev->name, __func__);
1254                 if (sc->sc_beacons)
1255                         ath_beacon_config(sc, NULL);    /* restart beacons */
1256                 ath_hal_intrset(ah, sc->sc_imask);
1257         }
1258
1259         return vap;
1260 }
1261
1262 static void
1263 ath_vap_delete(struct ieee80211vap *vap)
1264 {
1265         struct net_device *dev = vap->iv_ic->ic_dev;
1266         struct ath_softc *sc = netdev_priv(dev);
1267         struct ath_hal *ah = sc->sc_ah;
1268         struct ath_vap *avp = ATH_VAP(vap);
1269         int decrease = 1;
1270         int i;
1271         KASSERT(vap->iv_state == IEEE80211_S_INIT, ("VAP not stopped"));
1272
1273         if (dev->flags & IFF_RUNNING) {
1274                 /*
1275                  * Quiesce the hardware while we remove the VAP.  In
1276                  * particular we need to reclaim all references to the
1277                  * VAP state by any frames pending on the tx queues.
1278                  *
1279                  * XXX can we do this w/o affecting other VAPs?
1280                  */
1281                 ath_hal_intrset(ah, 0);         /* disable interrupts */
1282                 ath_draintxq(sc);               /* stop xmit side */
1283                 ath_stoprecv(sc);               /* stop recv side */
1284         }
1285
1286         /*
1287          * Reclaim any pending mcast bufs on the VAP.
1288          */
1289         ath_tx_draintxq(sc, &avp->av_mcastq);
1290         ATH_TXQ_LOCK_DESTROY(&avp->av_mcastq);
1291
1292         /*
1293          * Reclaim beacon state.  Note this must be done before
1294          * VAP instance is reclaimed as we may have a reference
1295          * to it in the buffer for the beacon frame.
1296          */
1297         if (avp->av_bcbuf != NULL) {
1298                 if (avp->av_bslot != -1) {
1299                         sc->sc_bslot[avp->av_bslot] = NULL;
1300                         sc->sc_nbcnvaps--;
1301                 }
1302                 ath_beacon_return(sc, avp->av_bcbuf);
1303                 avp->av_bcbuf = NULL;
1304                 if (sc->sc_nbcnvaps == 0)
1305                         sc->sc_stagbeacons = 0;
1306         }
1307         if (vap->iv_opmode == IEEE80211_M_STA) {
1308                 sc->sc_nstavaps--;
1309                 if (sc->sc_nostabeacons)
1310                         sc->sc_nostabeacons = 0;
1311         } else if (vap->iv_opmode == IEEE80211_M_MONITOR) {
1312                 sc->sc_nmonvaps--;
1313         } else if (vap->iv_opmode == IEEE80211_M_WDS) {
1314                 decrease = 0;
1315         }
1316         ieee80211_vap_detach(vap);
1317         /* NB: memory is reclaimed through dev->destructor callback */
1318         if (decrease)
1319                 sc->sc_nvaps--;
1320
1321 #ifdef ATH_SUPERG_XR 
1322         /*
1323          * If it's an XR VAP, free the memory allocated explicitly.
1324          * Since the XR VAP is not registered, OS cannot free the memory.
1325          */
1326         if (vap->iv_flags & IEEE80211_F_XR) {
1327                 ath_grppoll_stop(vap);
1328                 ath_descdma_cleanup(sc, &sc->sc_grppolldma, &sc->sc_grppollbuf, BUS_DMA_FROMDEVICE);
1329                 memset(&sc->sc_grppollbuf, 0, sizeof(sc->sc_grppollbuf));
1330                 memset(&sc->sc_grppolldma, 0, sizeof(sc->sc_grppolldma));
1331                 if (vap->iv_xrvap)
1332                         vap->iv_xrvap->iv_xrvap = NULL;
1333                 kfree(vap->iv_dev);
1334                 ath_tx_cleanupq(sc,sc->sc_xrtxq);
1335                 sc->sc_xrtxq = NULL;
1336                 if (sc->sc_hasdiversity) {
1337                         /* Restore diversity setting to old diversity setting */
1338                         ath_hal_setdiversity(ah, sc->sc_olddiversity);
1339                         sc->sc_diversity = sc->sc_olddiversity;
1340                 }
1341         }
1342 #endif
1343
1344         for (i = 0; i < IEEE80211_APPIE_NUM_OF_FRAME; i++) {
1345                 if (vap->app_ie[i].ie != NULL) {
1346                         FREE(vap->app_ie[i].ie, M_DEVBUF);
1347                         vap->app_ie[i].ie = NULL;
1348                         vap->app_ie[i].length = 0;
1349                 }
1350         }
1351
1352         if (dev->flags & IFF_RUNNING) {
1353                 /*
1354                  * Restart rx+tx machines if device is still running.
1355                  */
1356                 if (ath_startrecv(sc) != 0)     /* restart recv */
1357                         printk("%s: %s: unable to start recv logic\n",
1358                                 dev->name, __func__);
1359                 if (sc->sc_beacons)
1360                         ath_beacon_config(sc, NULL);    /* restart beacons */
1361                 ath_hal_intrset(ah, sc->sc_imask);
1362         }
1363 }
1364
1365 void
1366 ath_suspend(struct net_device *dev)
1367 {
1368         struct ath_softc *sc = netdev_priv(dev);
1369
1370         DPRINTF(sc, ATH_DEBUG_ANY, "%s: flags %x\n", __func__, dev->flags);
1371         ath_stop(dev);
1372 }
1373
1374 void
1375 ath_resume(struct net_device *dev)
1376 {
1377         struct ath_softc *sc = netdev_priv(dev);
1378
1379         DPRINTF(sc, ATH_DEBUG_ANY, "%s: flags %x\n", __func__, dev->flags);
1380         ath_init(dev);
1381 }
1382
1383 static void
1384 ath_uapsd_processtriggers(struct ath_softc *sc)
1385 {
1386         struct ath_hal *ah = sc->sc_ah;
1387         struct ath_buf *bf;
1388         struct ath_desc *ds;
1389         struct sk_buff *skb;
1390         struct ieee80211_node *ni;
1391         struct ath_node *an;
1392         struct ieee80211_qosframe *qwh;
1393         struct ath_txq *uapsd_xmit_q = sc->sc_uapsdq;
1394         struct ieee80211com *ic = &sc->sc_ic;
1395         int ac, retval;
1396         u_int8_t tid;
1397         u_int16_t frame_seq;
1398         u_int64_t tsf;
1399 #define PA2DESC(_sc, _pa) \
1400         ((struct ath_desc *)((caddr_t)(_sc)->sc_rxdma.dd_desc + \
1401                 ((_pa) - (_sc)->sc_rxdma.dd_desc_paddr)))
1402
1403         /* XXXAPSD: build in check against max triggers we could see
1404          *          based on ic->ic_uapsdmaxtriggers.
1405          */
1406
1407         tsf = ath_hal_gettsf64(ah);
1408         ATH_RXBUF_LOCK(sc);
1409         if (sc->sc_rxbufcur == NULL)
1410                 sc->sc_rxbufcur = STAILQ_FIRST(&sc->sc_rxbuf);
1411         for (bf = sc->sc_rxbufcur; bf; bf = STAILQ_NEXT(bf, bf_list)) {
1412                 ds = bf->bf_desc;
1413                 if (ds->ds_link == bf->bf_daddr) {
1414                         /* NB: never process the self-linked entry at the end */
1415                         break;
1416                 }
1417                 if (bf->bf_status & ATH_BUFSTATUS_DONE) {
1418                         /* 
1419                          * already processed this buffer (shouldn't occur if
1420                          * we change code to always process descriptors in
1421                          * rx intr handler - as opposed to sometimes processing
1422                          * in the rx tasklet).
1423                          */
1424                         continue;
1425                 }
1426                 skb = bf->bf_skb;
1427                 if (skb == NULL) {              /* XXX ??? can this happen */
1428                         printk("%s: no skbuff\n", __func__);
1429                         continue;
1430                 }
1431
1432                 /*
1433                  * XXXAPSD: consider new HAL call that does only the subset
1434                  *          of ath_hal_rxprocdesc we require for trigger search.
1435                  */
1436
1437                 /* 
1438                  * NB: descriptor memory doesn't need to be sync'd
1439                  *     due to the way it was allocated. 
1440                  */
1441
1442                 /*
1443                  * Must provide the virtual address of the current
1444                  * descriptor, the physical address, and the virtual
1445                  * address of the next descriptor in the h/w chain.
1446                  * This allows the HAL to look ahead to see if the
1447                  * hardware is done with a descriptor by checking the
1448                  * done bit in the following descriptor and the address
1449                  * of the current descriptor the DMA engine is working
1450                  * on.  All this is necessary because of our use of
1451                  * a self-linked list to avoid rx overruns.
1452                  */
1453                 retval = ath_hal_rxprocdesc(ah, ds, bf->bf_daddr, PA2DESC(sc, ds->ds_link), tsf);
1454                 if (HAL_EINPROGRESS == retval)
1455                         break;
1456
1457                 /* XXX: we do not support frames spanning multiple descriptors */
1458                 bf->bf_status |= ATH_BUFSTATUS_DONE;
1459
1460                 /* errors? */
1461                 if (ds->ds_rxstat.rs_status)
1462                         continue;
1463
1464                 /* prepare wireless header for examination */
1465                 bus_dma_sync_single(sc->sc_bdev, bf->bf_skbaddr, 
1466                                                         sizeof(struct ieee80211_qosframe), 
1467                                                         BUS_DMA_FROMDEVICE);
1468                 qwh = (struct ieee80211_qosframe *) skb->data;
1469
1470                 /* find the node. it MUST be in the keycache. */
1471                 if (ds->ds_rxstat.rs_keyix == HAL_RXKEYIX_INVALID ||
1472                     (ni = sc->sc_keyixmap[ds->ds_rxstat.rs_keyix]) == NULL) {
1473                         /* 
1474                          * XXX: this can occur if WEP mode is used for non-Atheros clients
1475                          *      (since we do not know which of the 4 WEP keys will be used
1476                          *      at association time, so cannot setup a key-cache entry.
1477                          *      The Atheros client can convey this in the Atheros IE.)
1478                          *
1479                          * TODO: The fix is to use the hash lookup on the node here.
1480                          */
1481 #if 0
1482                         /*
1483                          * This print is very chatty, so removing for now.
1484                          */
1485                         DPRINTF(sc, ATH_DEBUG_UAPSD, "%s: U-APSD node (%s) has invalid keycache entry\n",
1486                                 __func__, ether_sprintf(qwh->i_addr2));
1487 #endif
1488                         continue;
1489                 }
1490                 
1491                 if (!(ni->ni_flags & IEEE80211_NODE_UAPSD))
1492                         continue;
1493                 
1494                 /*
1495                  * Must deal with change of state here, since otherwise there would
1496                  * be a race (on two quick frames from STA) between this code and the
1497                  * tasklet where we would:
1498                  *   - miss a trigger on entry to PS if we're already trigger hunting
1499                  *   - generate spurious SP on exit (due to frame following exit frame)
1500                  */
1501                 if (((qwh->i_fc[1] & IEEE80211_FC1_PWR_MGT) ^
1502                      (ni->ni_flags & IEEE80211_NODE_PWR_MGT))) {
1503                         /*
1504                          * NB: do not require lock here since this runs at intr
1505                          * "proper" time and cannot be interrupted by rx tasklet
1506                          * (code there has lock). May want to place a macro here
1507                          * (that does nothing) to make this more clear.
1508                          */
1509                         ni->ni_flags |= IEEE80211_NODE_PS_CHANGED;
1510                         ni->ni_pschangeseq = *(__le16 *)(&qwh->i_seq[0]);
1511                         ni->ni_flags &= ~IEEE80211_NODE_UAPSD_SP;
1512                         ni->ni_flags ^= IEEE80211_NODE_PWR_MGT;
1513                         if (qwh->i_fc[1] & IEEE80211_FC1_PWR_MGT) {
1514                                 ni->ni_flags |= IEEE80211_NODE_UAPSD_TRIG;
1515                                 ic->ic_uapsdmaxtriggers++;
1516                                 WME_UAPSD_NODE_TRIGSEQINIT(ni);
1517                                 DPRINTF(sc, ATH_DEBUG_UAPSD,
1518                                         "%s: Node (%s) became U-APSD triggerable (%d)\n", 
1519                                         __func__, ether_sprintf(qwh->i_addr2),
1520                                         ic->ic_uapsdmaxtriggers);
1521                         } else {
1522                                 ni->ni_flags &= ~IEEE80211_NODE_UAPSD_TRIG;
1523                                 ic->ic_uapsdmaxtriggers--;
1524                                 DPRINTF(sc, ATH_DEBUG_UAPSD,
1525                                         "%s: Node (%s) no longer U-APSD triggerable (%d)\n", 
1526                                         __func__, ether_sprintf(qwh->i_addr2),
1527                                         ic->ic_uapsdmaxtriggers);
1528                                 /* 
1529                                  * XXX: rapidly thrashing sta could get 
1530                                  * out-of-order frames due this flush placing
1531                                  * frames on backlogged regular AC queue and
1532                                  * re-entry to PS having fresh arrivals onto
1533                                  * faster UPSD delivery queue. if this is a
1534                                  * big problem we may need to drop these.
1535                                  */
1536                                 ath_uapsd_flush(ni);
1537                         }
1538                         
1539                         continue;
1540                 }
1541
1542                 if (ic->ic_uapsdmaxtriggers == 0)
1543                         continue;
1544                 
1545                 /* make sure the frame is QoS data/null */
1546                 /* NB: with current sub-type definitions, the 
1547                  * IEEE80211_FC0_SUBTYPE_QOS check, below, covers the 
1548                  * QoS null case too.
1549                  */
1550                 if (((qwh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_DATA) ||
1551                      !(qwh->i_fc[0] & IEEE80211_FC0_SUBTYPE_QOS))
1552                         continue;
1553                 
1554                 /*
1555                  * To be a trigger:
1556                  *   - node is in triggerable state
1557                  *   - QoS data/null frame with triggerable AC
1558                  */
1559                 tid = qwh->i_qos[0] & IEEE80211_QOS_TID;
1560                 ac = TID_TO_WME_AC(tid);
1561                 if (!WME_UAPSD_AC_CAN_TRIGGER(ac, ni))
1562                         continue;
1563                 
1564                 DPRINTF(sc, ATH_DEBUG_UAPSD, 
1565                         "%s: U-APSD trigger detected for node (%s) on AC %d\n",
1566                         __func__, ether_sprintf(ni->ni_macaddr), ac);
1567                 if (ni->ni_flags & IEEE80211_NODE_UAPSD_SP) {
1568                         /* have trigger, but SP in progress, so ignore */
1569                         DPRINTF(sc, ATH_DEBUG_UAPSD,
1570                                 "%s:   SP already in progress - ignoring\n",
1571                                 __func__);
1572                         continue;
1573                 }
1574
1575                 /*
1576                  * Detect duplicate triggers and drop if so.
1577                  */
1578                 frame_seq = le16toh(*(__le16 *)qwh->i_seq);
1579                 if ((qwh->i_fc[1] & IEEE80211_FC1_RETRY) &&
1580                     frame_seq == ni->ni_uapsd_trigseq[ac]) {
1581                         DPRINTF(sc, ATH_DEBUG_UAPSD, "%s: dropped dup trigger, ac %d, seq %d\n",
1582                                 __func__, ac, frame_seq);
1583                         continue;
1584                 }
1585
1586                 an = ATH_NODE(ni);
1587
1588                 /* start the SP */
1589                 ATH_NODE_UAPSD_LOCK(an);
1590                 ni->ni_stats.ns_uapsd_triggers++;
1591                 ni->ni_flags |= IEEE80211_NODE_UAPSD_SP;
1592                 ni->ni_uapsd_trigseq[ac] = frame_seq;
1593                 ATH_NODE_UAPSD_UNLOCK(an);
1594
1595                 ATH_TXQ_LOCK(uapsd_xmit_q);
1596                 if (STAILQ_EMPTY(&an->an_uapsd_q)) {
1597                         DPRINTF(sc, ATH_DEBUG_UAPSD,
1598                                 "%s: Queue empty, generating QoS NULL to send\n",
1599                                 __func__);
1600                         /* 
1601                          * Empty queue, so need to send QoS null on this ac. Make a
1602                          * call that will dump a QoS null onto the node's queue, then
1603                          * we can proceed as normal.
1604                          */
1605                         ieee80211_send_qosnulldata(ni, ac);
1606                 }
1607
1608                 if (STAILQ_FIRST(&an->an_uapsd_q)) {
1609                         struct ath_buf *last_buf = STAILQ_LAST(&an->an_uapsd_q, ath_buf, bf_list);
1610                         struct ath_desc *last_desc = last_buf->bf_desc;
1611                         struct ieee80211_qosframe *qwhl = (struct ieee80211_qosframe *)last_buf->bf_skb->data;
1612                         /* 
1613                          * NB: flip the bit to cause intr on the EOSP desc,
1614                          * which is the last one
1615                          */
1616                         ath_hal_txreqintrdesc(sc->sc_ah, last_desc);
1617                         qwhl->i_qos[0] |= IEEE80211_QOS_EOSP;
1618
1619                         if (IEEE80211_VAP_EOSPDROP_ENABLED(ni->ni_vap)) {
1620                                 /* simulate lost EOSP */
1621                                 qwhl->i_addr1[0] |= 0x40;
1622                         }
1623                         
1624                         /* more data bit only for EOSP frame */
1625                         if (an->an_uapsd_overflowqdepth)
1626                                 qwhl->i_fc[1] |= IEEE80211_FC1_MORE_DATA;
1627                         else if (IEEE80211_NODE_UAPSD_USETIM(ni))
1628                                 ni->ni_vap->iv_set_tim(ni, 0);
1629
1630                         ni->ni_stats.ns_tx_uapsd += an->an_uapsd_qdepth;
1631
1632                         bus_dma_sync_single(sc->sc_bdev, last_buf->bf_skbaddr,
1633                                 sizeof(*qwhl), BUS_DMA_TODEVICE);
1634                         
1635                         if (uapsd_xmit_q->axq_link) {
1636 #ifdef AH_NEED_DESC_SWAP
1637                                 *uapsd_xmit_q->axq_link = cpu_to_le32(STAILQ_FIRST(&an->an_uapsd_q)->bf_daddr);
1638 #else
1639                                 *uapsd_xmit_q->axq_link = STAILQ_FIRST(&an->an_uapsd_q)->bf_daddr;
1640 #endif
1641                         }
1642                         /* below leaves an_uapsd_q NULL */
1643                         STAILQ_CONCAT(&uapsd_xmit_q->axq_q, &an->an_uapsd_q);
1644                         uapsd_xmit_q->axq_link = &last_desc->ds_link;
1645                         ath_hal_puttxbuf(sc->sc_ah, 
1646                                 uapsd_xmit_q->axq_qnum, 
1647                                 (STAILQ_FIRST(&uapsd_xmit_q->axq_q))->bf_daddr);
1648                         ath_hal_txstart(sc->sc_ah, uapsd_xmit_q->axq_qnum);
1649                 }
1650                 an->an_uapsd_qdepth = 0;
1651
1652                 ATH_TXQ_UNLOCK(uapsd_xmit_q);
1653         }
1654         sc->sc_rxbufcur = bf;
1655         ATH_RXBUF_UNLOCK(sc);
1656 #undef PA2DESC
1657 }
1658
1659 /*
1660  * Interrupt handler.  Most of the actual processing is deferred.
1661  */
1662 irqreturn_t
1663 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
1664 ath_intr(int irq, void *dev_id)
1665 #else
1666 ath_intr(int irq, void *dev_id, struct pt_regs *regs)
1667 #endif
1668 {
1669         struct net_device *dev = dev_id;
1670         struct ath_softc *sc = netdev_priv(dev);
1671         struct ath_hal *ah = sc->sc_ah;
1672         HAL_INT status;
1673         int needmark;
1674
1675         if (sc->sc_invalid) {
1676                 /*
1677                  * The hardware is not ready/present, don't touch anything.
1678                  * Note this can happen early on if the IRQ is shared.
1679                  */
1680                 return IRQ_NONE;
1681         }
1682         if (!ath_hal_intrpend(ah))              /* shared irq, not for us */
1683                 return IRQ_NONE;
1684         if ((dev->flags & (IFF_RUNNING | IFF_UP)) != (IFF_RUNNING | IFF_UP)) {
1685                 DPRINTF(sc, ATH_DEBUG_INTR, "%s: flags 0x%x\n",
1686                         __func__, dev->flags);
1687                 ath_hal_getisr(ah, &status);    /* clear ISR */
1688                 ath_hal_intrset(ah, 0);         /* disable further intr's */
1689                 return IRQ_HANDLED;
1690         }
1691         needmark = 0;
1692         /*
1693          * Figure out the reason(s) for the interrupt.  Note
1694          * that the HAL returns a pseudo-ISR that may include
1695          * bits we haven't explicitly enabled so we mask the
1696          * value to ensure we only process bits we requested.
1697          */
1698         ath_hal_getisr(ah, &status);            /* NB: clears ISR too */
1699         DPRINTF(sc, ATH_DEBUG_INTR, "%s: status 0x%x\n", __func__, status);
1700         status &= sc->sc_imask;                 /* discard unasked for bits */
1701         if (status & HAL_INT_FATAL) {
1702                 sc->sc_stats.ast_hardware++;
1703                 ath_hal_intrset(ah, 0);         /* disable intr's until reset */
1704                 ATH_SCHEDULE_TQUEUE(&sc->sc_fataltq, &needmark);
1705         } else if (status & HAL_INT_RXORN) {
1706                 sc->sc_stats.ast_rxorn++;
1707                 ath_hal_intrset(ah, 0);         /* disable intr's until reset */
1708                 ATH_SCHEDULE_TQUEUE(&sc->sc_rxorntq, &needmark);
1709         } else {
1710                 if (status & HAL_INT_SWBA) {
1711                         /*
1712                          * Software beacon alert--time to send a beacon.
1713                          * Handle beacon transmission directly; deferring
1714                          * this is too slow to meet timing constraints
1715                          * under load.
1716                          */
1717                         ath_beacon_send(sc, &needmark);
1718                 }
1719                 if (status & HAL_INT_RXEOL) {
1720                         /*
1721                          * NB: the hardware should re-read the link when
1722                          *     RXE bit is written, but it doesn't work at
1723                          *     least on older hardware revs.
1724                          */
1725                         sc->sc_stats.ast_rxeol++;
1726                 }
1727                 if (status & HAL_INT_TXURN) {
1728                         sc->sc_stats.ast_txurn++;
1729                         /* bump tx trigger level */
1730                         ath_hal_updatetxtriglevel(ah, AH_TRUE);
1731                 }
1732                 if (status & HAL_INT_RX) {
1733                         ath_uapsd_processtriggers(sc);
1734                         /* Get the noise floor data in interrupt context as we can't get it
1735                          * per frame, so we need to get it as soon as possible (i.e. the tasklet
1736                          * might take too long to fire */
1737                         ath_hal_process_noisefloor(ah);
1738                         sc->sc_channoise = ath_hal_get_channel_noise(ah, &(sc->sc_curchan));
1739                         ATH_SCHEDULE_TQUEUE(&sc->sc_rxtq, &needmark);
1740                 }
1741                 if (status & HAL_INT_TX) {
1742 #ifdef ATH_SUPERG_DYNTURBO
1743                         /*
1744                          * Check if the beacon queue caused the interrupt 
1745                          * when a dynamic turbo switch
1746                          * is pending so we can initiate the change. 
1747                          * XXX must wait for all VAPs' beacons
1748                          */
1749
1750                         if (sc->sc_dturbo_switch) {
1751                                 u_int32_t txqs = (1 << sc->sc_bhalq);
1752                                 ath_hal_gettxintrtxqs(ah, &txqs);
1753                                 if(txqs & (1 << sc->sc_bhalq)) {
1754                                         sc->sc_dturbo_switch = 0;
1755                                         /*
1756                                          * Hack: defer switch for 10ms to permit slow
1757                                          * clients time to track us.  This especially
1758                                          * noticeable with Windows clients.
1759                                          */
1760                                         mod_timer(&sc->sc_dturbo_switch_mode,
1761                                                           jiffies + msecs_to_jiffies(10));
1762                                 }
1763                         } 
1764 #endif
1765                         ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, &needmark);
1766                 }
1767                 if (status & HAL_INT_BMISS) {
1768                         sc->sc_stats.ast_bmiss++;
1769                         ATH_SCHEDULE_TQUEUE(&sc->sc_bmisstq, &needmark);
1770                 }
1771                 if (status & HAL_INT_MIB) {
1772                         sc->sc_stats.ast_mib++;
1773                         /*
1774                          * Disable interrupts until we service the MIB
1775                          * interrupt; otherwise it will continue to fire.
1776                          */
1777                         ath_hal_intrset(ah, 0);
1778                         /*
1779                          * Let the HAL handle the event.  We assume it will
1780                          * clear whatever condition caused the interrupt.
1781                          */
1782                         ath_hal_mibevent(ah, &sc->sc_halstats);
1783                         ath_hal_intrset(ah, sc->sc_imask);
1784                 }
1785         }
1786         if (needmark)
1787                 mark_bh(IMMEDIATE_BH);
1788         return IRQ_HANDLED;
1789 }
1790
1791 static void
1792 ath_radar_task(struct work_struct *thr)
1793 {
1794         struct ath_softc *sc = container_of(thr, struct ath_softc, sc_radartask);
1795         struct ath_hal *ah = sc->sc_ah;
1796         struct ieee80211com *ic = &sc->sc_ic;
1797         struct ieee80211_channel ichan;
1798         HAL_CHANNEL hchan;
1799
1800         sc->sc_rtasksched = 0;
1801         if (ath_hal_procdfs(ah, &hchan)) {
1802                 /*
1803                  * DFS was found, initiate channel change
1804                  */
1805                 ichan.ic_ieee = ath_hal_mhz2ieee(ah, hchan.channel, hchan.channelFlags);
1806                 ichan.ic_freq = hchan.channel;
1807                 ichan.ic_flags = hchan.channelFlags;
1808
1809                 if ((sc->sc_curchan.channel == hchan.channel) &&
1810                     (sc->sc_curchan.channelFlags == hchan.channel)) {
1811                         if (hchan.privFlags & CHANNEL_INTERFERENCE)
1812                                 sc->sc_curchan.privFlags |= CHANNEL_INTERFERENCE;
1813                 }
1814                 ieee80211_mark_dfs(ic, &ichan);
1815                 if (((ic->ic_flags_ext & IEEE80211_FEXT_MARKDFS) == 0) &&
1816                     (ic->ic_opmode == IEEE80211_M_HOSTAP)) {
1817                         sc->sc_dfstest_ieeechan = ic->ic_curchan->ic_ieee;
1818                         sc->sc_dfstesttimer.function = ath_dfs_test_return;
1819                         sc->sc_dfstesttimer.expires = jiffies + (sc->sc_dfstesttime * HZ);
1820                         sc->sc_dfstesttimer.data = (unsigned long)sc;
1821                         if (sc->sc_dfstest == 0) {
1822                                 sc->sc_dfstest = 1;
1823                                 add_timer(&sc->sc_dfstesttimer);
1824                         }
1825                 }
1826         }
1827 }
1828
1829 static void
1830 ath_dfs_test_return(unsigned long data)
1831 {
1832         struct ath_softc *sc = (struct ath_softc *)data; 
1833         struct ieee80211com *ic = &sc->sc_ic;
1834
1835         sc->sc_dfstest = 0;
1836         ieee80211_dfs_test_return(ic, sc->sc_dfstest_ieeechan);
1837 }
1838
1839 static void
1840 ath_fatal_tasklet(TQUEUE_ARG data)
1841 {
1842         struct net_device *dev = (struct net_device *)data;
1843
1844         printk("%s: hardware error; resetting\n", dev->name);
1845         ath_reset(dev);
1846 }
1847
1848 static void
1849 ath_rxorn_tasklet(TQUEUE_ARG data)
1850 {
1851         struct net_device *dev = (struct net_device *)data;
1852
1853         printk("%s: rx FIFO overrun; resetting\n", dev->name);
1854         ath_reset(dev);
1855 }
1856
1857 static void
1858 ath_bmiss_tasklet(TQUEUE_ARG data)
1859 {
1860         struct net_device *dev = (struct net_device *)data;
1861         struct ath_softc *sc = netdev_priv(dev);
1862
1863         if (time_before(jiffies, sc->sc_ic.ic_bmiss_guard)) {
1864                 /* Beacon miss interrupt occured too short after last beacon
1865                  * timer configuration. Ignore it as it could be spurious. */
1866                 DPRINTF(sc, ATH_DEBUG_ANY, "%s: ignored\n", __func__);
1867         } else {
1868                 DPRINTF(sc, ATH_DEBUG_ANY, "%s\n", __func__);
1869                 ieee80211_beacon_miss(&sc->sc_ic);
1870         }
1871 }
1872
1873 static u_int
1874 ath_chan2flags(struct ieee80211_channel *chan)
1875 {
1876         u_int flags;
1877         static const u_int modeflags[] = {
1878                 0,              /* IEEE80211_MODE_AUTO    */
1879                 CHANNEL_A,      /* IEEE80211_MODE_11A     */
1880                 CHANNEL_B,      /* IEEE80211_MODE_11B     */
1881                 CHANNEL_PUREG,  /* IEEE80211_MODE_11G     */
1882                 0,              /* IEEE80211_MODE_FH      */
1883                 CHANNEL_108A,   /* IEEE80211_MODE_TURBO_A */
1884                 CHANNEL_108G,   /* IEEE80211_MODE_TURBO_G */
1885         };
1886
1887         flags = modeflags[ieee80211_chan2mode(chan)];
1888
1889         if (IEEE80211_IS_CHAN_HALF(chan))
1890                 flags |= CHANNEL_HALF;
1891         else if (IEEE80211_IS_CHAN_QUARTER(chan))
1892                 flags |= CHANNEL_QUARTER;
1893
1894         return flags;
1895 }
1896
1897 /*
1898  * Context: process context
1899  */
1900
1901 static int
1902 ath_init(struct net_device *dev)
1903 {
1904         struct ath_softc *sc = netdev_priv(dev);
1905         struct ieee80211com *ic = &sc->sc_ic;
1906         struct ath_hal *ah = sc->sc_ah;
1907         HAL_STATUS status;
1908         int error = 0;
1909
1910         ATH_LOCK(sc);
1911
1912         DPRINTF(sc, ATH_DEBUG_RESET, "%s: mode %d\n", __func__, ic->ic_opmode);
1913
1914         /*
1915          * Stop anything previously setup.  This is safe
1916          * whether this is the first time through or not.
1917          */
1918         ath_stop_locked(dev);
1919
1920 #ifdef ATH_CAP_TPC
1921         ath_hal_setcapability(sc->sc_ah, HAL_CAP_TPC, 0, 1, NULL);
1922 #endif
1923
1924         /* Whether we should enable h/w TKIP MIC */
1925         if ((ic->ic_caps & IEEE80211_C_WME) == 0)
1926                 ath_hal_setcapability(sc->sc_ah, HAL_CAP_TKIP_MIC, 0, 0, NULL);
1927         else {
1928                 if (((ic->ic_caps & IEEE80211_C_WME_TKIPMIC) == 0) &&
1929                     (ic->ic_flags & IEEE80211_F_WME))
1930                         ath_hal_setcapability(sc->sc_ah, HAL_CAP_TKIP_MIC, 0, 0, NULL);
1931                 else
1932                         ath_hal_setcapability(sc->sc_ah, HAL_CAP_TKIP_MIC, 0, 1, NULL);
1933         }
1934                 
1935         /*
1936          * Flush the skb's allocated for receive in case the rx
1937          * buffer size changes.  This could be optimized but for
1938          * now we do it each time under the assumption it does
1939          * not happen often.
1940          */
1941         ath_flushrecv(sc);
1942
1943         /*
1944          * The basic interface to setting the hardware in a good
1945          * state is ``reset''.  On return the hardware is known to
1946          * be powered up and with interrupts disabled.  This must
1947          * be followed by initialization of the appropriate bits
1948          * and then setup of the interrupt mask.
1949          */
1950         sc->sc_curchan.channel = ic->ic_curchan->ic_freq;
1951         sc->sc_curchan.channelFlags = ath_chan2flags(ic->ic_curchan);
1952         if (!ath_hal_reset(ah, sc->sc_opmode, &sc->sc_curchan, AH_FALSE, &status)) {
1953                 printk("%s: unable to reset hardware: '%s' (HAL status %u) "
1954                         "(freq %u flags 0x%x)\n", dev->name,
1955                         ath_get_hal_status_desc(status), status,
1956                         sc->sc_curchan.channel, sc->sc_curchan.channelFlags);
1957                 error = -EIO;
1958                 goto done;
1959         }
1960
1961         if (sc->sc_softled)
1962                 ath_hal_gpioCfgOutput(ah, sc->sc_ledpin);
1963
1964         /* Turn off Interference Mitigation in non-STA modes */
1965         if ((sc->sc_opmode != HAL_M_STA) && sc->sc_hasintmit && !sc->sc_useintmit) {
1966                 DPRINTF(sc, ATH_DEBUG_RESET,
1967                         "%s: disabling interference mitigation (ANI)\n", __func__);
1968                 ath_hal_setintmit(ah, 0);
1969         }
1970
1971         /*
1972          * This is needed only to setup initial state
1973          * but it's best done after a reset.
1974          */
1975         ath_update_txpow(sc);
1976
1977         /* Set the default RX antenna; it may get lost on reset. */
1978         ath_setdefantenna(sc, sc->sc_defant);
1979
1980         /*
1981          * Setup the hardware after reset: the key cache
1982          * is filled as needed and the receive engine is
1983          * set going.  Frame transmit is handled entirely
1984          * in the frame output path; there's nothing to do
1985          * here except setup the interrupt mask.
1986          */
1987 #if 0
1988         ath_initkeytable(sc);           /* XXX still needed? */
1989 #endif
1990         if (ath_startrecv(sc) != 0) {
1991                 printk("%s: unable to start recv logic\n", dev->name);
1992                 error = -EIO;
1993                 goto done;
1994         }
1995         /* Enable interrupts. */
1996         sc->sc_imask = HAL_INT_RX | HAL_INT_TX
1997                   | HAL_INT_RXEOL | HAL_INT_RXORN
1998                   | HAL_INT_FATAL | HAL_INT_GLOBAL;
1999         /*
2000          * Enable MIB interrupts when there are hardware phy counters.
2001          * Note we only do this (at the moment) for station mode.
2002          */
2003         if (sc->sc_needmib && ic->ic_opmode == IEEE80211_M_STA)
2004                 sc->sc_imask |= HAL_INT_MIB;
2005         ath_hal_intrset(ah, sc->sc_imask);
2006
2007         /*
2008          * The hardware should be ready to go now so it's safe
2009          * to kick the 802.11 state machine as it's likely to
2010          * immediately call back to us to send mgmt frames.
2011          */
2012         ath_chan_change(sc, ic->ic_curchan);
2013         ath_set_ack_bitrate(sc, sc->sc_ackrate);
2014         dev->flags |= IFF_RUNNING;              /* we are ready to go */
2015         ieee80211_start_running(ic);            /* start all VAPs */
2016 #ifdef ATH_TX99_DIAG
2017         if (sc->sc_tx99 != NULL)
2018                 sc->sc_tx99->start(sc->sc_tx99);
2019 #endif
2020 done:
2021         ATH_UNLOCK(sc);
2022         return error;
2023 }
2024
2025 /* Caller must lock ATH_LOCK 
2026  *
2027  * Context: softIRQ
2028  */ 
2029 static int
2030 ath_stop_locked(struct net_device *dev)
2031 {
2032         struct ath_softc *sc = netdev_priv(dev);
2033         struct ieee80211com *ic = &sc->sc_ic;
2034         struct ath_hal *ah = sc->sc_ah;
2035
2036         DPRINTF(sc, ATH_DEBUG_RESET, "%s: invalid %u flags 0x%x\n",
2037                 __func__, sc->sc_invalid, dev->flags);
2038
2039         if (dev->flags & IFF_RUNNING) {
2040                 /*
2041                  * Shutdown the hardware and driver:
2042                  *    stop output from above
2043                  *    reset 802.11 state machine
2044                  *      (sends station deassoc/deauth frames)
2045                  *    turn off timers
2046                  *    disable interrupts
2047                  *    clear transmit machinery
2048                  *    clear receive machinery
2049                  *    turn off the radio
2050                  *    reclaim beacon resources
2051                  *
2052                  * Note that some of this work is not possible if the
2053                  * hardware is gone (invalid).
2054                  */
2055 #ifdef ATH_TX99_DIAG
2056                 if (sc->sc_tx99 != NULL)
2057                         sc->sc_tx99->stop(sc->sc_tx99);
2058 #endif
2059                 netif_stop_queue(dev);          /* XXX re-enabled by ath_newstate */
2060                 dev->flags &= ~IFF_RUNNING;     /* NB: avoid recursion */
2061                 ieee80211_stop_running(ic);     /* stop all VAPs */
2062                 if (!sc->sc_invalid) {
2063                         ath_hal_intrset(ah, 0);
2064                         if (sc->sc_softled) {
2065                                 del_timer(&sc->sc_ledtimer);
2066                                 ath_hal_gpioset(ah, sc->sc_ledpin, !sc->sc_ledon);
2067                                 sc->sc_blinking = 0;
2068                                 sc->sc_ledstate = 1;
2069                         }
2070                 }
2071                 ath_draintxq(sc);
2072                 if (!sc->sc_invalid) {
2073                         ath_stoprecv(sc);
2074                         ath_hal_phydisable(ah);
2075                 } else
2076                         sc->sc_rxlink = NULL;
2077                 ath_beacon_free(sc);            /* XXX needed? */
2078         } else
2079                 ieee80211_stop_running(ic);     /* stop other VAPs */
2080
2081         if (sc->sc_softled)
2082                 ath_hal_gpioset(ah, sc->sc_ledpin, !sc->sc_ledon);
2083         
2084         return 0;
2085 }
2086
2087 /*
2088  * Stop the device, grabbing the top-level lock to protect
2089  * against concurrent entry through ath_init (which can happen
2090  * if another thread does a system call and the thread doing the
2091  * stop is preempted).
2092  */
2093 static int
2094 ath_stop(struct net_device *dev)
2095 {
2096         struct ath_softc *sc = netdev_priv(dev);
2097         int error;
2098
2099         ATH_LOCK(sc);
2100
2101         if (!sc->sc_invalid)
2102                 ath_hal_setpower(sc->sc_ah, HAL_PM_AWAKE);
2103
2104         error = ath_stop_locked(dev);
2105 #if 0
2106         if (error == 0 && !sc->sc_invalid) {
2107                 /*
2108                  * Set the chip in full sleep mode.  Note that we are
2109                  * careful to do this only when bringing the interface
2110                  * completely to a stop.  When the chip is in this state
2111                  * it must be carefully woken up or references to
2112                  * registers in the PCI clock domain may freeze the bus
2113                  * (and system).  This varies by chip and is mostly an
2114                  * issue with newer parts that go to sleep more quickly.
2115                  */
2116                 ath_hal_setpower(sc->sc_ah, HAL_PM_FULL_SLEEP);
2117         }
2118 #endif
2119         ATH_UNLOCK(sc);
2120
2121         return error;
2122 }
2123
2124 static int 
2125 ar_device(int devid)
2126 {
2127         switch (devid) {
2128         case AR5210_DEFAULT:
2129         case AR5210_PROD:
2130         case AR5210_AP:
2131                 return 5210;
2132         case AR5211_DEFAULT:
2133         case AR5311_DEVID:
2134         case AR5211_LEGACY:
2135         case AR5211_FPGA11B:
2136                 return 5211;
2137         case AR5212_DEFAULT:
2138         case AR5212_DEVID:
2139         case AR5212_FPGA:
2140         case AR5212_DEVID_IBM:
2141         case AR5212_AR5312_REV2:
2142         case AR5212_AR5312_REV7:
2143         case AR5212_AR2313_REV8:
2144         case AR5212_AR2315_REV6:
2145         case AR5212_AR2315_REV7:
2146         case AR5212_AR2317_REV1:
2147         case AR5212_DEVID_0014:
2148         case AR5212_DEVID_0015:
2149         case AR5212_DEVID_0016:
2150         case AR5212_DEVID_0017:
2151         case AR5212_DEVID_0018:
2152         case AR5212_DEVID_0019:
2153         case AR5212_AR2413:
2154         case AR5212_AR5413:
2155         case AR5212_AR5424:
2156         case AR5212_DEVID_FF19:
2157                 return 5212;
2158         case AR5213_SREV_1_0:
2159         case AR5213_SREV_REG:
2160         case AR_SUBVENDOR_ID_NOG:
2161         case AR_SUBVENDOR_ID_NEW_A:
2162                 return 5213;
2163         default: 
2164                 return 0; /* unknown */
2165         }
2166 }
2167
2168
2169 static int 
2170 ath_set_ack_bitrate(struct ath_softc *sc, int high) 
2171 {
2172         struct ath_hal *ah = sc->sc_ah;
2173         if (ar_device(sc->devid) == 5212 || ar_device(sc->devid) == 5213) {
2174                 /* set ack to be sent at low bit-rate */
2175                 /* registers taken from the OpenBSD 5212 HAL */
2176 #define AR5K_AR5212_STA_ID1                     0x8004
2177 #define AR5K_AR5212_STA_ID1_ACKCTS_6MB          0x01000000
2178 #define AR5K_AR5212_STA_ID1_BASE_RATE_11B       0x02000000
2179                 u_int32_t v = AR5K_AR5212_STA_ID1_BASE_RATE_11B | AR5K_AR5212_STA_ID1_ACKCTS_6MB;
2180                 if (high) {
2181                         OS_REG_WRITE(ah, AR5K_AR5212_STA_ID1, OS_REG_READ(ah, AR5K_AR5212_STA_ID1) & ~v);
2182                 } else {
2183                         OS_REG_WRITE(ah, AR5K_AR5212_STA_ID1, OS_REG_READ(ah, AR5K_AR5212_STA_ID1) | v);
2184                 }
2185                 return 0;
2186         }
2187         return 1;
2188 }
2189
2190 /*
2191  * Reset the hardware w/o losing operational state.  This is
2192  * basically a more efficient way of doing ath_stop, ath_init,
2193  * followed by state transitions to the current 802.11
2194  * operational state.  Used to recover from errors rx overrun
2195  * and to reset the hardware when rf gain settings must be reset.
2196  */
2197 static int
2198 ath_reset(struct net_device *dev)
2199 {
2200         struct ath_softc *sc = netdev_priv(dev);
2201         struct ieee80211com *ic = &sc->sc_ic;
2202         struct ath_hal *ah = sc->sc_ah;
2203         struct ieee80211_channel *c;
2204         HAL_STATUS status;
2205
2206         /*
2207          * Convert to a HAL channel description with the flags
2208          * constrained to reflect the current operating mode.
2209          */
2210         c = ic->ic_curchan;
2211         sc->sc_curchan.channel = c->ic_freq;
2212         sc->sc_curchan.channelFlags = ath_chan2flags(c);
2213
2214         ath_hal_intrset(ah, 0);         /* disable interrupts */
2215         ath_draintxq(sc);               /* stop xmit side */
2216         ath_stoprecv(sc);               /* stop recv side */
2217         /* NB: indicate channel change so we do a full reset */
2218         if (!ath_hal_reset(ah, sc->sc_opmode, &sc->sc_curchan, AH_TRUE, &status))
2219                 printk("%s: %s: unable to reset hardware: '%s' (HAL status %u)\n",
2220                         dev->name, __func__, ath_get_hal_status_desc(status), status);
2221
2222         /* Turn off Interference Mitigation in non-STA modes */
2223         if ((sc->sc_opmode != HAL_M_STA) && sc->sc_hasintmit && !sc->sc_useintmit) {
2224                 DPRINTF(sc, ATH_DEBUG_RESET,
2225                         "%s: disabling interference mitigation (ANI)\n", __func__);
2226                 ath_hal_setintmit(ah, 0);
2227         }
2228
2229         ath_update_txpow(sc);           /* update tx power state */
2230         if (ath_startrecv(sc) != 0)     /* restart recv */
2231                 printk("%s: %s: unable to start recv logic\n",
2232                         dev->name, __func__);
2233         if (sc->sc_softled)
2234                 ath_hal_gpioCfgOutput(ah, sc->sc_ledpin);
2235
2236         /*
2237          * We may be doing a reset in response to an ioctl
2238          * that changes the channel so update any state that
2239          * might change as a result.
2240          */
2241         ath_chan_change(sc, c);
2242         if (sc->sc_beacons)
2243                 ath_beacon_config(sc, NULL);    /* restart beacons */
2244         ath_hal_intrset(ah, sc->sc_imask);
2245         ath_set_ack_bitrate(sc, sc->sc_ackrate);
2246         netif_wake_queue(dev);          /* restart xmit */
2247 #ifdef ATH_SUPERG_XR
2248         /*
2249          * restart the group polls.
2250          */
2251         if (sc->sc_xrgrppoll) {
2252                 struct ieee80211vap *vap;
2253                 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
2254                         if (vap && (vap->iv_flags & IEEE80211_F_XR))
2255                                 break;
2256                 ath_grppoll_stop(vap);
2257                 ath_grppoll_start(vap, sc->sc_xrpollcount);
2258         }
2259 #endif
2260         return 0;
2261 }
2262
2263
2264 /* Swap transmit descriptor.
2265  * if AH_NEED_DESC_SWAP flag is not defined this becomes a "null"
2266  * function.
2267  */
2268 static __inline void
2269 ath_desc_swap(struct ath_desc *ds)
2270 {
2271 #ifdef AH_NEED_DESC_SWAP
2272         ds->ds_link = cpu_to_le32(ds->ds_link);
2273         ds->ds_data = cpu_to_le32(ds->ds_data);
2274         ds->ds_ctl0 = cpu_to_le32(ds->ds_ctl0);
2275         ds->ds_ctl1 = cpu_to_le32(ds->ds_ctl1);
2276         ds->ds_hw[0] = cpu_to_le32(ds->ds_hw[0]);
2277         ds->ds_hw[1] = cpu_to_le32(ds->ds_hw[1]);
2278 #endif
2279 }
2280
2281 /*
2282  * Insert a buffer on a txq 
2283  * 
2284  */
2285 static __inline void
2286 ath_tx_txqaddbuf(struct ath_softc *sc, struct ieee80211_node *ni, 
2287         struct ath_txq *txq, struct ath_buf *bf, 
2288         struct ath_desc *lastds, int framelen)
2289 {
2290         struct ath_hal *ah = sc->sc_ah;
2291
2292         /*
2293          * Insert the frame on the outbound list and
2294          * pass it on to the hardware.
2295          */
2296         ATH_TXQ_LOCK(txq);
2297         if (ni && ni->ni_vap && txq == &ATH_VAP(ni->ni_vap)->av_mcastq) {
2298                 /*
2299                  * The CAB queue is started from the SWBA handler since
2300                  * frames only go out on DTIM and to avoid possible races.
2301                  */
2302                 ath_hal_intrset(ah, sc->sc_imask & ~HAL_INT_SWBA);
2303                 ATH_TXQ_INSERT_TAIL(txq, bf, bf_list);
2304                 DPRINTF(sc, ATH_DEBUG_TX_PROC, "%s: txq depth = %d\n", __func__, txq->axq_depth);
2305                 if (txq->axq_link != NULL) {
2306 #ifdef AH_NEED_DESC_SWAP
2307                         *txq->axq_link = cpu_to_le32(bf->bf_daddr);
2308 #else
2309                         *txq->axq_link = bf->bf_daddr;
2310 #endif
2311                         DPRINTF(sc, ATH_DEBUG_XMIT, "%s: link[%u](%p)=%llx (%p)\n",
2312                                 __func__,
2313                                 txq->axq_qnum, txq->axq_link,
2314                                 ito64(bf->bf_daddr), bf->bf_desc);
2315                 }
2316                 txq->axq_link = &lastds->ds_link;
2317                 ath_hal_intrset(ah, sc->sc_imask);
2318         } else {
2319                 ATH_TXQ_INSERT_TAIL(txq, bf, bf_list);
2320                 DPRINTF(sc, ATH_DEBUG_TX_PROC, "%s: txq depth = %d\n", __func__, txq->axq_depth);
2321                 if (txq->axq_link == NULL) {
2322                         ath_hal_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr);
2323                         DPRINTF(sc, ATH_DEBUG_XMIT, "%s: TXDP[%u] = %llx (%p)\n",
2324                                 __func__,
2325                                 txq->axq_qnum, ito64(bf->bf_daddr), bf->bf_desc);
2326                 } else {
2327 #ifdef AH_NEED_DESC_SWAP
2328                         *txq->axq_link = cpu_to_le32(bf->bf_daddr);
2329 #else
2330                         *txq->axq_link = bf->bf_daddr;
2331 #endif
2332                         DPRINTF(sc, ATH_DEBUG_XMIT, "%s: link[%u] (%p)=%llx (%p)\n",
2333                                 __func__,
2334                                 txq->axq_qnum, txq->axq_link,
2335                                 ito64(bf->bf_daddr), bf->bf_desc);
2336                 }
2337                 txq->axq_link = &lastds->ds_link;
2338                 ath_hal_txstart(ah, txq->axq_qnum);
2339                 sc->sc_dev->trans_start = jiffies;
2340         }
2341         ATH_TXQ_UNLOCK(txq);
2342
2343         sc->sc_devstats.tx_packets++;
2344         sc->sc_devstats.tx_bytes += framelen;
2345 }
2346
2347 static int 
2348 dot11_to_ratecode(struct ath_softc *sc, const HAL_RATE_TABLE *rt, int dot11)
2349 {
2350         int index = sc->sc_rixmap[dot11 & IEEE80211_RATE_VAL];
2351         if (index >= 0 && index < rt->rateCount)
2352                 return rt->info[index].rateCode;
2353         
2354         return rt->info[sc->sc_minrateix].rateCode;
2355 }
2356
2357
2358 static int 
2359 ath_tx_startraw(struct net_device *dev, struct ath_buf *bf, struct sk_buff *skb) 
2360 {
2361         struct ath_softc *sc = netdev_priv(dev);
2362         struct ath_hal *ah = sc->sc_ah;
2363         struct ieee80211_phy_params *ph = (struct ieee80211_phy_params *) (skb->cb + sizeof(struct ieee80211_cb));
2364         const HAL_RATE_TABLE *rt;
2365         int pktlen;
2366         int hdrlen;
2367         HAL_PKT_TYPE atype;
2368         u_int flags;
2369         int keyix;
2370         int try0;
2371         int power;
2372         u_int8_t antenna, txrate;
2373         struct ath_txq *txq=NULL;
2374         struct ath_desc *ds=NULL;
2375         struct ieee80211_frame *wh; 
2376         
2377         wh = (struct ieee80211_frame *) skb->data;
2378         try0 = ph->try0;
2379         rt = sc->sc_currates;
2380         txrate = dot11_to_ratecode(sc, rt, ph->rate0);
2381         power = ph->power > 60 ? 60 : ph->power;
2382         hdrlen = ieee80211_anyhdrsize(wh);
2383         pktlen = skb->len + IEEE80211_CRC_LEN;
2384         
2385         keyix = HAL_TXKEYIX_INVALID;
2386         flags = HAL_TXDESC_INTREQ | HAL_TXDESC_CLRDMASK; /* XXX needed for crypto errs */
2387         
2388         bf->bf_skbaddr = bus_map_single(sc->sc_bdev,
2389                                         skb->data, pktlen, BUS_DMA_TODEVICE);
2390         DPRINTF(sc, ATH_DEBUG_XMIT, "%s: skb %p [data %p len %u] skbaddr %llx\n",
2391                 __func__, skb, skb->data, skb->len, ito64(bf->bf_skbaddr));
2392         
2393         
2394         bf->bf_skb = skb;
2395         bf->bf_node = NULL;
2396         
2397 #ifdef ATH_SUPERG_FF
2398         bf->bf_numdesc = 1;
2399 #endif
2400         
2401         /* setup descriptors */
2402         ds = bf->bf_desc;
2403         rt = sc->sc_currates;
2404         KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode));
2405         
2406         
2407         if (IEEE80211_IS_MULTICAST(wh->i_addr1)) {
2408                 flags |= HAL_TXDESC_NOACK;      /* no ack on broad/multicast */
2409                 sc->sc_stats.ast_tx_noack++;
2410                 try0 = 1;
2411         }
2412         atype = HAL_PKT_TYPE_NORMAL;            /* default */
2413         txq = sc->sc_ac2q[skb->priority & 0x3];
2414         
2415         
2416         flags |= HAL_TXDESC_INTREQ;
2417         antenna = sc->sc_txantenna;
2418         
2419         /* XXX check return value? */
2420         ath_hal_setuptxdesc(ah, ds
2421                             , pktlen    /* packet length */
2422                             , hdrlen    /* header length */
2423                             , atype     /* Atheros packet type */
2424                             , power     /* txpower */
2425                             , txrate, try0 /* series 0 rate/tries */
2426                             , keyix     /* key cache index */
2427                             , antenna   /* antenna mode */
2428                             , flags     /* flags */
2429                             , 0         /* rts/cts rate */
2430                             , 0         /* rts/cts duration */
2431                             , 0         /* comp icv len */
2432                             , 0         /* comp iv len */
2433                             , ATH_COMP_PROC_NO_COMP_NO_CCS /* comp scheme */
2434                            );
2435
2436         if (ph->try1) {
2437                 ath_hal_setupxtxdesc(sc->sc_ah, ds
2438                         , dot11_to_ratecode(sc, rt, ph->rate1), ph->try1 /* series 1 */
2439                         , dot11_to_ratecode(sc, rt, ph->rate2), ph->try2 /* series 2 */
2440                         , dot11_to_ratecode(sc, rt, ph->rate3), ph->try3 /* series 3 */
2441                         );      
2442         }
2443         bf->bf_flags = flags;                   /* record for post-processing */
2444
2445         ds->ds_link = 0;
2446         ds->ds_data = bf->bf_skbaddr;
2447         
2448         ath_hal_filltxdesc(ah, ds
2449                            , skb->len   /* segment length */
2450                            , AH_TRUE    /* first segment */
2451                            , AH_TRUE    /* last segment */
2452                            , ds         /* first descriptor */
2453                            );
2454         
2455         /* NB: The desc swap function becomes void, 
2456          * if descriptor swapping is not enabled
2457          */
2458         ath_desc_swap(ds);
2459         
2460         DPRINTF(sc, ATH_DEBUG_XMIT, "%s: Q%d: %08x %08x %08x %08x %08x %08x\n",
2461                 __func__, M_FLAG_GET(skb, M_UAPSD) ? 0 : txq->axq_qnum, ds->ds_link, ds->ds_data,
2462                 ds->ds_ctl0, ds->ds_ctl1, ds->ds_hw[0], ds->ds_hw[1]);
2463                 
2464         ath_tx_txqaddbuf(sc, NULL, txq, bf, ds, pktlen);
2465         return 0;
2466 }
2467
2468 #ifdef ATH_SUPERG_FF
2469 /*
2470  * Flush FF staging queue.
2471  */
2472 static int
2473 ath_ff_neverflushtestdone(struct ath_txq *txq, struct ath_buf *bf)
2474 {
2475         return 0;
2476 }
2477
2478 static int
2479 ath_ff_ageflushtestdone(struct ath_txq *txq, struct ath_buf *bf)
2480 {
2481         if ( (txq->axq_totalqueued - bf->bf_queueage) < ATH_FF_STAGEQAGEMAX )
2482                 return 1;
2483
2484         return 0;
2485 }
2486
2487 /* Caller must not hold ATH_TXQ_LOCK and ATH_TXBUF_LOCK
2488  *
2489  * Context: softIRQ
2490  */
2491 static void
2492 ath_ffstageq_flush(struct ath_softc *sc, struct ath_txq *txq,
2493         int (*ath_ff_flushdonetest)(struct ath_txq *txq, struct ath_buf *bf))
2494 {
2495         struct ath_buf *bf_ff = NULL;
2496         struct ieee80211_node *ni = NULL;
2497         int framecnt;
2498
2499         for (;;) {
2500                 ATH_TXQ_LOCK(txq);
2501
2502                 bf_ff = TAILQ_LAST(&txq->axq_stageq, axq_headtype);
2503                 if ((!bf_ff) || ath_ff_flushdonetest(txq, bf_ff))
2504                 {
2505                         ATH_TXQ_UNLOCK(txq);
2506                         break;
2507                 }
2508
2509                 ni = bf_ff->bf_node;
2510                 KASSERT(ATH_NODE(ni)->an_tx_ffbuf[bf_ff->bf_skb->priority],
2511                         ("no bf_ff on staging queue %p", bf_ff));
2512                 ATH_NODE(ni)->an_tx_ffbuf[bf_ff->bf_skb->priority] = NULL;
2513                 TAILQ_REMOVE(&txq->axq_stageq, bf_ff, bf_stagelist);
2514
2515                 ATH_TXQ_UNLOCK(txq);
2516
2517                 /* encap and xmit */
2518                 bf_ff->bf_skb = ieee80211_encap(ni, bf_ff->bf_skb, &framecnt);
2519                 if (bf_ff->bf_skb == NULL) {
2520                         DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
2521                                 "%s: discard, encapsulation failure\n", __func__);
2522                         sc->sc_stats.ast_tx_encap++;
2523                         goto bad;
2524                 }
2525                 if (ath_tx_start(sc->sc_dev, ni, bf_ff, bf_ff->bf_skb, 0) == 0)
2526                         continue;
2527         bad:
2528                 ieee80211_free_node(ni);
2529                 if (bf_ff->bf_skb != NULL) {
2530                         dev_kfree_skb(bf_ff->bf_skb);
2531                         bf_ff->bf_skb = NULL;
2532                 }
2533                 bf_ff->bf_node = NULL;
2534
2535                 ATH_TXBUF_LOCK_IRQ(sc);
2536                 STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf_ff, bf_list);
2537                 ATH_TXBUF_UNLOCK_IRQ(sc);
2538         }
2539 }
2540 #endif
2541
2542 #define ATH_HARDSTART_GET_TX_BUF_WITH_LOCK                              \
2543         ATH_TXBUF_LOCK_IRQ(sc);                                         \
2544         bf = STAILQ_FIRST(&sc->sc_txbuf);                               \
2545         if (bf != NULL) {                                               \
2546                 STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);             \
2547                 STAILQ_INSERT_TAIL(&bf_head, bf, bf_list);              \
2548         }                                                               \
2549         /* XXX use a counter and leave at least one for mgmt frames */  \
2550         if (STAILQ_EMPTY(&sc->sc_txbuf)) {                              \
2551                 DPRINTF(sc, ATH_DEBUG_XMIT,                             \
2552                         "%s: stop queue\n", __func__);                  \
2553                 sc->sc_stats.ast_tx_qstop++;                            \
2554                 netif_stop_queue(dev);                                  \
2555                 sc->sc_devstopped = 1;                                  \
2556                 ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, NULL);                \
2557         }                                                               \
2558         ATH_TXBUF_UNLOCK_IRQ(sc);                                       \
2559         if (bf == NULL) {               /* NB: should not happen */     \
2560                 DPRINTF(sc,ATH_DEBUG_XMIT,                              \
2561                         "%s: discard, no xmit buf\n", __func__);        \
2562                 sc->sc_stats.ast_tx_nobuf++;                            \
2563         }
2564
2565 /*
2566  * Transmit a data packet.  On failure caller is
2567  * assumed to reclaim the resources.
2568  *
2569  * Context: process context with BH's disabled
2570  */
2571 static int
2572 ath_hardstart(struct sk_buff *skb, struct net_device *dev)
2573 {
2574         struct ath_softc *sc = netdev_priv(dev);
2575         struct ieee80211_node *ni = NULL;
2576         struct ath_buf *bf = NULL;
2577         struct ieee80211_cb *cb = (struct ieee80211_cb *) skb->cb;
2578         struct ether_header *eh;
2579         STAILQ_HEAD(tmp_bf_head, ath_buf) bf_head;
2580         struct ath_buf *tbf, *tempbf;
2581         struct sk_buff *tskb;
2582         struct ieee80211vap *vap;
2583         int framecnt;
2584         int requeue = 0;
2585 #ifdef ATH_SUPERG_FF
2586         struct ieee80211com *ic = &sc->sc_ic;
2587         struct ath_node *an;
2588         struct ath_txq *txq = NULL;
2589         int ff_flush;
2590 #endif
2591
2592         if ((dev->flags & IFF_RUNNING) == 0 || sc->sc_invalid) {
2593                 DPRINTF(sc, ATH_DEBUG_XMIT,
2594                         "%s: discard, invalid %d flags %x\n",
2595                         __func__, sc->sc_invalid, dev->flags);
2596                 sc->sc_stats.ast_tx_invalid++;
2597                 return -ENETDOWN;
2598         }
2599
2600         STAILQ_INIT(&bf_head);
2601
2602         if (cb->flags & M_RAW) {
2603                 ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
2604                 if (bf == NULL)
2605                         goto hardstart_fail;
2606                 ath_tx_startraw(dev, bf,skb);
2607                 return NETDEV_TX_OK;
2608         }
2609
2610         eh = (struct ether_header *)skb->data;
2611         ni = cb->ni;            /* NB: always passed down by 802.11 layer */
2612         if (ni == NULL) {
2613                 /* NB: this happens if someone marks the underlying device up */
2614                 DPRINTF(sc, ATH_DEBUG_XMIT,
2615                         "%s: discard, no node in cb\n", __func__);
2616                 goto hardstart_fail;
2617         }
2618
2619         vap = ni->ni_vap;
2620
2621 #ifdef ATH_SUPERG_FF
2622         if (M_FLAG_GET(skb, M_UAPSD)) {
2623                 /* bypass FF handling */
2624                 ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
2625                 if (bf == NULL)
2626                         goto hardstart_fail;
2627                 goto ff_bypass;
2628         }
2629
2630         /*
2631          * Fast frames check.
2632          */
2633         ATH_FF_MAGIC_CLR(skb);
2634         an = ATH_NODE(ni);
2635
2636         txq = sc->sc_ac2q[skb->priority];
2637
2638         if (txq->axq_depth > TAIL_DROP_COUNT) {
2639                 sc->sc_stats.ast_tx_discard++;
2640                 /* queue is full, let the kernel backlog the skb */
2641                 requeue = 1;
2642                 goto hardstart_fail;
2643         }
2644
2645         /* NB: use this lock to protect an->an_ff_txbuf in athff_can_aggregate()
2646          *     call too.
2647          */
2648         ATH_TXQ_LOCK(txq);
2649         if (athff_can_aggregate(sc, eh, an, skb, vap->iv_fragthreshold, &ff_flush)) {
2650
2651                 if (an->an_tx_ffbuf[skb->priority]) { /* i.e., frame on the staging queue */
2652                         bf = an->an_tx_ffbuf[skb->priority];
2653
2654                         /* get (and remove) the frame from staging queue */
2655                         TAILQ_REMOVE(&txq->axq_stageq, bf, bf_stagelist);
2656                         an->an_tx_ffbuf[skb->priority] = NULL;
2657
2658                         ATH_TXQ_UNLOCK(txq);
2659
2660                         /*
2661                          * chain skbs and add FF magic
2662                          *
2663                          * NB: the arriving skb should not be on a list (skb->list),
2664                          *     so "re-using" the skb next field should be OK.
2665                          */
2666                         bf->bf_skb->next = skb;
2667                         skb->next = NULL;
2668                         skb = bf->bf_skb;
2669                         ATH_FF_MAGIC_PUT(skb);
2670
2671                         /* decrement extra node reference made when an_tx_ffbuf[] was set */
2672                         //ieee80211_free_node(ni); /* XXX where was it set ? */
2673
2674                         DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
2675                                 "%s: aggregating fast-frame\n", __func__);
2676                 } else {
2677                         /* NB: careful grabbing the TX_BUF lock since still holding the txq lock.
2678                          *     this could be avoided by always obtaining the txbuf earlier,
2679                          *     but the "if" portion of this "if/else" clause would then need
2680                          *     to give the buffer back.
2681                          */
2682                         ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
2683                         if (bf == NULL) {
2684                                 ATH_TXQ_UNLOCK(txq);
2685                                 goto hardstart_fail;
2686                         }
2687                         DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
2688                                 "%s: adding to fast-frame stage Q\n", __func__);
2689
2690                         bf->bf_skb = skb;
2691                         bf->bf_node = ni;
2692                         bf->bf_queueage = txq->axq_totalqueued;
2693                         an->an_tx_ffbuf[skb->priority] = bf;
2694
2695                         TAILQ_INSERT_HEAD(&txq->axq_stageq, bf, bf_stagelist);
2696
2697                         ATH_TXQ_UNLOCK(txq);
2698
2699                         return NETDEV_TX_OK;
2700                 }
2701         } else {
2702                 if (ff_flush) {
2703                         struct ath_buf *bf_ff = an->an_tx_ffbuf[skb->priority];
2704
2705                         TAILQ_REMOVE(&txq->axq_stageq, bf_ff, bf_stagelist);
2706                         an->an_tx_ffbuf[skb->priority] = NULL;
2707
2708                         ATH_TXQ_UNLOCK(txq);
2709
2710                         /* encap and xmit */
2711                         bf_ff->bf_skb = ieee80211_encap(ni, bf_ff->bf_skb, &framecnt);
2712
2713                         if (bf_ff->bf_skb == NULL) {
2714                                 DPRINTF(sc, ATH_DEBUG_XMIT,
2715                                         "%s: discard, ff flush encap failure\n",
2716                                         __func__);
2717                                 sc->sc_stats.ast_tx_encap++;
2718                                 goto ff_flushbad;
2719                         }
2720                         /* NB: ath_tx_start() will use ATH_TXBUF_LOCK_BH(). The _BH
2721                          *     portion is not needed here since we're running at
2722                          *     interrupt time, but should be harmless.
2723                          */
2724                         if (ath_tx_start(dev, ni, bf_ff, bf_ff->bf_skb, 0))
2725                                 goto ff_flushbad;
2726                         goto ff_flushdone;
2727                 ff_flushbad:
2728                         DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
2729                                 "%s: ff stageq flush failure\n", __func__);
2730                         ieee80211_free_node(ni);
2731                         if (bf_ff->bf_skb) {
2732                                 dev_kfree_skb(bf_ff->bf_skb);
2733                                 bf_ff->bf_skb = NULL;
2734                         }
2735                         bf_ff->bf_node = NULL;
2736
2737                         ATH_TXBUF_LOCK(sc);
2738                         STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf_ff, bf_list);
2739                         ATH_TXBUF_UNLOCK(sc);
2740                         goto ff_flushdone;
2741                 }
2742                 /*
2743                  * XXX: out-of-order condition only occurs for AP mode and multicast.
2744                  *      But, there may be no valid way to get this condition.
2745                  */
2746                 else if (an->an_tx_ffbuf[skb->priority]) {
2747                         DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
2748                                 "%s: Out-Of-Order fast-frame\n", __func__);
2749                         ATH_TXQ_UNLOCK(txq);
2750                 } else
2751                         ATH_TXQ_UNLOCK(txq);
2752
2753         ff_flushdone:
2754                 ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
2755                 if (bf == NULL)
2756                         goto hardstart_fail;
2757         }
2758
2759 ff_bypass:
2760
2761 #else /* ATH_SUPERG_FF */
2762
2763         ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
2764
2765 #endif /* ATH_SUPERG_FF */
2766
2767         /*
2768          * Encapsulate the packet for transmission.
2769          */
2770         skb = ieee80211_encap(ni, skb, &framecnt);
2771         if (skb == NULL) {
2772                 DPRINTF(sc, ATH_DEBUG_XMIT,
2773                         "%s: discard, encapsulation failure\n", __func__);
2774                 sc->sc_stats.ast_tx_encap++;
2775                 goto hardstart_fail;
2776         }
2777
2778         if (framecnt > 1) {
2779                 int bfcnt;
2780
2781                 /*
2782                 **  Allocate 1 ath_buf for each frame given 1 was 
2783                 **  already alloc'd
2784                 */
2785                 ATH_TXBUF_LOCK(sc);
2786                 for (bfcnt = 1; bfcnt < framecnt; ++bfcnt) {
2787                         if ((tbf = STAILQ_FIRST(&sc->sc_txbuf)) != NULL) {
2788                                 STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);
2789                                 STAILQ_INSERT_TAIL(&bf_head, tbf, bf_list);
2790                         }
2791                         else
2792                                 break;
2793                         
2794                         ieee80211_ref_node(ni);
2795                 }
2796
2797                 if (bfcnt != framecnt) {
2798                         if (!STAILQ_EMPTY(&bf_head)) {
2799                                 /*
2800                                 **  Failed to alloc enough ath_bufs;
2801                                 **  return to sc_txbuf list
2802                                 */
2803                                 STAILQ_FOREACH_SAFE(tbf, &bf_head, bf_list, tempbf) {
2804                                         STAILQ_INSERT_TAIL(&sc->sc_txbuf, tbf, bf_list);
2805                                 }
2806                         }
2807                         ATH_TXBUF_UNLOCK(sc);
2808                         STAILQ_INIT(&bf_head);
2809                         goto hardstart_fail;
2810                 }
2811                 ATH_TXBUF_UNLOCK(sc);
2812
2813                 while ((bf = STAILQ_FIRST(&bf_head)) != NULL && skb != NULL) {
2814                         int nextfraglen = 0;
2815
2816                         STAILQ_REMOVE_HEAD(&bf_head, bf_list);
2817                         tskb = skb->next;
2818                         skb->next = NULL;
2819                         if (tskb)
2820                                 nextfraglen = tskb->len;
2821
2822                         if (ath_tx_start(dev, ni, bf, skb, nextfraglen) != 0) {
2823                                 STAILQ_INSERT_TAIL(&bf_head, bf, bf_list);
2824                                 skb->next = tskb;
2825                                 goto hardstart_fail;
2826                         }
2827                         skb = tskb;
2828                 }
2829         } else {
2830                 if (ath_tx_start(dev, ni, bf, skb, 0) != 0) {
2831                         STAILQ_INSERT_TAIL(&bf_head, bf, bf_list);
2832                         goto hardstart_fail;
2833                 }
2834         }
2835
2836 #ifdef ATH_SUPERG_FF
2837         /*
2838          * flush out stale FF from staging Q for applicable operational modes.
2839          */
2840         /* XXX: ADHOC mode too? */
2841         if (txq && ic->ic_opmode == IEEE80211_M_HOSTAP)
2842                 ath_ffstageq_flush(sc, txq, ath_ff_ageflushtestdone);
2843 #endif
2844
2845         return NETDEV_TX_OK;
2846
2847 hardstart_fail:
2848         if (!STAILQ_EMPTY(&bf_head)) {
2849                 ATH_TXBUF_LOCK(sc);
2850                 STAILQ_FOREACH_SAFE(tbf, &bf_head, bf_list, tempbf) {
2851                         tbf->bf_skb = NULL;
2852                         tbf->bf_node = NULL;
2853                         
2854                         if (ni != NULL) 
2855                                 ieee80211_free_node(ni);
2856
2857                         STAILQ_INSERT_TAIL(&sc->sc_txbuf, tbf, bf_list);
2858                 }
2859                 ATH_TXBUF_UNLOCK(sc);
2860         }
2861         
2862         /* let the kernel requeue the skb (don't free it!) */
2863         if (requeue)
2864                 return NETDEV_TX_BUSY;
2865
2866         /* free sk_buffs */
2867         while (skb) {
2868                 tskb = skb->next;
2869                 skb->next = NULL;
2870                 dev_kfree_skb(skb);
2871                 skb = tskb;
2872         }
2873         return NETDEV_TX_OK;
2874 }
2875 #undef ATH_HARDSTART_GET_TX_BUF_WITH_LOCK
2876
2877 /*
2878  * Transmit a management frame.  On failure we reclaim the skbuff.
2879  * Note that management frames come directly from the 802.11 layer
2880  * and do not honor the send queue flow control.  Need to investigate
2881  * using priority queuing so management frames can bypass data.
2882  *
2883  * Context: hwIRQ and softIRQ
2884  */
2885 static int
2886 ath_mgtstart(struct ieee80211com *ic, struct sk_buff *skb)
2887 {
2888         struct net_device *dev = ic->ic_dev;
2889         struct ath_softc *sc = netdev_priv(dev);
2890         struct ieee80211_node *ni = NULL;
2891         struct ath_buf *bf = NULL;
2892         struct ieee80211_cb *cb;
2893         int error;
2894
2895         if ((dev->flags & IFF_RUNNING) == 0 || sc->sc_invalid) {
2896                 DPRINTF(sc, ATH_DEBUG_XMIT,
2897                         "%s: discard, invalid %d flags %x\n",
2898                         __func__, sc->sc_invalid, dev->flags);
2899                 sc->sc_stats.ast_tx_invalid++;
2900                 error = -ENETDOWN;
2901                 goto bad;
2902         }
2903         /*
2904          * Grab a TX buffer and associated resources.
2905          */
2906         ATH_TXBUF_LOCK_IRQ(sc);
2907         bf = STAILQ_FIRST(&sc->sc_txbuf);
2908         if (bf != NULL)
2909                 STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);
2910         if (STAILQ_EMPTY(&sc->sc_txbuf)) {
2911                 DPRINTF(sc, ATH_DEBUG_XMIT, "%s: stop queue\n", __func__);
2912                 sc->sc_stats.ast_tx_qstop++;
2913                 netif_stop_queue(dev);
2914                 sc->sc_devstopped=1;
2915                 ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, NULL);
2916         }
2917         ATH_TXBUF_UNLOCK_IRQ(sc);
2918         if (bf == NULL) {
2919                 printk("ath_mgtstart: discard, no xmit buf\n");
2920                 sc->sc_stats.ast_tx_nobufmgt++;
2921                 error = -ENOBUFS;
2922                 goto bad;
2923         }
2924
2925         /*
2926          * NB: the referenced node pointer is in the
2927          * control block of the sk_buff.  This is
2928          * placed there by ieee80211_mgmt_output because
2929          * we need to hold the reference with the frame.
2930          */
2931         cb = (struct ieee80211_cb *)skb->cb;
2932         ni = cb->ni;
2933         error = ath_tx_start(dev, ni, bf, skb, 0);
2934         if (error == 0) {
2935                 sc->sc_stats.ast_tx_mgmt++;
2936                 return 0;
2937         }
2938         /* fall thru... */
2939 bad:
2940         if (ni != NULL)
2941                 ieee80211_free_node(ni);
2942         if (bf != NULL) {
2943                 bf->bf_skb = NULL;
2944                 bf->bf_node = NULL;
2945
2946                 ATH_TXBUF_LOCK_IRQ(sc);
2947                 STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list);
2948                 ATH_TXBUF_UNLOCK_IRQ(sc);
2949         }
2950         dev_kfree_skb_any(skb);
2951         skb = NULL;
2952         return error;
2953 }
2954
2955 #ifdef AR_DEBUG
2956 static void
2957 ath_keyprint(struct ath_softc *sc, const char *tag, u_int ix,
2958         const HAL_KEYVAL *hk, const u_int8_t mac[IEEE80211_ADDR_LEN])
2959 {
2960         static const char *ciphers[] = {
2961                 "WEP",
2962                 "AES-OCB",
2963                 "AES-CCM",
2964                 "CKIP",
2965                 "TKIP",
2966                 "CLR",
2967         };
2968         int i, n;
2969
2970         printk("%s: [%02u] %-7s ", tag, ix, ciphers[hk->kv_type]);
2971         for (i = 0, n = hk->kv_len; i < n; i++)
2972                 printk("%02x", hk->kv_val[i]);
2973         printk(" mac %s", ether_sprintf(mac));
2974         if (hk->kv_type == HAL_CIPHER_TKIP) {
2975                 printk(" %s ", sc->sc_splitmic ? "mic" : "rxmic");
2976                 for (i = 0; i < sizeof(hk->kv_mic); i++)
2977                         printk("%02x", hk->kv_mic[i]);
2978 #if HAL_ABI_VERSION > 0x06052200
2979                 if (!sc->sc_splitmic) {
2980                         printk(" txmic ");
2981                         for (i = 0; i < sizeof(hk->kv_txmic); i++)
2982                                 printk("%02x", hk->kv_txmic[i]);
2983                 }
2984 #endif
2985         }
2986         printk("\n");
2987 }
2988 #endif
2989
2990 /*
2991  * Set a TKIP key into the hardware.  This handles the
2992  * potential distribution of key state to multiple key
2993  * cache slots for TKIP.
2994  */
2995 static int
2996 ath_keyset_tkip(struct ath_softc *sc, const struct ieee80211_key *k,
2997         HAL_KEYVAL *hk, const u_int8_t mac[IEEE80211_ADDR_LEN])
2998 {
2999 #define IEEE80211_KEY_XR        (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV)
3000         static const u_int8_t zerobssid[IEEE80211_ADDR_LEN];
3001         struct ath_hal *ah = sc->sc_ah;
3002
3003         KASSERT(k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP,
3004                 ("got a non-TKIP key, cipher %u", k->wk_cipher->ic_cipher));
3005         if ((k->wk_flags & IEEE80211_KEY_XR) == IEEE80211_KEY_XR) {
3006                 if (sc->sc_splitmic) {
3007                         /*
3008                          * TX key goes at first index, RX key at the rx index.
3009                          * The HAL handles the MIC keys at index+64.
3010                          */
3011                         memcpy(hk->kv_mic, k->wk_txmic, sizeof(hk->kv_mic));
3012                         KEYPRINTF(sc, k->wk_keyix, hk, zerobssid);
3013                         if (!ath_hal_keyset(ah, k->wk_keyix, hk, zerobssid))
3014                                 return 0;
3015
3016                         memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
3017                         KEYPRINTF(sc, k->wk_keyix+32, hk, mac);
3018                         /* XXX delete tx key on failure? */
3019                         return ath_hal_keyset(ah, k->wk_keyix+32, hk, mac);
3020                 } else {
3021                         /*
3022                          * Room for both TX+RX MIC keys in one key cache
3023                          * slot, just set key at the first index; the HAL
3024                          * will handle the reset.
3025                          */
3026                         memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
3027 #if HAL_ABI_VERSION > 0x06052200
3028                         memcpy(hk->kv_txmic, k->wk_txmic, sizeof(hk->kv_txmic));
3029 #endif
3030                         KEYPRINTF(sc, k->wk_keyix, hk, mac);
3031                         return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
3032                 }
3033         } else if (k->wk_flags & IEEE80211_KEY_XR) {
3034                 /*
3035                  * TX/RX key goes at first index.
3036                  * The HAL handles the MIC keys are index+64.
3037                  */
3038                 memcpy(hk->kv_mic, k->wk_flags & IEEE80211_KEY_XMIT ?
3039                         k->wk_txmic : k->wk_rxmic, sizeof(hk->kv_mic));
3040                 KEYPRINTF(sc, k->wk_keyix, hk, mac);
3041                 return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
3042         }
3043         return 0;
3044 #undef IEEE80211_KEY_XR
3045 }
3046
3047 /*
3048  * Set a net80211 key into the hardware.  This handles the
3049  * potential distribution of key state to multiple key
3050  * cache slots for TKIP with hardware MIC support.
3051  */
3052 static int
3053 ath_keyset(struct ath_softc *sc, const struct ieee80211_key *k,
3054         const u_int8_t mac0[IEEE80211_ADDR_LEN],
3055         struct ieee80211_node *bss)
3056 {
3057 #define N(a)    ((int)(sizeof(a)/sizeof(a[0])))
3058         static const u_int8_t ciphermap[] = {
3059                 HAL_CIPHER_WEP,         /* IEEE80211_CIPHER_WEP */
3060                 HAL_CIPHER_TKIP,        /* IEEE80211_CIPHER_TKIP */
3061                 HAL_CIPHER_AES_OCB,     /* IEEE80211_CIPHER_AES_OCB */
3062                 HAL_CIPHER_AES_CCM,     /* IEEE80211_CIPHER_AES_CCM */
3063                 (u_int8_t) -1,          /* 4 is not allocated */
3064                 HAL_CIPHER_CKIP,        /* IEEE80211_CIPHER_CKIP */
3065                 HAL_CIPHER_CLR,         /* IEEE80211_CIPHER_NONE */
3066         };
3067         struct ath_hal *ah = sc->sc_ah;
3068         const struct ieee80211_cipher *cip = k->wk_cipher;
3069         u_int8_t gmac[IEEE80211_ADDR_LEN];
3070         const u_int8_t *mac;
3071         HAL_KEYVAL hk;
3072
3073         memset(&hk, 0, sizeof(hk));
3074         /*
3075          * Software crypto uses a "clear key" so non-crypto
3076          * state kept in the key cache are maintained and
3077          * so that rx frames have an entry to match.
3078          */
3079         if ((k->wk_flags & IEEE80211_KEY_SWCRYPT) == 0) {
3080                 KASSERT(cip->ic_cipher < N(ciphermap),
3081                         ("invalid cipher type %u", cip->ic_cipher));
3082                 hk.kv_type = ciphermap[cip->ic_cipher];
3083                 hk.kv_len = k->wk_keylen;
3084                 memcpy(hk.kv_val, k->wk_key, k->wk_keylen);
3085         } else
3086                 hk.kv_type = HAL_CIPHER_CLR;
3087
3088         if ((k->wk_flags & IEEE80211_KEY_GROUP) && sc->sc_mcastkey) {
3089                 /*
3090                  * Group keys on hardware that supports multicast frame
3091                  * key search use a mac that is the sender's address with
3092                  * the high bit set instead of the app-specified address.
3093                  */
3094                 IEEE80211_ADDR_COPY(gmac, bss->ni_macaddr);
3095                 gmac[0] |= 0x80;
3096                 mac = gmac;
3097         } else
3098                 mac = mac0;
3099
3100         if (hk.kv_type == HAL_CIPHER_TKIP &&
3101             (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
3102                 return ath_keyset_tkip(sc, k, &hk, mac);
3103         } else {
3104                 KEYPRINTF(sc, k->wk_keyix, &hk, mac);
3105                 return ath_hal_keyset(ah, k->wk_keyix, &hk, mac);
3106         }
3107 #undef N
3108 }
3109
3110 /*
3111  * Allocate tx/rx key slots for TKIP.  We allocate two slots for
3112  * each key, one for decrypt/encrypt and the other for the MIC.
3113  */
3114 static u_int16_t
3115 key_alloc_2pair(struct ath_softc *sc)
3116 {
3117 #define N(a)    ((int)(sizeof(a)/sizeof(a[0])))
3118         u_int i, keyix;
3119
3120         KASSERT(sc->sc_splitmic, ("key cache !split"));
3121         /* XXX could optimize */
3122         for (i = 0; i < N(sc->sc_keymap) / 4; i++) {
3123                 u_int8_t b = sc->sc_keymap[i];
3124                 if (b != 0xff) {
3125                         /*
3126                          * One or more slots in this byte are free.
3127                          */
3128                         keyix = i * NBBY;
3129                         while (b & 1) {
3130                 again:
3131                                 keyix++;
3132                                 b >>= 1;
3133                         }
3134                         /* XXX IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV */
3135                         if (isset(sc->sc_keymap, keyix + 32) ||
3136                             isset(sc->sc_keymap, keyix + 64) ||
3137                             isset(sc->sc_keymap, keyix + 32 + 64)) {
3138                                 /* full pair unavailable */
3139                                 /* XXX statistic */
3140                                 if (keyix == (i + 1) * NBBY) {
3141                                         /* no slots were appropriate, advance */
3142                                         continue;
3143                                 }
3144                                 goto again;
3145                         }
3146                         setbit(sc->sc_keymap, keyix);
3147                         setbit(sc->sc_keymap, keyix + 64);
3148                         setbit(sc->sc_keymap, keyix + 32);
3149                         setbit(sc->sc_keymap, keyix + 32 + 64);
3150                         DPRINTF(sc, ATH_DEBUG_KEYCACHE,
3151                                 "%s: key pair %u,%u %u,%u\n",
3152                                 __func__, keyix, keyix + 64,
3153                                 keyix + 32, keyix + 32 + 64);
3154                         return keyix;
3155                 }
3156         }
3157         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of pair space\n", __func__);
3158         return IEEE80211_KEYIX_NONE;
3159 #undef N
3160 }
3161
3162 /*
3163  * Allocate tx/rx key slots for TKIP.  We allocate two slots for
3164  * each key, one for decrypt/encrypt and the other for the MIC.
3165  */
3166 static u_int16_t
3167 key_alloc_pair(struct ath_softc *sc)
3168 {
3169 #define N(a)    (sizeof(a)/sizeof(a[0]))
3170         u_int i, keyix;
3171
3172         KASSERT(!sc->sc_splitmic, ("key cache split"));
3173         /* XXX could optimize */
3174         for (i = 0; i < N(sc->sc_keymap)/4; i++) {
3175                 u_int8_t b = sc->sc_keymap[i];
3176                 if (b != 0xff) {
3177                         /*
3178                          * One or more slots in this byte are free.
3179                          */
3180                         keyix = i*NBBY;
3181                         while (b & 1) {
3182                 again:
3183                                 keyix++;
3184                                 b >>= 1;
3185                         }
3186                         if (isset(sc->sc_keymap, keyix+64)) {
3187                                 /* full pair unavailable */
3188                                 /* XXX statistic */
3189                                 if (keyix == (i+1)*NBBY) {
3190                                         /* no slots were appropriate, advance */
3191                                         continue;
3192                                 }
3193                                 goto again;
3194                         }
3195                         setbit(sc->sc_keymap, keyix);
3196                         setbit(sc->sc_keymap, keyix+64);
3197                         DPRINTF(sc, ATH_DEBUG_KEYCACHE,
3198                                 "%s: key pair %u,%u\n",
3199                                 __func__, keyix, keyix+64);
3200                         return keyix;
3201                 }
3202         }
3203         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of pair space\n", __func__);
3204         return IEEE80211_KEYIX_NONE;
3205 #undef N
3206 }
3207
3208 /*
3209  * Allocate a single key cache slot.
3210  */
3211 static u_int16_t
3212 key_alloc_single(struct ath_softc *sc)
3213 {
3214 #define N(a)    ((int)(sizeof(a)/sizeof(a[0])))
3215         u_int i, keyix;
3216
3217         /* XXX try i,i+32,i+64,i+32+64 to minimize key pair conflicts */
3218         for (i = 0; i < N(sc->sc_keymap); i++) {
3219                 u_int8_t b = sc->sc_keymap[i];
3220                 if (b != 0xff) {
3221                         /*
3222                          * One or more slots are free.
3223                          */
3224                         keyix = i * NBBY;
3225                         while (b & 1)
3226                                 keyix++, b >>= 1;
3227                         setbit(sc->sc_keymap, keyix);
3228                         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: key %u\n",
3229                                 __func__, keyix);
3230                         return keyix;
3231                 }
3232         }
3233         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of space\n", __func__);
3234         return IEEE80211_KEYIX_NONE;
3235 #undef N
3236 }
3237
3238 /*
3239  * Allocate one or more key cache slots for a unicast key.  The
3240  * key itself is needed only to identify the cipher.  For hardware
3241  * TKIP with split cipher+MIC keys we allocate two key cache slot
3242  * pairs so that we can setup separate TX and RX MIC keys.  Note
3243  * that the MIC key for a TKIP key at slot i is assumed by the
3244  * hardware to be at slot i+64.  This limits TKIP keys to the first
3245  * 64 entries.
3246  */
3247 static int
3248 ath_key_alloc(struct ieee80211vap *vap, const struct ieee80211_key *k)
3249 {
3250         struct net_device *dev = vap->iv_ic->ic_dev;
3251         struct ath_softc *sc = netdev_priv(dev);
3252
3253         /*
3254          * Group key allocation must be handled specially for
3255          * parts that do not support multicast key cache search
3256          * functionality.  For those parts the key id must match
3257          * the h/w key index so lookups find the right key.  On
3258          * parts w/ the key search facility we install the sender's
3259          * mac address (with the high bit set) and let the hardware
3260          * find the key w/o using the key id.  This is preferred as
3261          * it permits us to support multiple users for adhoc and/or
3262          * multi-station operation.
3263          */
3264         if ((k->wk_flags & IEEE80211_KEY_GROUP) && !sc->sc_mcastkey) {
3265                 int i;
3266                 u_int keyix = IEEE80211_KEYIX_NONE;
3267
3268                 for (i = 0; i < IEEE80211_WEP_NKID; i++) {
3269                         if (k == &vap->iv_nw_keys[i]) {
3270                                 keyix = i;
3271                                 break;
3272                         }
3273                 }
3274                 if (keyix == IEEE80211_KEYIX_NONE) {
3275                         /* should not happen */
3276                         DPRINTF(sc, ATH_DEBUG_KEYCACHE,
3277                                 "%s: bogus group key\n", __func__);
3278                         return IEEE80211_KEYIX_NONE;
3279                 }
3280
3281                 /*
3282                  * XXX we pre-allocate the global keys so
3283                  * have no way to check if they've already been allocated.
3284                  */
3285                 return keyix;
3286         }
3287         /*
3288          * We allocate two pair for TKIP when using the h/w to do
3289          * the MIC.  For everything else, including software crypto,
3290          * we allocate a single entry.  Note that s/w crypto requires
3291          * a pass-through slot on the 5211 and 5212.  The 5210 does
3292          * not support pass-through cache entries and we map all
3293          * those requests to slot 0.
3294          *
3295          * Allocate 1 pair of keys for WEP case. Make sure the key
3296          * is not a shared-key.
3297          */
3298         if (k->wk_flags & IEEE80211_KEY_SWCRYPT)
3299                 return key_alloc_single(sc);
3300         else if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP &&
3301                 (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
3302                 if (sc->sc_splitmic)
3303                         return key_alloc_2pair(sc);
3304                 else
3305                         return key_alloc_pair(sc);
3306         } else
3307                 return key_alloc_single(sc);
3308 }
3309
3310 /*
3311  * Delete an entry in the key cache allocated by ath_key_alloc.
3312  */
3313 static int
3314 ath_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k,
3315                                 struct ieee80211_node *ninfo)
3316 {
3317         struct net_device *dev = vap->iv_ic->ic_dev;
3318         struct ath_softc *sc = netdev_priv(dev);
3319         struct ath_hal *ah = sc->sc_ah;
3320         const struct ieee80211_cipher *cip = k->wk_cipher;
3321         struct ieee80211_node *ni;
3322         u_int keyix = k->wk_keyix;
3323         int rxkeyoff = 0;
3324
3325         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: delete key %u\n", __func__, keyix);
3326
3327         ath_hal_keyreset(ah, keyix);
3328         /*
3329          * Check the key->node map and flush any ref.
3330          */
3331         ni = sc->sc_keyixmap[keyix];
3332         if (ni != NULL) {
3333                 ieee80211_free_node(ni);
3334                 sc->sc_keyixmap[keyix] = NULL;
3335         }
3336         /*
3337          * Handle split tx/rx keying required for TKIP with h/w MIC.
3338          */
3339         if (cip->ic_cipher == IEEE80211_CIPHER_TKIP &&
3340             (k->wk_flags & IEEE80211_KEY_SWMIC) == 0 && sc->sc_splitmic) {
3341                 ath_hal_keyreset(ah, keyix + 32);       /* RX key */
3342                 ni = sc->sc_keyixmap[keyix + 32];
3343                 if (ni != NULL) {                       /* as above... */
3344                         ieee80211_free_node(ni);
3345                         sc->sc_keyixmap[keyix + 32] = NULL;
3346                 }
3347         }
3348
3349         /* Remove receive key entry if one exists for static WEP case */
3350         if (ninfo != NULL) {
3351                 rxkeyoff = ninfo->ni_rxkeyoff;
3352                 if (rxkeyoff != 0) {
3353                         ninfo->ni_rxkeyoff = 0;
3354                         ath_hal_keyreset(ah, keyix + rxkeyoff);
3355                         ni = sc->sc_keyixmap[keyix + rxkeyoff];
3356                         if (ni != NULL) {       /* as above... */
3357                                 ieee80211_free_node(ni);
3358                                 sc->sc_keyixmap[keyix + rxkeyoff] = NULL;
3359                         }
3360                 }
3361         }
3362
3363         if (keyix >= IEEE80211_WEP_NKID) {
3364                 /*
3365                  * Don't touch keymap entries for global keys so
3366                  * they are never considered for dynamic allocation.
3367                  */
3368                 clrbit(sc->sc_keymap, keyix);
3369                 if (cip->ic_cipher == IEEE80211_CIPHER_TKIP &&
3370                     (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
3371                         clrbit(sc->sc_keymap, keyix + 64);      /* TX key MIC */
3372                         if (sc->sc_splitmic) {
3373                                 /* +32 for RX key, +32+64 for RX key MIC */
3374                                 clrbit(sc->sc_keymap, keyix+32);
3375                                 clrbit(sc->sc_keymap, keyix+32+64);
3376                         }
3377                 }
3378
3379                 if (rxkeyoff != 0)
3380                         clrbit(sc->sc_keymap, keyix + rxkeyoff);/*RX Key */
3381         }
3382         return 1;
3383 }
3384
3385 /*
3386  * Set the key cache contents for the specified key.  Key cache
3387  * slot(s) must already have been allocated by ath_key_alloc.
3388  */
3389 static int
3390 ath_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k,
3391         const u_int8_t mac[IEEE80211_ADDR_LEN])
3392 {
3393         struct net_device *dev = vap->iv_ic->ic_dev;
3394         struct ath_softc *sc = netdev_priv(dev);
3395
3396         return ath_keyset(sc, k, mac, vap->iv_bss);
3397 }
3398
3399 /*
3400  * Block/unblock tx+rx processing while a key change is done.
3401  * We assume the caller serializes key management operations
3402  * so we only need to worry about synchronization with other
3403  * uses that originate in the driver.
3404  */
3405 static void
3406 ath_key_update_begin(struct ieee80211vap *vap)
3407 {
3408         struct net_device *dev = vap->iv_ic->ic_dev;
3409         struct ath_softc *sc = netdev_priv(dev);
3410
3411         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s:\n", __func__);
3412         /*
3413          * When called from the rx tasklet we cannot use
3414          * tasklet_disable because it will block waiting
3415          * for us to complete execution.
3416          *
3417          * XXX Using in_softirq is not right since we might
3418          * be called from other soft irq contexts than
3419          * ath_rx_tasklet.
3420          */
3421         if (!in_softirq())
3422                 tasklet_disable(&sc->sc_rxtq);
3423         netif_stop_queue(dev);
3424 }
3425
3426 static void
3427 ath_key_update_end(struct ieee80211vap *vap)
3428 {
3429         struct net_device *dev = vap->iv_ic->ic_dev;
3430         struct ath_softc *sc = netdev_priv(dev);
3431
3432         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s:\n", __func__);
3433         netif_start_queue(dev);
3434         if (!in_softirq())              /* NB: see above */
3435                 tasklet_enable(&sc->sc_rxtq);
3436 }
3437
3438 /*
3439  * Calculate the receive filter according to the
3440  * operating mode and state:
3441  *
3442  * o always accept unicast, broadcast, and multicast traffic
3443  * o maintain current state of phy error reception (the HAL
3444  *   may enable phy error frames for noise immunity work)
3445  * o probe request frames are accepted only when operating in
3446  *   hostap, adhoc, or monitor modes
3447  * o enable promiscuous mode according to the interface state
3448  * o accept beacons:
3449  *   - when operating in adhoc mode so the 802.11 layer creates
3450  *     node table entries for peers,
3451  *   - when operating in station mode for collecting rssi data when
3452  *     the station is otherwise quiet, or
3453  *   - when operating as a repeater so we see repeater-sta beacons
3454  *   - when scanning
3455  */
3456 static u_int32_t
3457 ath_calcrxfilter(struct ath_softc *sc)
3458 {
3459 #define RX_FILTER_PRESERVE      (HAL_RX_FILTER_PHYERR | HAL_RX_FILTER_PHYRADAR)
3460         struct ieee80211com *ic = &sc->sc_ic;
3461         struct net_device *dev = ic->ic_dev;
3462         struct ath_hal *ah = sc->sc_ah;
3463         u_int32_t rfilt;
3464
3465         rfilt = (ath_hal_getrxfilter(ah) & RX_FILTER_PRESERVE) |
3466                  HAL_RX_FILTER_UCAST | HAL_RX_FILTER_BCAST |
3467                  HAL_RX_FILTER_MCAST;
3468         if (ic->ic_opmode != IEEE80211_M_STA)
3469                 rfilt |= HAL_RX_FILTER_PROBEREQ;
3470         if (ic->ic_opmode != IEEE80211_M_HOSTAP && (dev->flags & IFF_PROMISC))
3471                 rfilt |= HAL_RX_FILTER_PROM;
3472         if (ic->ic_opmode == IEEE80211_M_STA ||
3473             sc->sc_opmode == HAL_M_IBSS ||      /* NB: AHDEMO too */
3474             (sc->sc_nostabeacons) || sc->sc_scanning)
3475                 rfilt |= HAL_RX_FILTER_BEACON;
3476         if (sc->sc_nmonvaps > 0) 
3477                 rfilt |= (HAL_RX_FILTER_CONTROL | HAL_RX_FILTER_BEACON | 
3478                           HAL_RX_FILTER_PROBEREQ | HAL_RX_FILTER_PROM);
3479         return rfilt;
3480 #undef RX_FILTER_PRESERVE
3481 }
3482
3483 /*
3484  * Merge multicast addresses from all VAPs to form the
3485  * hardware filter.  Ideally we should only inspect our
3486  * own list and the 802.11 layer would merge for us but
3487  * that's a bit difficult so for now we put the onus on
3488  * the driver.
3489  */
3490 static void
3491 ath_merge_mcast(struct ath_softc *sc, u_int32_t mfilt[2])
3492 {
3493         struct ieee80211com *ic = &sc->sc_ic;
3494         struct ieee80211vap *vap;
3495         struct ath_netdev_hw_addr *ha;
3496         u_int32_t val;
3497         u_int8_t pos;
3498
3499         mfilt[0] = mfilt[1] = 0;
3500         /* XXX locking */
3501         TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
3502                 struct net_device *dev = vap->iv_dev;
3503                 netdev_for_each_mc_addr (ha, dev) {
3504                         /* calculate XOR of eight 6-bit values */
3505                         val = LE_READ_4(ath_ha_addr(ha) + 0);
3506                         pos = (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
3507                         val = LE_READ_4(ath_ha_addr(ha) + 3);
3508                         pos ^= (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
3509                         pos &= 0x3f;
3510                         mfilt[pos / 32] |= (1 << (pos % 32));
3511                 }
3512         }
3513 }
3514
3515 static void
3516 ath_mode_init(struct net_device *dev)
3517 {
3518         struct ath_softc *sc = netdev_priv(dev);
3519         struct ath_hal *ah = sc->sc_ah;
3520         u_int32_t rfilt, mfilt[2];
3521
3522         /* configure rx filter */
3523         rfilt = ath_calcrxfilter(sc);
3524         ath_hal_setrxfilter(ah, rfilt);
3525
3526         /* configure bssid mask */
3527         if (sc->sc_hasbmask)
3528                 ath_hal_setbssidmask(ah, sc->sc_bssidmask);
3529
3530         /* configure operational mode */
3531         ath_hal_setopmode(ah);
3532
3533         /* calculate and install multicast filter */
3534         if ((dev->flags & IFF_ALLMULTI) == 0)
3535                 ath_merge_mcast(sc, mfilt);
3536         else
3537                 mfilt[0] = mfilt[1] = ~0;
3538         ath_hal_setmcastfilter(ah, mfilt[0], mfilt[1]);
3539         DPRINTF(sc, ATH_DEBUG_STATE,
3540              "%s: RX filter 0x%x, MC filter %08x:%08x\n",
3541              __func__, rfilt, mfilt[0], mfilt[1]);
3542 }
3543
3544 /*
3545  * Set the slot time based on the current setting.
3546  */
3547 static void
3548 ath_setslottime(struct ath_softc *sc)
3549 {
3550         struct ieee80211com *ic = &sc->sc_ic;
3551         struct ath_hal *ah = sc->sc_ah;
3552
3553         if (sc->sc_slottimeconf > 0) /* manual override */
3554                 ath_hal_setslottime(ah, sc->sc_slottimeconf);
3555         else if (ic->ic_flags & IEEE80211_F_SHSLOT)
3556                 ath_hal_setslottime(ah, HAL_SLOT_TIME_9);
3557         else
3558                 ath_hal_setslottime(ah, HAL_SLOT_TIME_20);
3559         sc->sc_updateslot = OK;
3560 }
3561
3562 /*
3563  * Callback from the 802.11 layer to update the
3564  * slot time based on the current setting.
3565  */
3566 static void
3567 ath_updateslot(struct net_device *dev)
3568 {
3569         struct ath_softc *sc = netdev_priv(dev);
3570         struct ieee80211com *ic = &sc->sc_ic;
3571
3572         /*
3573          * When not coordinating the BSS, change the hardware
3574          * immediately.  For other operation we defer the change
3575          * until beacon updates have propagated to the stations.
3576          */
3577         if (ic->ic_opmode == IEEE80211_M_HOSTAP)
3578                 sc->sc_updateslot = UPDATE;
3579         else if (dev->flags & IFF_RUNNING)
3580                 ath_setslottime(sc);
3581 }
3582
3583 #ifdef ATH_SUPERG_DYNTURBO
3584 /*
3585  * Dynamic turbo support.
3586  * XXX much of this could be moved up to the net80211 layer.
3587  */
3588
3589 /*
3590  * Configure dynamic turbo state on beacon setup.
3591  */
3592 static void
3593 ath_beacon_dturbo_config(struct ieee80211vap *vap, u_int32_t intval)
3594 {
3595 #define IS_CAPABLE(vap) \
3596         (vap->iv_bss && (vap->iv_bss->ni_ath_flags & (IEEE80211_ATHC_TURBOP )) == \
3597                 (IEEE80211_ATHC_TURBOP))
3598         struct ieee80211com *ic = vap->iv_ic;
3599         struct ath_softc *sc = netdev_priv(ic->ic_dev);
3600
3601         if (ic->ic_opmode == IEEE80211_M_HOSTAP && IS_CAPABLE(vap)) {
3602
3603                 /* Dynamic Turbo is supported on this channel. */
3604                 sc->sc_dturbo = 1;
3605                 sc->sc_dturbo_tcount = 0;
3606                 sc->sc_dturbo_switch = 0;
3607                 sc->sc_ignore_ar = 0;
3608
3609                 /* Set the initial ATHC_BOOST capability. */
3610                 if (ic->ic_bsschan->ic_flags & CHANNEL_TURBO)
3611                         ic->ic_ath_cap |=  IEEE80211_ATHC_BOOST;
3612                 else
3613                         ic->ic_ath_cap &= ~IEEE80211_ATHC_BOOST;
3614
3615                 /*
3616                  * Calculate time & bandwidth thresholds
3617                  *
3618                  * sc_dturbo_base_tmin  :  ~70 seconds
3619                  * sc_dturbo_turbo_tmax : ~120 seconds
3620                  *
3621                  * NB: scale calculated values to account for staggered
3622                  *     beacon handling
3623                  */
3624                 sc->sc_dturbo_base_tmin  = 70  * 1024 / ic->ic_lintval;
3625                 sc->sc_dturbo_turbo_tmax = 120 * 1024 / ic->ic_lintval;
3626                 sc->sc_dturbo_turbo_tmin = 5 * 1024 / ic->ic_lintval;
3627                 /* convert the thresholds from BW/sec to BW/beacon period */
3628                 sc->sc_dturbo_bw_base    = ATH_TURBO_DN_THRESH/(1024/ic->ic_lintval);  
3629                 sc->sc_dturbo_bw_turbo   = ATH_TURBO_UP_THRESH/(1024/ic->ic_lintval); 
3630                 /* time in hold state in number of beacon */
3631                 sc->sc_dturbo_hold_max   = (ATH_TURBO_PERIOD_HOLD * 1024)/ic->ic_lintval;
3632         } else {
3633                 sc->sc_dturbo = 0;
3634                 ic->ic_ath_cap &= ~IEEE80211_ATHC_BOOST;
3635         }
3636 #undef IS_CAPABLE
3637 }
3638
3639 /*
3640  * Update dynamic turbo state at SWBA.  We assume we care
3641  * called only if dynamic turbo has been enabled (sc_turbo).
3642  */
3643 static void
3644 ath_beacon_dturbo_update(struct ieee80211vap *vap, int *needmark,u_int8_t dtim)
3645 {
3646         struct ieee80211com *ic = vap->iv_ic;
3647         struct ath_softc *sc = netdev_priv(ic->ic_dev);
3648         u_int32_t bss_traffic;
3649
3650         /* TBD: Age out CHANNEL_INTERFERENCE */
3651         if (sc->sc_ignore_ar) {
3652                 /* 
3653                  * Ignore AR for this beacon; a dynamic turbo
3654                  * switch just happened and the information
3655                  * is invalid.  Notify AR support of the channel
3656                  * change.
3657                  */
3658                 sc->sc_ignore_ar = 0;
3659                 ath_hal_ar_enable(sc->sc_ah);
3660         }
3661         sc->sc_dturbo_tcount++;
3662         /*
3663          * Calculate BSS traffic over the previous interval.
3664          */
3665         bss_traffic = (sc->sc_devstats.tx_bytes + sc->sc_devstats.rx_bytes)
3666                     - sc->sc_dturbo_bytes;
3667         sc->sc_dturbo_bytes = sc->sc_devstats.tx_bytes
3668                             + sc->sc_devstats.rx_bytes;
3669         if (ic->ic_ath_cap & IEEE80211_ATHC_BOOST) {
3670                 /* 
3671                 * before switching to base mode,
3672                 * make sure that the conditions( low rssi, low bw) to switch mode 
3673                 * hold for some time and time in turbo exceeds minimum turbo time.
3674                 */
3675  
3676                 if (sc->sc_dturbo_tcount >= sc->sc_dturbo_turbo_tmin && 
3677                    sc->sc_dturbo_hold ==0 &&
3678                    (bss_traffic < sc->sc_dturbo_bw_base || !sc->sc_rate_recn_state)) {
3679                         sc->sc_dturbo_hold = 1;
3680                 } else {
3681                         if (sc->sc_dturbo_hold &&
3682                            bss_traffic >= sc->sc_dturbo_bw_turbo && sc->sc_rate_recn_state) {
3683                                 /* out of hold state */
3684                                 sc->sc_dturbo_hold = 0;
3685                                 sc->sc_dturbo_hold_count = sc->sc_dturbo_hold_max;
3686                         }
3687                 }
3688                 if (sc->sc_dturbo_hold && sc->sc_dturbo_hold_count)
3689                         sc->sc_dturbo_hold_count--;
3690                 /*
3691                  * Current Mode: Turbo (i.e. BOOST)
3692                  *
3693                  * Transition to base occurs when one of the following
3694                  * is true:
3695                  *    1. its a DTIM beacon. 
3696                  *    2. Maximum time in BOOST has elapsed (120 secs).
3697                  *    3. Channel is marked with interference
3698                  *    4. Average BSS traffic falls below 4Mbps 
3699                  *    5. RSSI cannot support at least 18 Mbps rate 
3700                  * XXX do bw checks at true beacon interval?
3701                  */
3702                 if (dtim && 
3703                         (sc->sc_dturbo_tcount >= sc->sc_dturbo_turbo_tmax ||
3704                          ((vap->iv_bss->ni_ath_flags & IEEE80211_ATHC_AR) && 
3705                           (sc->sc_curchan.privFlags & CHANNEL_INTERFERENCE) &&
3706                           IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan)) || 
3707                          !sc->sc_dturbo_hold_count)) {
3708                         DPRINTF(sc, ATH_DEBUG_TURBO, "%s: Leaving turbo\n",
3709                                         sc->sc_dev->name);
3710                         ic->ic_ath_cap &= ~IEEE80211_ATHC_BOOST;
3711                         vap->iv_bss->ni_ath_flags &= ~IEEE80211_ATHC_BOOST;
3712                         sc->sc_dturbo_tcount = 0;
3713                         sc->sc_dturbo_switch = 1;
3714                 }
3715         } else {
3716                 /*
3717                  * Current Mode: BASE
3718                  *
3719                  * Transition to Turbo (i.e. BOOST) when all of the
3720                  * following are true:
3721                  *
3722                  * 1. its a DTIM beacon. 
3723                  * 2. Dwell time at base has exceeded minimum (70 secs)
3724                  * 3. Only DT-capable stations are associated
3725                  * 4. Channel is marked interference-free.
3726                  * 5. BSS data traffic averages at least 6Mbps 
3727                  * 6. RSSI is good enough to support 36Mbps 
3728                  * XXX do bw+rssi checks at true beacon interval?
3729                  */
3730                 if (dtim && 
3731                         (sc->sc_dturbo_tcount >= sc->sc_dturbo_base_tmin &&
3732                          (ic->ic_dt_sta_assoc != 0 &&
3733                           ic->ic_sta_assoc == ic->ic_dt_sta_assoc) &&
3734                          ((vap->iv_bss->ni_ath_flags & IEEE80211_ATHC_AR) == 0 || 
3735                           (sc->sc_curchan.privFlags & CHANNEL_INTERFERENCE) == 0) &&
3736                          bss_traffic >= sc->sc_dturbo_bw_turbo && 
3737                          sc->sc_rate_recn_state)) {
3738                         DPRINTF(sc, ATH_DEBUG_TURBO, "%s: Entering turbo\n",
3739                                         sc->sc_dev->name);
3740                         ic->ic_ath_cap |= IEEE80211_ATHC_BOOST;
3741                         vap->iv_bss->ni_ath_flags |= IEEE80211_ATHC_BOOST;
3742                         sc->sc_dturbo_tcount = 0;
3743                         sc->sc_dturbo_switch = 1;
3744                         sc->sc_dturbo_hold = 0;
3745                         sc->sc_dturbo_hold_count = sc->sc_dturbo_hold_max;
3746                 }
3747         }
3748 }
3749
3750
3751 static int 
3752 ath_check_beacon_done(struct ath_softc *sc)
3753 {
3754         struct ieee80211vap *vap=NULL;
3755         struct ath_vap *avp;
3756         struct ath_buf *bf;
3757         struct ath_desc *ds;
3758         struct ath_hal *ah = sc->sc_ah;
3759         int slot;
3760
3761         /*
3762          * check if the last beacon went out with the mode change flag set.
3763          */
3764         for (slot = 0; slot < ath_maxvaps; slot++) {
3765                 if(sc->sc_bslot[slot]) { 
3766                         vap = sc->sc_bslot[slot];
3767                         break;
3768                 }
3769         }
3770         if (!vap)
3771                  return 0;
3772         avp = ATH_VAP(vap);
3773         bf = avp->av_bcbuf;
3774         ds = bf->bf_desc;
3775
3776         return (ath_hal_txprocdesc(ah, ds) != HAL_EINPROGRESS);
3777
3778 }
3779
3780 /*
3781  * Effect a turbo mode switch when operating in dynamic
3782  * turbo mode. wait for beacon to go out before switching.
3783  */
3784 static void
3785 ath_turbo_switch_mode(unsigned long data)
3786 {
3787         struct net_device *dev = (struct net_device *)data;
3788         struct ath_softc *sc = netdev_priv(dev);
3789         struct ieee80211com *ic = &sc->sc_ic;
3790         int newflags;
3791
3792         KASSERT(ic->ic_opmode == IEEE80211_M_HOSTAP,
3793                 ("unexpected operating mode %d", ic->ic_opmode));
3794
3795         DPRINTF(sc, ATH_DEBUG_STATE, "%s: dynamic turbo switch to %s mode\n",
3796                 dev->name,
3797                 ic->ic_ath_cap & IEEE80211_ATHC_BOOST ? "turbo" : "base");
3798
3799         if (!ath_check_beacon_done(sc)) {
3800                 /* 
3801                  * beacon did not go out. reschedule tasklet.
3802                  */
3803                 mod_timer(&sc->sc_dturbo_switch_mode, jiffies + msecs_to_jiffies(2));
3804                 return;
3805         }
3806
3807         /* TBD: DTIM adjustments, delay CAB queue tx until after transmit */
3808         newflags = ic->ic_bsschan->ic_flags;
3809         if (ic->ic_ath_cap & IEEE80211_ATHC_BOOST) {
3810                 if (IEEE80211_IS_CHAN_2GHZ(ic->ic_bsschan)) {
3811                         /*
3812                          * Ignore AR next beacon. the AR detection
3813                          * code detects the traffic in normal channel
3814                          * from stations during transition delays
3815                          * between AP and station.
3816                          */
3817                         sc->sc_ignore_ar = 1;
3818                         ath_hal_ar_disable(sc->sc_ah);
3819                 }
3820                 newflags |= IEEE80211_CHAN_TURBO;
3821         } else
3822                 newflags &= ~IEEE80211_CHAN_TURBO;
3823         ieee80211_dturbo_switch(ic, newflags);
3824         /* XXX ieee80211_reset_erp? */
3825 }
3826 #endif /* ATH_SUPERG_DYNTURBO */
3827
3828 /*
3829  * Setup a h/w transmit queue for beacons.
3830  */
3831 static int
3832 ath_beaconq_setup(struct ath_hal *ah)
3833 {
3834         HAL_TXQ_INFO qi;
3835
3836         memset(&qi, 0, sizeof(qi));
3837         qi.tqi_aifs = 1;
3838         qi.tqi_cwmin = 0;
3839         qi.tqi_cwmax = 0;
3840 #ifdef ATH_SUPERG_DYNTURBO
3841         qi.tqi_qflags = HAL_TXQ_TXDESCINT_ENABLE;
3842 #endif
3843         /* NB: don't enable any interrupts */
3844         return ath_hal_setuptxqueue(ah, HAL_TX_QUEUE_BEACON, &qi);
3845 }
3846
3847 /*
3848  * Configure IFS parameter for the beacon queue.
3849  */
3850 static int
3851 ath_beaconq_config(struct ath_softc *sc)
3852 {
3853 #define ATH_EXPONENT_TO_VALUE(v)        ((1<<v)-1)
3854         struct ieee80211com *ic = &sc->sc_ic;
3855         struct ath_hal *ah = sc->sc_ah;
3856         HAL_TXQ_INFO qi;
3857
3858         ath_hal_gettxqueueprops(ah, sc->sc_bhalq, &qi);
3859         if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
3860                 /*
3861                  * Always burst out beacon and CAB traffic.
3862                  */
3863                 qi.tqi_aifs = 1;
3864                 qi.tqi_cwmin = 0;
3865                 qi.tqi_cwmax = 0;
3866         } else {
3867                 struct wmeParams *wmep =
3868                         &ic->ic_wme.wme_chanParams.cap_wmeParams[WME_AC_BE];
3869                 /*
3870                  * Adhoc mode; important thing is to use 2x cwmin.
3871                  */
3872                 qi.tqi_aifs = wmep->wmep_aifsn;
3873                 qi.tqi_cwmin = 2 * ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmin);
3874                 qi.tqi_cwmax = ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmax);
3875         }
3876
3877         if (!ath_hal_settxqueueprops(ah, sc->sc_bhalq, &qi)) {
3878                 printk("%s: unable to update h/w beacon queue parameters\n",
3879                         sc->sc_dev->name);
3880                 return 0;
3881         } else {
3882                 ath_hal_resettxqueue(ah, sc->sc_bhalq); /* push to h/w */
3883                 return 1;
3884         }
3885 #undef ATH_EXPONENT_TO_VALUE
3886 }
3887
3888 /*
3889  * Allocate and setup an initial beacon frame.
3890  *
3891  * Context: softIRQ
3892  */
3893 static int
3894 ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_node *ni)
3895 {
3896         struct ath_vap *avp = ATH_VAP(ni->ni_vap);
3897         struct ieee80211_frame *wh;
3898         struct ath_buf *bf;