[svn-inject] Installing original source of madwifi (0.9.4+r4100.20090929)
[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 4005 2009-04-15 12:04:43Z 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 #ifndef AUTOCONF_INCLUDED
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 pktlen;
2498         int framecnt;
2499
2500         for (;;) {
2501                 ATH_TXQ_LOCK(txq);
2502
2503                 bf_ff = TAILQ_LAST(&txq->axq_stageq, axq_headtype);
2504                 if ((!bf_ff) || ath_ff_flushdonetest(txq, bf_ff))
2505                 {
2506                         ATH_TXQ_UNLOCK(txq);
2507                         break;
2508                 }
2509
2510                 ni = bf_ff->bf_node;
2511                 KASSERT(ATH_NODE(ni)->an_tx_ffbuf[bf_ff->bf_skb->priority],
2512                         ("no bf_ff on staging queue %p", bf_ff));
2513                 ATH_NODE(ni)->an_tx_ffbuf[bf_ff->bf_skb->priority] = NULL;
2514                 TAILQ_REMOVE(&txq->axq_stageq, bf_ff, bf_stagelist);
2515
2516                 ATH_TXQ_UNLOCK(txq);
2517
2518                 /* encap and xmit */
2519                 bf_ff->bf_skb = ieee80211_encap(ni, bf_ff->bf_skb, &framecnt);
2520                 if (bf_ff->bf_skb == NULL) {
2521                         DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
2522                                 "%s: discard, encapsulation failure\n", __func__);
2523                         sc->sc_stats.ast_tx_encap++;
2524                         goto bad;
2525                 }
2526                 pktlen = bf_ff->bf_skb->len;    /* NB: don't reference skb below */
2527                 if (ath_tx_start(sc->sc_dev, ni, bf_ff, bf_ff->bf_skb, 0) == 0)
2528                         continue;
2529         bad:
2530                 ieee80211_free_node(ni);
2531                 if (bf_ff->bf_skb != NULL) {
2532                         dev_kfree_skb(bf_ff->bf_skb);
2533                         bf_ff->bf_skb = NULL;
2534                 }
2535                 bf_ff->bf_node = NULL;
2536
2537                 ATH_TXBUF_LOCK_IRQ(sc);
2538                 STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf_ff, bf_list);
2539                 ATH_TXBUF_UNLOCK_IRQ(sc);
2540         }
2541 }
2542 #endif
2543
2544 #define ATH_HARDSTART_GET_TX_BUF_WITH_LOCK                              \
2545         ATH_TXBUF_LOCK_IRQ(sc);                                         \
2546         bf = STAILQ_FIRST(&sc->sc_txbuf);                               \
2547         if (bf != NULL) {                                               \
2548                 STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);             \
2549                 STAILQ_INSERT_TAIL(&bf_head, bf, bf_list);              \
2550         }                                                               \
2551         /* XXX use a counter and leave at least one for mgmt frames */  \
2552         if (STAILQ_EMPTY(&sc->sc_txbuf)) {                              \
2553                 DPRINTF(sc, ATH_DEBUG_XMIT,                             \
2554                         "%s: stop queue\n", __func__);                  \
2555                 sc->sc_stats.ast_tx_qstop++;                            \
2556                 netif_stop_queue(dev);                                  \
2557                 sc->sc_devstopped = 1;                                  \
2558                 ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, NULL);                \
2559         }                                                               \
2560         ATH_TXBUF_UNLOCK_IRQ(sc);                                       \
2561         if (bf == NULL) {               /* NB: should not happen */     \
2562                 DPRINTF(sc,ATH_DEBUG_XMIT,                              \
2563                         "%s: discard, no xmit buf\n", __func__);        \
2564                 sc->sc_stats.ast_tx_nobuf++;                            \
2565         }
2566
2567 /*
2568  * Transmit a data packet.  On failure caller is
2569  * assumed to reclaim the resources.
2570  *
2571  * Context: process context with BH's disabled
2572  */
2573 static int
2574 ath_hardstart(struct sk_buff *skb, struct net_device *dev)
2575 {
2576         struct ath_softc *sc = netdev_priv(dev);
2577         struct ieee80211_node *ni = NULL;
2578         struct ath_buf *bf = NULL;
2579         struct ieee80211_cb *cb = (struct ieee80211_cb *) skb->cb;
2580         struct ether_header *eh;
2581         STAILQ_HEAD(tmp_bf_head, ath_buf) bf_head;
2582         struct ath_buf *tbf, *tempbf;
2583         struct sk_buff *tskb;
2584         struct ieee80211vap *vap;
2585         int framecnt;
2586         int requeue = 0;
2587 #ifdef ATH_SUPERG_FF
2588         int pktlen;
2589         struct ieee80211com *ic = &sc->sc_ic;
2590         struct ath_node *an;
2591         struct ath_txq *txq = NULL;
2592         int ff_flush;
2593 #endif
2594
2595         if ((dev->flags & IFF_RUNNING) == 0 || sc->sc_invalid) {
2596                 DPRINTF(sc, ATH_DEBUG_XMIT,
2597                         "%s: discard, invalid %d flags %x\n",
2598                         __func__, sc->sc_invalid, dev->flags);
2599                 sc->sc_stats.ast_tx_invalid++;
2600                 return -ENETDOWN;
2601         }
2602
2603         STAILQ_INIT(&bf_head);
2604
2605         if (cb->flags & M_RAW) {
2606                 ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
2607                 if (bf == NULL)
2608                         goto hardstart_fail;
2609                 ath_tx_startraw(dev, bf,skb);
2610                 return NETDEV_TX_OK;
2611         }
2612
2613         eh = (struct ether_header *)skb->data;
2614         ni = cb->ni;            /* NB: always passed down by 802.11 layer */
2615         if (ni == NULL) {
2616                 /* NB: this happens if someone marks the underlying device up */
2617                 DPRINTF(sc, ATH_DEBUG_XMIT,
2618                         "%s: discard, no node in cb\n", __func__);
2619                 goto hardstart_fail;
2620         }
2621
2622         vap = ni->ni_vap;
2623
2624 #ifdef ATH_SUPERG_FF
2625         if (M_FLAG_GET(skb, M_UAPSD)) {
2626                 /* bypass FF handling */
2627                 ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
2628                 if (bf == NULL)
2629                         goto hardstart_fail;
2630                 goto ff_bypass;
2631         }
2632
2633         /*
2634          * Fast frames check.
2635          */
2636         ATH_FF_MAGIC_CLR(skb);
2637         an = ATH_NODE(ni);
2638
2639         txq = sc->sc_ac2q[skb->priority];
2640
2641         if (txq->axq_depth > TAIL_DROP_COUNT) {
2642                 sc->sc_stats.ast_tx_discard++;
2643                 /* queue is full, let the kernel backlog the skb */
2644                 requeue = 1;
2645                 goto hardstart_fail;
2646         }
2647
2648         /* NB: use this lock to protect an->an_ff_txbuf in athff_can_aggregate()
2649          *     call too.
2650          */
2651         ATH_TXQ_LOCK(txq);
2652         if (athff_can_aggregate(sc, eh, an, skb, vap->iv_fragthreshold, &ff_flush)) {
2653
2654                 if (an->an_tx_ffbuf[skb->priority]) { /* i.e., frame on the staging queue */
2655                         bf = an->an_tx_ffbuf[skb->priority];
2656
2657                         /* get (and remove) the frame from staging queue */
2658                         TAILQ_REMOVE(&txq->axq_stageq, bf, bf_stagelist);
2659                         an->an_tx_ffbuf[skb->priority] = NULL;
2660
2661                         ATH_TXQ_UNLOCK(txq);
2662
2663                         /*
2664                          * chain skbs and add FF magic
2665                          *
2666                          * NB: the arriving skb should not be on a list (skb->list),
2667                          *     so "re-using" the skb next field should be OK.
2668                          */
2669                         bf->bf_skb->next = skb;
2670                         skb->next = NULL;
2671                         skb = bf->bf_skb;
2672                         ATH_FF_MAGIC_PUT(skb);
2673
2674                         /* decrement extra node reference made when an_tx_ffbuf[] was set */
2675                         //ieee80211_free_node(ni); /* XXX where was it set ? */
2676
2677                         DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
2678                                 "%s: aggregating fast-frame\n", __func__);
2679                 } else {
2680                         /* NB: careful grabbing the TX_BUF lock since still holding the txq lock.
2681                          *     this could be avoided by always obtaining the txbuf earlier,
2682                          *     but the "if" portion of this "if/else" clause would then need
2683                          *     to give the buffer back.
2684                          */
2685                         ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
2686                         if (bf == NULL) {
2687                                 ATH_TXQ_UNLOCK(txq);
2688                                 goto hardstart_fail;
2689                         }
2690                         DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
2691                                 "%s: adding to fast-frame stage Q\n", __func__);
2692
2693                         bf->bf_skb = skb;
2694                         bf->bf_node = ni;
2695                         bf->bf_queueage = txq->axq_totalqueued;
2696                         an->an_tx_ffbuf[skb->priority] = bf;
2697
2698                         TAILQ_INSERT_HEAD(&txq->axq_stageq, bf, bf_stagelist);
2699
2700                         ATH_TXQ_UNLOCK(txq);
2701
2702                         return NETDEV_TX_OK;
2703                 }
2704         } else {
2705                 if (ff_flush) {
2706                         struct ath_buf *bf_ff = an->an_tx_ffbuf[skb->priority];
2707
2708                         TAILQ_REMOVE(&txq->axq_stageq, bf_ff, bf_stagelist);
2709                         an->an_tx_ffbuf[skb->priority] = NULL;
2710
2711                         ATH_TXQ_UNLOCK(txq);
2712
2713                         /* encap and xmit */
2714                         bf_ff->bf_skb = ieee80211_encap(ni, bf_ff->bf_skb, &framecnt);
2715
2716                         if (bf_ff->bf_skb == NULL) {
2717                                 DPRINTF(sc, ATH_DEBUG_XMIT,
2718                                         "%s: discard, ff flush encap failure\n",
2719                                         __func__);
2720                                 sc->sc_stats.ast_tx_encap++;
2721                                 goto ff_flushbad;
2722                         }
2723                         pktlen = bf_ff->bf_skb->len;    /* NB: don't reference skb below */
2724                         /* NB: ath_tx_start() will use ATH_TXBUF_LOCK_BH(). The _BH
2725                          *     portion is not needed here since we're running at
2726                          *     interrupt time, but should be harmless.
2727                          */
2728                         if (ath_tx_start(dev, ni, bf_ff, bf_ff->bf_skb, 0))
2729                                 goto ff_flushbad;
2730                         goto ff_flushdone;
2731                 ff_flushbad:
2732                         DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
2733                                 "%s: ff stageq flush failure\n", __func__);
2734                         ieee80211_free_node(ni);
2735                         if (bf_ff->bf_skb) {
2736                                 dev_kfree_skb(bf_ff->bf_skb);
2737                                 bf_ff->bf_skb = NULL;
2738                         }
2739                         bf_ff->bf_node = NULL;
2740
2741                         ATH_TXBUF_LOCK(sc);
2742                         STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf_ff, bf_list);
2743                         ATH_TXBUF_UNLOCK(sc);
2744                         goto ff_flushdone;
2745                 }
2746                 /*
2747                  * XXX: out-of-order condition only occurs for AP mode and multicast.
2748                  *      But, there may be no valid way to get this condition.
2749                  */
2750                 else if (an->an_tx_ffbuf[skb->priority]) {
2751                         DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
2752                                 "%s: Out-Of-Order fast-frame\n", __func__);
2753                         ATH_TXQ_UNLOCK(txq);
2754                 } else
2755                         ATH_TXQ_UNLOCK(txq);
2756
2757         ff_flushdone:
2758                 ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
2759                 if (bf == NULL)
2760                         goto hardstart_fail;
2761         }
2762
2763 ff_bypass:
2764
2765 #else /* ATH_SUPERG_FF */
2766
2767         ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
2768
2769 #endif /* ATH_SUPERG_FF */
2770
2771         /*
2772          * Encapsulate the packet for transmission.
2773          */
2774         skb = ieee80211_encap(ni, skb, &framecnt);
2775         if (skb == NULL) {
2776                 DPRINTF(sc, ATH_DEBUG_XMIT,
2777                         "%s: discard, encapsulation failure\n", __func__);
2778                 sc->sc_stats.ast_tx_encap++;
2779                 goto hardstart_fail;
2780         }
2781
2782         if (framecnt > 1) {
2783                 int bfcnt;
2784
2785                 /*
2786                 **  Allocate 1 ath_buf for each frame given 1 was 
2787                 **  already alloc'd
2788                 */
2789                 ATH_TXBUF_LOCK(sc);
2790                 for (bfcnt = 1; bfcnt < framecnt; ++bfcnt) {
2791                         if ((tbf = STAILQ_FIRST(&sc->sc_txbuf)) != NULL) {
2792                                 STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);
2793                                 STAILQ_INSERT_TAIL(&bf_head, tbf, bf_list);
2794                         }
2795                         else
2796                                 break;
2797                         
2798                         ieee80211_ref_node(ni);
2799                 }
2800
2801                 if (bfcnt != framecnt) {
2802                         if (!STAILQ_EMPTY(&bf_head)) {
2803                                 /*
2804                                 **  Failed to alloc enough ath_bufs;
2805                                 **  return to sc_txbuf list
2806                                 */
2807                                 STAILQ_FOREACH_SAFE(tbf, &bf_head, bf_list, tempbf) {
2808                                         STAILQ_INSERT_TAIL(&sc->sc_txbuf, tbf, bf_list);
2809                                 }
2810                         }
2811                         ATH_TXBUF_UNLOCK(sc);
2812                         STAILQ_INIT(&bf_head);
2813                         goto hardstart_fail;
2814                 }
2815                 ATH_TXBUF_UNLOCK(sc);
2816
2817                 while ((bf = STAILQ_FIRST(&bf_head)) != NULL && skb != NULL) {
2818                         int nextfraglen = 0;
2819
2820                         STAILQ_REMOVE_HEAD(&bf_head, bf_list);
2821                         tskb = skb->next;
2822                         skb->next = NULL;
2823                         if (tskb)
2824                                 nextfraglen = tskb->len;
2825
2826                         if (ath_tx_start(dev, ni, bf, skb, nextfraglen) != 0) {
2827                                 STAILQ_INSERT_TAIL(&bf_head, bf, bf_list);
2828                                 skb->next = tskb;
2829                                 goto hardstart_fail;
2830                         }
2831                         skb = tskb;
2832                 }
2833         } else {
2834                 if (ath_tx_start(dev, ni, bf, skb, 0) != 0) {
2835                         STAILQ_INSERT_TAIL(&bf_head, bf, bf_list);
2836                         goto hardstart_fail;
2837                 }
2838         }
2839
2840 #ifdef ATH_SUPERG_FF
2841         /*
2842          * flush out stale FF from staging Q for applicable operational modes.
2843          */
2844         /* XXX: ADHOC mode too? */
2845         if (txq && ic->ic_opmode == IEEE80211_M_HOSTAP)
2846                 ath_ffstageq_flush(sc, txq, ath_ff_ageflushtestdone);
2847 #endif
2848
2849         return NETDEV_TX_OK;
2850
2851 hardstart_fail:
2852         if (!STAILQ_EMPTY(&bf_head)) {
2853                 ATH_TXBUF_LOCK(sc);
2854                 STAILQ_FOREACH_SAFE(tbf, &bf_head, bf_list, tempbf) {
2855                         tbf->bf_skb = NULL;
2856                         tbf->bf_node = NULL;
2857                         
2858                         if (ni != NULL) 
2859                                 ieee80211_free_node(ni);
2860
2861                         STAILQ_INSERT_TAIL(&sc->sc_txbuf, tbf, bf_list);
2862                 }
2863                 ATH_TXBUF_UNLOCK(sc);
2864         }
2865         
2866         /* let the kernel requeue the skb (don't free it!) */
2867         if (requeue)
2868                 return NETDEV_TX_BUSY;
2869
2870         /* free sk_buffs */
2871         while (skb) {
2872                 tskb = skb->next;
2873                 skb->next = NULL;
2874                 dev_kfree_skb(skb);
2875                 skb = tskb;
2876         }
2877         return NETDEV_TX_OK;
2878 }
2879 #undef ATH_HARDSTART_GET_TX_BUF_WITH_LOCK
2880
2881 /*
2882  * Transmit a management frame.  On failure we reclaim the skbuff.
2883  * Note that management frames come directly from the 802.11 layer
2884  * and do not honor the send queue flow control.  Need to investigate
2885  * using priority queuing so management frames can bypass data.
2886  *
2887  * Context: hwIRQ and softIRQ
2888  */
2889 static int
2890 ath_mgtstart(struct ieee80211com *ic, struct sk_buff *skb)
2891 {
2892         struct net_device *dev = ic->ic_dev;
2893         struct ath_softc *sc = netdev_priv(dev);
2894         struct ieee80211_node *ni = NULL;
2895         struct ath_buf *bf = NULL;
2896         struct ieee80211_cb *cb;
2897         int error;
2898
2899         if ((dev->flags & IFF_RUNNING) == 0 || sc->sc_invalid) {
2900                 DPRINTF(sc, ATH_DEBUG_XMIT,
2901                         "%s: discard, invalid %d flags %x\n",
2902                         __func__, sc->sc_invalid, dev->flags);
2903                 sc->sc_stats.ast_tx_invalid++;
2904                 error = -ENETDOWN;
2905                 goto bad;
2906         }
2907         /*
2908          * Grab a TX buffer and associated resources.
2909          */
2910         ATH_TXBUF_LOCK_IRQ(sc);
2911         bf = STAILQ_FIRST(&sc->sc_txbuf);
2912         if (bf != NULL)
2913                 STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);
2914         if (STAILQ_EMPTY(&sc->sc_txbuf)) {
2915                 DPRINTF(sc, ATH_DEBUG_XMIT, "%s: stop queue\n", __func__);
2916                 sc->sc_stats.ast_tx_qstop++;
2917                 netif_stop_queue(dev);
2918                 sc->sc_devstopped=1;
2919                 ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, NULL);
2920         }
2921         ATH_TXBUF_UNLOCK_IRQ(sc);
2922         if (bf == NULL) {
2923                 printk("ath_mgtstart: discard, no xmit buf\n");
2924                 sc->sc_stats.ast_tx_nobufmgt++;
2925                 error = -ENOBUFS;
2926                 goto bad;
2927         }
2928
2929         /*
2930          * NB: the referenced node pointer is in the
2931          * control block of the sk_buff.  This is
2932          * placed there by ieee80211_mgmt_output because
2933          * we need to hold the reference with the frame.
2934          */
2935         cb = (struct ieee80211_cb *)skb->cb;
2936         ni = cb->ni;
2937         error = ath_tx_start(dev, ni, bf, skb, 0);
2938         if (error == 0) {
2939                 sc->sc_stats.ast_tx_mgmt++;
2940                 return 0;
2941         }
2942         /* fall thru... */
2943 bad:
2944         if (ni != NULL)
2945                 ieee80211_free_node(ni);
2946         if (bf != NULL) {
2947                 bf->bf_skb = NULL;
2948                 bf->bf_node = NULL;
2949
2950                 ATH_TXBUF_LOCK_IRQ(sc);
2951                 STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list);
2952                 ATH_TXBUF_UNLOCK_IRQ(sc);
2953         }
2954         dev_kfree_skb_any(skb);
2955         skb = NULL;
2956         return error;
2957 }
2958
2959 #ifdef AR_DEBUG
2960 static void
2961 ath_keyprint(struct ath_softc *sc, const char *tag, u_int ix,
2962         const HAL_KEYVAL *hk, const u_int8_t mac[IEEE80211_ADDR_LEN])
2963 {
2964         static const char *ciphers[] = {
2965                 "WEP",
2966                 "AES-OCB",
2967                 "AES-CCM",
2968                 "CKIP",
2969                 "TKIP",
2970                 "CLR",
2971         };
2972         int i, n;
2973
2974         printk("%s: [%02u] %-7s ", tag, ix, ciphers[hk->kv_type]);
2975         for (i = 0, n = hk->kv_len; i < n; i++)
2976                 printk("%02x", hk->kv_val[i]);
2977         printk(" mac %s", ether_sprintf(mac));
2978         if (hk->kv_type == HAL_CIPHER_TKIP) {
2979                 printk(" %s ", sc->sc_splitmic ? "mic" : "rxmic");
2980                 for (i = 0; i < sizeof(hk->kv_mic); i++)
2981                         printk("%02x", hk->kv_mic[i]);
2982 #if HAL_ABI_VERSION > 0x06052200
2983                 if (!sc->sc_splitmic) {
2984                         printk(" txmic ");
2985                         for (i = 0; i < sizeof(hk->kv_txmic); i++)
2986                                 printk("%02x", hk->kv_txmic[i]);
2987                 }
2988 #endif
2989         }
2990         printk("\n");
2991 }
2992 #endif
2993
2994 /*
2995  * Set a TKIP key into the hardware.  This handles the
2996  * potential distribution of key state to multiple key
2997  * cache slots for TKIP.
2998  */
2999 static int
3000 ath_keyset_tkip(struct ath_softc *sc, const struct ieee80211_key *k,
3001         HAL_KEYVAL *hk, const u_int8_t mac[IEEE80211_ADDR_LEN])
3002 {
3003 #define IEEE80211_KEY_XR        (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV)
3004         static const u_int8_t zerobssid[IEEE80211_ADDR_LEN];
3005         struct ath_hal *ah = sc->sc_ah;
3006
3007         KASSERT(k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP,
3008                 ("got a non-TKIP key, cipher %u", k->wk_cipher->ic_cipher));
3009         if ((k->wk_flags & IEEE80211_KEY_XR) == IEEE80211_KEY_XR) {
3010                 if (sc->sc_splitmic) {
3011                         /*
3012                          * TX key goes at first index, RX key at the rx index.
3013                          * The HAL handles the MIC keys at index+64.
3014                          */
3015                         memcpy(hk->kv_mic, k->wk_txmic, sizeof(hk->kv_mic));
3016                         KEYPRINTF(sc, k->wk_keyix, hk, zerobssid);
3017                         if (!ath_hal_keyset(ah, k->wk_keyix, hk, zerobssid))
3018                                 return 0;
3019
3020                         memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
3021                         KEYPRINTF(sc, k->wk_keyix+32, hk, mac);
3022                         /* XXX delete tx key on failure? */
3023                         return ath_hal_keyset(ah, k->wk_keyix+32, hk, mac);
3024                 } else {
3025                         /*
3026                          * Room for both TX+RX MIC keys in one key cache
3027                          * slot, just set key at the first index; the HAL
3028                          * will handle the reset.
3029                          */
3030                         memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
3031 #if HAL_ABI_VERSION > 0x06052200
3032                         memcpy(hk->kv_txmic, k->wk_txmic, sizeof(hk->kv_txmic));
3033 #endif
3034                         KEYPRINTF(sc, k->wk_keyix, hk, mac);
3035                         return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
3036                 }
3037         } else if (k->wk_flags & IEEE80211_KEY_XR) {
3038                 /*
3039                  * TX/RX key goes at first index.
3040                  * The HAL handles the MIC keys are index+64.
3041                  */
3042                 memcpy(hk->kv_mic, k->wk_flags & IEEE80211_KEY_XMIT ?
3043                         k->wk_txmic : k->wk_rxmic, sizeof(hk->kv_mic));
3044                 KEYPRINTF(sc, k->wk_keyix, hk, mac);
3045                 return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
3046         }
3047         return 0;
3048 #undef IEEE80211_KEY_XR
3049 }
3050
3051 /*
3052  * Set a net80211 key into the hardware.  This handles the
3053  * potential distribution of key state to multiple key
3054  * cache slots for TKIP with hardware MIC support.
3055  */
3056 static int
3057 ath_keyset(struct ath_softc *sc, const struct ieee80211_key *k,
3058         const u_int8_t mac0[IEEE80211_ADDR_LEN],
3059         struct ieee80211_node *bss)
3060 {
3061 #define N(a)    ((int)(sizeof(a)/sizeof(a[0])))
3062         static const u_int8_t ciphermap[] = {
3063                 HAL_CIPHER_WEP,         /* IEEE80211_CIPHER_WEP */
3064                 HAL_CIPHER_TKIP,        /* IEEE80211_CIPHER_TKIP */
3065                 HAL_CIPHER_AES_OCB,     /* IEEE80211_CIPHER_AES_OCB */
3066                 HAL_CIPHER_AES_CCM,     /* IEEE80211_CIPHER_AES_CCM */
3067                 (u_int8_t) -1,          /* 4 is not allocated */
3068                 HAL_CIPHER_CKIP,        /* IEEE80211_CIPHER_CKIP */
3069                 HAL_CIPHER_CLR,         /* IEEE80211_CIPHER_NONE */
3070         };
3071         struct ath_hal *ah = sc->sc_ah;
3072         const struct ieee80211_cipher *cip = k->wk_cipher;
3073         u_int8_t gmac[IEEE80211_ADDR_LEN];
3074         const u_int8_t *mac;
3075         HAL_KEYVAL hk;
3076
3077         memset(&hk, 0, sizeof(hk));
3078         /*
3079          * Software crypto uses a "clear key" so non-crypto
3080          * state kept in the key cache are maintained and
3081          * so that rx frames have an entry to match.
3082          */
3083         if ((k->wk_flags & IEEE80211_KEY_SWCRYPT) == 0) {
3084                 KASSERT(cip->ic_cipher < N(ciphermap),
3085                         ("invalid cipher type %u", cip->ic_cipher));
3086                 hk.kv_type = ciphermap[cip->ic_cipher];
3087                 hk.kv_len = k->wk_keylen;
3088                 memcpy(hk.kv_val, k->wk_key, k->wk_keylen);
3089         } else
3090                 hk.kv_type = HAL_CIPHER_CLR;
3091
3092         if ((k->wk_flags & IEEE80211_KEY_GROUP) && sc->sc_mcastkey) {
3093                 /*
3094                  * Group keys on hardware that supports multicast frame
3095                  * key search use a mac that is the sender's address with
3096                  * the high bit set instead of the app-specified address.
3097                  */
3098                 IEEE80211_ADDR_COPY(gmac, bss->ni_macaddr);
3099                 gmac[0] |= 0x80;
3100                 mac = gmac;
3101         } else
3102                 mac = mac0;
3103
3104         if (hk.kv_type == HAL_CIPHER_TKIP &&
3105             (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
3106                 return ath_keyset_tkip(sc, k, &hk, mac);
3107         } else {
3108                 KEYPRINTF(sc, k->wk_keyix, &hk, mac);
3109                 return ath_hal_keyset(ah, k->wk_keyix, &hk, mac);
3110         }
3111 #undef N
3112 }
3113
3114 /*
3115  * Allocate tx/rx key slots for TKIP.  We allocate two slots for
3116  * each key, one for decrypt/encrypt and the other for the MIC.
3117  */
3118 static u_int16_t
3119 key_alloc_2pair(struct ath_softc *sc)
3120 {
3121 #define N(a)    ((int)(sizeof(a)/sizeof(a[0])))
3122         u_int i, keyix;
3123
3124         KASSERT(sc->sc_splitmic, ("key cache !split"));
3125         /* XXX could optimize */
3126         for (i = 0; i < N(sc->sc_keymap) / 4; i++) {
3127                 u_int8_t b = sc->sc_keymap[i];
3128                 if (b != 0xff) {
3129                         /*
3130                          * One or more slots in this byte are free.
3131                          */
3132                         keyix = i * NBBY;
3133                         while (b & 1) {
3134                 again:
3135                                 keyix++;
3136                                 b >>= 1;
3137                         }
3138                         /* XXX IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV */
3139                         if (isset(sc->sc_keymap, keyix + 32) ||
3140                             isset(sc->sc_keymap, keyix + 64) ||
3141                             isset(sc->sc_keymap, keyix + 32 + 64)) {
3142                                 /* full pair unavailable */
3143                                 /* XXX statistic */
3144                                 if (keyix == (i + 1) * NBBY) {
3145                                         /* no slots were appropriate, advance */
3146                                         continue;
3147                                 }
3148                                 goto again;
3149                         }
3150                         setbit(sc->sc_keymap, keyix);
3151                         setbit(sc->sc_keymap, keyix + 64);
3152                         setbit(sc->sc_keymap, keyix + 32);
3153                         setbit(sc->sc_keymap, keyix + 32 + 64);
3154                         DPRINTF(sc, ATH_DEBUG_KEYCACHE,
3155                                 "%s: key pair %u,%u %u,%u\n",
3156                                 __func__, keyix, keyix + 64,
3157                                 keyix + 32, keyix + 32 + 64);
3158                         return keyix;
3159                 }
3160         }
3161         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of pair space\n", __func__);
3162         return IEEE80211_KEYIX_NONE;
3163 #undef N
3164 }
3165
3166 /*
3167  * Allocate tx/rx key slots for TKIP.  We allocate two slots for
3168  * each key, one for decrypt/encrypt and the other for the MIC.
3169  */
3170 static u_int16_t
3171 key_alloc_pair(struct ath_softc *sc)
3172 {
3173 #define N(a)    (sizeof(a)/sizeof(a[0]))
3174         u_int i, keyix;
3175
3176         KASSERT(!sc->sc_splitmic, ("key cache split"));
3177         /* XXX could optimize */
3178         for (i = 0; i < N(sc->sc_keymap)/4; i++) {
3179                 u_int8_t b = sc->sc_keymap[i];
3180                 if (b != 0xff) {
3181                         /*
3182                          * One or more slots in this byte are free.
3183                          */
3184                         keyix = i*NBBY;
3185                         while (b & 1) {
3186                 again:
3187                                 keyix++;
3188                                 b >>= 1;
3189                         }
3190                         if (isset(sc->sc_keymap, keyix+64)) {
3191                                 /* full pair unavailable */
3192                                 /* XXX statistic */
3193                                 if (keyix == (i+1)*NBBY) {
3194                                         /* no slots were appropriate, advance */
3195                                         continue;
3196                                 }
3197                                 goto again;
3198                         }
3199                         setbit(sc->sc_keymap, keyix);
3200                         setbit(sc->sc_keymap, keyix+64);
3201                         DPRINTF(sc, ATH_DEBUG_KEYCACHE,
3202                                 "%s: key pair %u,%u\n",
3203                                 __func__, keyix, keyix+64);
3204                         return keyix;
3205                 }
3206         }
3207         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of pair space\n", __func__);
3208         return IEEE80211_KEYIX_NONE;
3209 #undef N
3210 }
3211
3212 /*
3213  * Allocate a single key cache slot.
3214  */
3215 static u_int16_t
3216 key_alloc_single(struct ath_softc *sc)
3217 {
3218 #define N(a)    ((int)(sizeof(a)/sizeof(a[0])))
3219         u_int i, keyix;
3220
3221         /* XXX try i,i+32,i+64,i+32+64 to minimize key pair conflicts */
3222         for (i = 0; i < N(sc->sc_keymap); i++) {
3223                 u_int8_t b = sc->sc_keymap[i];
3224                 if (b != 0xff) {
3225                         /*
3226                          * One or more slots are free.
3227                          */
3228                         keyix = i * NBBY;
3229                         while (b & 1)
3230                                 keyix++, b >>= 1;
3231                         setbit(sc->sc_keymap, keyix);
3232                         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: key %u\n",
3233                                 __func__, keyix);
3234                         return keyix;
3235                 }
3236         }
3237         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of space\n", __func__);
3238         return IEEE80211_KEYIX_NONE;
3239 #undef N
3240 }
3241
3242 /*
3243  * Allocate one or more key cache slots for a unicast key.  The
3244  * key itself is needed only to identify the cipher.  For hardware
3245  * TKIP with split cipher+MIC keys we allocate two key cache slot
3246  * pairs so that we can setup separate TX and RX MIC keys.  Note
3247  * that the MIC key for a TKIP key at slot i is assumed by the
3248  * hardware to be at slot i+64.  This limits TKIP keys to the first
3249  * 64 entries.
3250  */
3251 static int
3252 ath_key_alloc(struct ieee80211vap *vap, const struct ieee80211_key *k)
3253 {
3254         struct net_device *dev = vap->iv_ic->ic_dev;
3255         struct ath_softc *sc = netdev_priv(dev);
3256
3257         /*
3258          * Group key allocation must be handled specially for
3259          * parts that do not support multicast key cache search
3260          * functionality.  For those parts the key id must match
3261          * the h/w key index so lookups find the right key.  On
3262          * parts w/ the key search facility we install the sender's
3263          * mac address (with the high bit set) and let the hardware
3264          * find the key w/o using the key id.  This is preferred as
3265          * it permits us to support multiple users for adhoc and/or
3266          * multi-station operation.
3267          */
3268         if ((k->wk_flags & IEEE80211_KEY_GROUP) && !sc->sc_mcastkey) {
3269                 int i;
3270                 u_int keyix = IEEE80211_KEYIX_NONE;
3271
3272                 for (i = 0; i < IEEE80211_WEP_NKID; i++) {
3273                         if (k == &vap->iv_nw_keys[i]) {
3274                                 keyix = i;
3275                                 break;
3276                         }
3277                 }
3278                 if (keyix == IEEE80211_KEYIX_NONE) {
3279                         /* should not happen */
3280                         DPRINTF(sc, ATH_DEBUG_KEYCACHE,
3281                                 "%s: bogus group key\n", __func__);
3282                         return IEEE80211_KEYIX_NONE;
3283                 }
3284
3285                 /*
3286                  * XXX we pre-allocate the global keys so
3287                  * have no way to check if they've already been allocated.
3288                  */
3289                 return keyix;
3290         }
3291         /*
3292          * We allocate two pair for TKIP when using the h/w to do
3293          * the MIC.  For everything else, including software crypto,
3294          * we allocate a single entry.  Note that s/w crypto requires
3295          * a pass-through slot on the 5211 and 5212.  The 5210 does
3296          * not support pass-through cache entries and we map all
3297          * those requests to slot 0.
3298          *
3299          * Allocate 1 pair of keys for WEP case. Make sure the key
3300          * is not a shared-key.
3301          */
3302         if (k->wk_flags & IEEE80211_KEY_SWCRYPT)
3303                 return key_alloc_single(sc);
3304         else if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP &&
3305                 (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
3306                 if (sc->sc_splitmic)
3307                         return key_alloc_2pair(sc);
3308                 else
3309                         return key_alloc_pair(sc);
3310         } else
3311                 return key_alloc_single(sc);
3312 }
3313
3314 /*
3315  * Delete an entry in the key cache allocated by ath_key_alloc.
3316  */
3317 static int
3318 ath_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k,
3319                                 struct ieee80211_node *ninfo)
3320 {
3321         struct net_device *dev = vap->iv_ic->ic_dev;
3322         struct ath_softc *sc = netdev_priv(dev);
3323         struct ath_hal *ah = sc->sc_ah;
3324         const struct ieee80211_cipher *cip = k->wk_cipher;
3325         struct ieee80211_node *ni;
3326         u_int keyix = k->wk_keyix;
3327         int rxkeyoff = 0;
3328
3329         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: delete key %u\n", __func__, keyix);
3330
3331         ath_hal_keyreset(ah, keyix);
3332         /*
3333          * Check the key->node map and flush any ref.
3334          */
3335         ni = sc->sc_keyixmap[keyix];
3336         if (ni != NULL) {
3337                 ieee80211_free_node(ni);
3338                 sc->sc_keyixmap[keyix] = NULL;
3339         }
3340         /*
3341          * Handle split tx/rx keying required for TKIP with h/w MIC.
3342          */
3343         if (cip->ic_cipher == IEEE80211_CIPHER_TKIP &&
3344             (k->wk_flags & IEEE80211_KEY_SWMIC) == 0 && sc->sc_splitmic) {
3345                 ath_hal_keyreset(ah, keyix + 32);       /* RX key */
3346                 ni = sc->sc_keyixmap[keyix + 32];
3347                 if (ni != NULL) {                       /* as above... */
3348                         ieee80211_free_node(ni);
3349                         sc->sc_keyixmap[keyix + 32] = NULL;
3350                 }
3351         }
3352
3353         /* Remove receive key entry if one exists for static WEP case */
3354         if (ninfo != NULL) {
3355                 rxkeyoff = ninfo->ni_rxkeyoff;
3356                 if (rxkeyoff != 0) {
3357                         ninfo->ni_rxkeyoff = 0;
3358                         ath_hal_keyreset(ah, keyix + rxkeyoff);
3359                         ni = sc->sc_keyixmap[keyix + rxkeyoff];
3360                         if (ni != NULL) {       /* as above... */
3361                                 ieee80211_free_node(ni);
3362                                 sc->sc_keyixmap[keyix + rxkeyoff] = NULL;
3363                         }
3364                 }
3365         }
3366
3367         if (keyix >= IEEE80211_WEP_NKID) {
3368                 /*
3369                  * Don't touch keymap entries for global keys so
3370                  * they are never considered for dynamic allocation.
3371                  */
3372                 clrbit(sc->sc_keymap, keyix);
3373                 if (cip->ic_cipher == IEEE80211_CIPHER_TKIP &&
3374                     (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
3375                         clrbit(sc->sc_keymap, keyix + 64);      /* TX key MIC */
3376                         if (sc->sc_splitmic) {
3377                                 /* +32 for RX key, +32+64 for RX key MIC */
3378                                 clrbit(sc->sc_keymap, keyix+32);
3379                                 clrbit(sc->sc_keymap, keyix+32+64);
3380                         }
3381                 }
3382
3383                 if (rxkeyoff != 0)
3384                         clrbit(sc->sc_keymap, keyix + rxkeyoff);/*RX Key */
3385         }
3386         return 1;
3387 }
3388
3389 /*
3390  * Set the key cache contents for the specified key.  Key cache
3391  * slot(s) must already have been allocated by ath_key_alloc.
3392  */
3393 static int
3394 ath_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k,
3395         const u_int8_t mac[IEEE80211_ADDR_LEN])
3396 {
3397         struct net_device *dev = vap->iv_ic->ic_dev;
3398         struct ath_softc *sc = netdev_priv(dev);
3399
3400         return ath_keyset(sc, k, mac, vap->iv_bss);
3401 }
3402
3403 /*
3404  * Block/unblock tx+rx processing while a key change is done.
3405  * We assume the caller serializes key management operations
3406  * so we only need to worry about synchronization with other
3407  * uses that originate in the driver.
3408  */
3409 static void
3410 ath_key_update_begin(struct ieee80211vap *vap)
3411 {
3412         struct net_device *dev = vap->iv_ic->ic_dev;
3413         struct ath_softc *sc = netdev_priv(dev);
3414
3415         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s:\n", __func__);
3416         /*
3417          * When called from the rx tasklet we cannot use
3418          * tasklet_disable because it will block waiting
3419          * for us to complete execution.
3420          *
3421          * XXX Using in_softirq is not right since we might
3422          * be called from other soft irq contexts than
3423          * ath_rx_tasklet.
3424          */
3425         if (!in_softirq())
3426                 tasklet_disable(&sc->sc_rxtq);
3427         netif_stop_queue(dev);
3428 }
3429
3430 static void
3431 ath_key_update_end(struct ieee80211vap *vap)
3432 {
3433         struct net_device *dev = vap->iv_ic->ic_dev;
3434         struct ath_softc *sc = netdev_priv(dev);
3435
3436         DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s:\n", __func__);
3437         netif_start_queue(dev);
3438         if (!in_softirq())              /* NB: see above */
3439                 tasklet_enable(&sc->sc_rxtq);
3440 }
3441
3442 /*
3443  * Calculate the receive filter according to the
3444  * operating mode and state:
3445  *
3446  * o always accept unicast, broadcast, and multicast traffic
3447  * o maintain current state of phy error reception (the HAL
3448  *   may enable phy error frames for noise immunity work)
3449  * o probe request frames are accepted only when operating in
3450  *   hostap, adhoc, or monitor modes
3451  * o enable promiscuous mode according to the interface state
3452  * o accept beacons:
3453  *   - when operating in adhoc mode so the 802.11 layer creates
3454  *     node table entries for peers,
3455  *   - when operating in station mode for collecting rssi data when
3456  *     the station is otherwise quiet, or
3457  *   - when operating as a repeater so we see repeater-sta beacons
3458  *   - when scanning
3459  */
3460 static u_int32_t
3461 ath_calcrxfilter(struct ath_softc *sc)
3462 {
3463 #define RX_FILTER_PRESERVE      (HAL_RX_FILTER_PHYERR | HAL_RX_FILTER_PHYRADAR)
3464         struct ieee80211com *ic = &sc->sc_ic;
3465         struct net_device *dev = ic->ic_dev;
3466         struct ath_hal *ah = sc->sc_ah;
3467         u_int32_t rfilt;
3468
3469         rfilt = (ath_hal_getrxfilter(ah) & RX_FILTER_PRESERVE) |
3470                  HAL_RX_FILTER_UCAST | HAL_RX_FILTER_BCAST |
3471                  HAL_RX_FILTER_MCAST;
3472         if (ic->ic_opmode != IEEE80211_M_STA)
3473                 rfilt |= HAL_RX_FILTER_PROBEREQ;
3474         if (ic->ic_opmode != IEEE80211_M_HOSTAP && (dev->flags & IFF_PROMISC))
3475                 rfilt |= HAL_RX_FILTER_PROM;
3476         if (ic->ic_opmode == IEEE80211_M_STA ||
3477             sc->sc_opmode == HAL_M_IBSS ||      /* NB: AHDEMO too */
3478             (sc->sc_nostabeacons) || sc->sc_scanning)
3479                 rfilt |= HAL_RX_FILTER_BEACON;
3480         if (sc->sc_nmonvaps > 0) 
3481                 rfilt |= (HAL_RX_FILTER_CONTROL | HAL_RX_FILTER_BEACON | 
3482                           HAL_RX_FILTER_PROBEREQ | HAL_RX_FILTER_PROM);
3483         return rfilt;
3484 #undef RX_FILTER_PRESERVE
3485 }
3486
3487 /*
3488  * Merge multicast addresses from all VAPs to form the
3489  * hardware filter.  Ideally we should only inspect our
3490  * own list and the 802.11 layer would merge for us but
3491  * that's a bit difficult so for now we put the onus on
3492  * the driver.
3493  */
3494 static void
3495 ath_merge_mcast(struct ath_softc *sc, u_int32_t mfilt[2])
3496 {
3497         struct ieee80211com *ic = &sc->sc_ic;
3498         struct ieee80211vap *vap;
3499         struct dev_mc_list *mc;
3500         u_int32_t val;
3501         u_int8_t pos;
3502
3503         mfilt[0] = mfilt[1] = 0;
3504         /* XXX locking */
3505         TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
3506                 struct net_device *dev = vap->iv_dev;
3507                 for (mc = dev->mc_list; mc; mc = mc->next) {
3508                         /* calculate XOR of eight 6-bit values */
3509                         val = LE_READ_4(mc->dmi_addr + 0);
3510                         pos = (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
3511                         val = LE_READ_4(mc->dmi_addr + 3);
3512                         pos ^= (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
3513                         pos &= 0x3f;
3514                         mfilt[pos / 32] |= (1 << (pos % 32));
3515                 }
3516         }
3517 }
3518
3519 static void
3520 ath_mode_init(struct net_device *dev)
3521 {
3522         struct ath_softc *sc = netdev_priv(dev);
3523         struct ath_hal *ah = sc->sc_ah;
3524         u_int32_t rfilt, mfilt[2];
3525
3526         /* configure rx filter */
3527         rfilt = ath_calcrxfilter(sc);
3528         ath_hal_setrxfilter(ah, rfilt);
3529
3530         /* configure bssid mask */
3531         if (sc->sc_hasbmask)
3532                 ath_hal_setbssidmask(ah, sc->sc_bssidmask);
3533
3534         /* configure operational mode */
3535         ath_hal_setopmode(ah);
3536
3537         /* calculate and install multicast filter */
3538         if ((dev->flags & IFF_ALLMULTI) == 0)
3539                 ath_merge_mcast(sc, mfilt);
3540         else
3541                 mfilt[0] = mfilt[1] = ~0;
3542         ath_hal_setmcastfilter(ah, mfilt[0], mfilt[1]);
3543         DPRINTF(sc, ATH_DEBUG_STATE,
3544              "%s: RX filter 0x%x, MC filter %08x:%08x\n",
3545              __func__, rfilt, mfilt[0], mfilt[1]);
3546 }
3547
3548 /*
3549  * Set the slot time based on the current setting.
3550  */
3551 static void
3552 ath_setslottime(struct ath_softc *sc)
3553 {
3554         struct ieee80211com *ic = &sc->sc_ic;
3555         struct ath_hal *ah = sc->sc_ah;
3556
3557         if (sc->sc_slottimeconf > 0) /* manual override */
3558                 ath_hal_setslottime(ah, sc->sc_slottimeconf);
3559         else if (ic->ic_flags & IEEE80211_F_SHSLOT)
3560                 ath_hal_setslottime(ah, HAL_SLOT_TIME_9);
3561         else
3562                 ath_hal_setslottime(ah, HAL_SLOT_TIME_20);
3563         sc->sc_updateslot = OK;
3564 }
3565
3566 /*
3567  * Callback from the 802.11 layer to update the
3568  * slot time based on the current setting.
3569  */
3570 static void
3571 ath_updateslot(struct net_device *dev)
3572 {
3573         struct ath_softc *sc = netdev_priv(dev);
3574         struct ieee80211com *ic = &sc->sc_ic;
3575
3576         /*
3577          * When not coordinating the BSS, change the hardware
3578          * immediately.  For other operation we defer the change
3579          * until beacon updates have propagated to the stations.
3580          */
3581         if (ic->ic_opmode == IEEE80211_M_HOSTAP)
3582                 sc->sc_updateslot = UPDATE;
3583         else if (dev->flags & IFF_RUNNING)
3584                 ath_setslottime(sc);
3585 }
3586
3587 #ifdef ATH_SUPERG_DYNTURBO
3588 /*
3589  * Dynamic turbo support.
3590  * XXX much of this could be moved up to the net80211 layer.
3591  */
3592
3593 /*
3594  * Configure dynamic turbo state on beacon setup.
3595  */
3596 static void
3597 ath_beacon_dturbo_config(struct ieee80211vap *vap, u_int32_t intval)
3598 {
3599 #define IS_CAPABLE(vap) \
3600         (vap->iv_bss && (vap->iv_bss->ni_ath_flags & (IEEE80211_ATHC_TURBOP )) == \
3601                 (IEEE80211_ATHC_TURBOP))
3602         struct ieee80211com *ic = vap->iv_ic;
3603         struct ath_softc *sc = netdev_priv(ic->ic_dev);
3604
3605         if (ic->ic_opmode == IEEE80211_M_HOSTAP && IS_CAPABLE(vap)) {
3606
3607                 /* Dynamic Turbo is supported on this channel. */
3608                 sc->sc_dturbo = 1;
3609                 sc->sc_dturbo_tcount = 0;
3610                 sc->sc_dturbo_switch = 0;
3611                 sc->sc_ignore_ar = 0;
3612
3613                 /* Set the initial ATHC_BOOST capability. */
3614                 if (ic->ic_bsschan->ic_flags & CHANNEL_TURBO)
3615                         ic->ic_ath_cap |=  IEEE80211_ATHC_BOOST;
3616                 else
3617                         ic->ic_ath_cap &= ~IEEE80211_ATHC_BOOST;
3618
3619                 /*
3620                  * Calculate time & bandwidth thresholds
3621                  *
3622                  * sc_dturbo_base_tmin  :  ~70 seconds
3623                  * sc_dturbo_turbo_tmax : ~120 seconds
3624                  *
3625                  * NB: scale calculated values to account for staggered
3626                  *     beacon handling
3627                  */
3628                 sc->sc_dturbo_base_tmin  = 70  * 1024 / ic->ic_lintval;
3629                 sc->sc_dturbo_turbo_tmax = 120 * 1024 / ic->ic_lintval;
3630                 sc->sc_dturbo_turbo_tmin = 5 * 1024 / ic->ic_lintval;
3631                 /* convert the thresholds from BW/sec to BW/beacon period */
3632                 sc->sc_dturbo_bw_base    = ATH_TURBO_DN_THRESH/(1024/ic->ic_lintval);  
3633                 sc->sc_dturbo_bw_turbo   = ATH_TURBO_UP_THRESH/(1024/ic->ic_lintval); 
3634                 /* time in hold state in number of beacon */
3635                 sc->sc_dturbo_hold_max   = (ATH_TURBO_PERIOD_HOLD * 1024)/ic->ic_lintval;
3636         } else {
3637                 sc->sc_dturbo = 0;
3638                 ic->ic_ath_cap &= ~IEEE80211_ATHC_BOOST;
3639         }
3640 #undef IS_CAPABLE
3641 }
3642
3643 /*
3644  * Update dynamic turbo state at SWBA.  We assume we care
3645  * called only if dynamic turbo has been enabled (sc_turbo).
3646  */
3647 static void
3648 ath_beacon_dturbo_update(struct ieee80211vap *vap, int *needmark,u_int8_t dtim)
3649 {
3650         struct ieee80211com *ic = vap->iv_ic;
3651         struct ath_softc *sc = netdev_priv(ic->ic_dev);
3652         u_int32_t bss_traffic;
3653
3654         /* TBD: Age out CHANNEL_INTERFERENCE */
3655         if (sc->sc_ignore_ar) {
3656                 /* 
3657                  * Ignore AR for this beacon; a dynamic turbo
3658                  * switch just happened and the information
3659                  * is invalid.  Notify AR support of the channel
3660                  * change.
3661                  */
3662                 sc->sc_ignore_ar = 0;
3663                 ath_hal_ar_enable(sc->sc_ah);
3664         }
3665         sc->sc_dturbo_tcount++;
3666         /*
3667          * Calculate BSS traffic over the previous interval.
3668          */
3669         bss_traffic = (sc->sc_devstats.tx_bytes + sc->sc_devstats.rx_bytes)
3670                     - sc->sc_dturbo_bytes;
3671         sc->sc_dturbo_bytes = sc->sc_devstats.tx_bytes
3672                             + sc->sc_devstats.rx_bytes;
3673         if (ic->ic_ath_cap & IEEE80211_ATHC_BOOST) {
3674                 /* 
3675                 * before switching to base mode,
3676                 * make sure that the conditions( low rssi, low bw) to switch mode 
3677                 * hold for some time and time in turbo exceeds minimum turbo time.
3678                 */
3679  
3680                 if (sc->sc_dturbo_tcount >= sc->sc_dturbo_turbo_tmin && 
3681                    sc->sc_dturbo_hold ==0 &&
3682                    (bss_traffic < sc->sc_dturbo_bw_base || !sc->sc_rate_recn_state)) {
3683                         sc->sc_dturbo_hold = 1;
3684                 } else {
3685                         if (sc->sc_dturbo_hold &&
3686                            bss_traffic >= sc->sc_dturbo_bw_turbo && sc->sc_rate_recn_state) {
3687                                 /* out of hold state */
3688                                 sc->sc_dturbo_hold = 0;
3689                                 sc->sc_dturbo_hold_count = sc->sc_dturbo_hold_max;
3690                         }
3691                 }
3692                 if (sc->sc_dturbo_hold && sc->sc_dturbo_hold_count)
3693                         sc->sc_dturbo_hold_count--;
3694                 /*
3695                  * Current Mode: Turbo (i.e. BOOST)
3696                  *
3697                  * Transition to base occurs when one of the following
3698                  * is true:
3699                  *    1. its a DTIM beacon. 
3700                  *    2. Maximum time in BOOST has elapsed (120 secs).
3701                  *    3. Channel is marked with interference
3702                  *    4. Average BSS traffic falls below 4Mbps 
3703                  *    5. RSSI cannot support at least 18 Mbps rate 
3704                  * XXX do bw checks at true beacon interval?
3705                  */
3706                 if (dtim && 
3707                         (sc->sc_dturbo_tcount >= sc->sc_dturbo_turbo_tmax ||
3708                          ((vap->iv_bss->ni_ath_flags & IEEE80211_ATHC_AR) && 
3709                           (sc->sc_curchan.privFlags & CHANNEL_INTERFERENCE) &&
3710                           IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan)) || 
3711                          !sc->sc_dturbo_hold_count)) {
3712                         DPRINTF(sc, ATH_DEBUG_TURBO, "%s: Leaving turbo\n",
3713                                         sc->sc_dev->name);
3714                         ic->ic_ath_cap &= ~IEEE80211_ATHC_BOOST;
3715                         vap->iv_bss->ni_ath_flags &= ~IEEE80211_ATHC_BOOST;
3716                         sc->sc_dturbo_tcount = 0;
3717                         sc->sc_dturbo_switch = 1;
3718                 }
3719         } else {
3720                 /*
3721                  * Current Mode: BASE
3722                  *
3723                  * Transition to Turbo (i.e. BOOST) when all of the
3724                  * following are true:
3725                  *
3726                  * 1. its a DTIM beacon. 
3727                  * 2. Dwell time at base has exceeded minimum (70 secs)
3728                  * 3. Only DT-capable stations are associated
3729                  * 4. Channel is marked interference-free.
3730                  * 5. BSS data traffic averages at least 6Mbps 
3731                  * 6. RSSI is good enough to support 36Mbps 
3732                  * XXX do bw+rssi checks at true beacon interval?
3733                  */
3734                 if (dtim && 
3735                         (sc->sc_dturbo_tcount >= sc->sc_dturbo_base_tmin &&
3736                          (ic->ic_dt_sta_assoc != 0 &&
3737                           ic->ic_sta_assoc == ic->ic_dt_sta_assoc) &&
3738                          ((vap->iv_bss->ni_ath_flags & IEEE80211_ATHC_AR) == 0 || 
3739                           (sc->sc_curchan.privFlags & CHANNEL_INTERFERENCE) == 0) &&
3740                          bss_traffic >= sc->sc_dturbo_bw_turbo && 
3741                          sc->sc_rate_recn_state)) {
3742                         DPRINTF(sc, ATH_DEBUG_TURBO, "%s: Entering turbo\n",
3743                                         sc->sc_dev->name);
3744                         ic->ic_ath_cap |= IEEE80211_ATHC_BOOST;
3745                         vap->iv_bss->ni_ath_flags |= IEEE80211_ATHC_BOOST;
3746                         sc->sc_dturbo_tcount = 0;
3747                         sc->sc_dturbo_switch = 1;
3748                         sc->sc_dturbo_hold = 0;
3749                         sc->sc_dturbo_hold_count = sc->sc_dturbo_hold_max;
3750                 }
3751         }
3752 }
3753
3754
3755 static int 
3756 ath_check_beacon_done(struct ath_softc *sc)
3757 {
3758         struct ieee80211vap *vap=NULL;
3759         struct ath_vap *avp;
3760         struct ath_buf *bf;
3761         struct sk_buff *skb;
3762         struct ath_desc *ds;
3763         struct ath_hal *ah = sc->sc_ah;
3764         int slot;
3765
3766         /*
3767          * check if the last beacon went out with the mode change flag set.
3768          */
3769         for (slot = 0; slot < ath_maxvaps; slot++) {
3770                 if(sc->sc_bslot[slot]) { 
3771                         vap = sc->sc_bslot[slot];
3772                         break;
3773                 }
3774         }
3775         if (!vap)
3776                  return 0;
3777         avp = ATH_VAP(vap);
3778         bf = avp->av_bcbuf;
3779         skb = bf->bf_skb;
3780         ds = bf->bf_desc;
3781
3782         return (ath_hal_txprocdesc(ah, ds) != HAL_EINPROGRESS);
3783
3784 }
3785
3786 /*
3787  * Effect a turbo mode switch when operating in dynamic
3788  * turbo mode. wait for beacon to go out before switching.
3789  */
3790 static void
3791 ath_turbo_switch_mode(unsigned long data)
3792 {
3793         struct net_device *dev = (struct net_device *)data;
3794         struct ath_softc *sc = netdev_priv(dev);
3795         struct ieee80211com *ic = &sc->sc_ic;
3796         int newflags;
3797
3798         KASSERT(ic->ic_opmode == IEEE80211_M_HOSTAP,
3799                 ("unexpected operating mode %d", ic->ic_opmode));
3800
3801         DPRINTF(sc, ATH_DEBUG_STATE, "%s: dynamic turbo switch to %s mode\n",
3802                 dev->name,
3803                 ic->ic_ath_cap & IEEE80211_ATHC_BOOST ? "turbo" : "base");
3804
3805         if (!ath_check_beacon_done(sc)) {
3806                 /* 
3807                  * beacon did not go out. reschedule tasklet.
3808                  */
3809                 mod_timer(&sc->sc_dturbo_switch_mode, jiffies + msecs_to_jiffies(2));
3810                 return;
3811         }
3812
3813         /* TBD: DTIM adjustments, delay CAB queue tx until after transmit */
3814         newflags = ic->ic_bsschan->ic_flags;
3815         if (ic->ic_ath_cap & IEEE80211_ATHC_BOOST) {
3816                 if (IEEE80211_IS_CHAN_2GHZ(ic->ic_bsschan)) {
3817                         /*
3818                          * Ignore AR next beacon. the AR detection
3819                          * code detects the traffic in normal channel
3820                          * from stations during transition delays
3821                          * between AP and station.
3822                          */
3823                         sc->sc_ignore_ar = 1;
3824                         ath_hal_ar_disable(sc->sc_ah);
3825                 }
3826                 newflags |= IEEE80211_CHAN_TURBO;
3827         } else
3828                 newflags &= ~IEEE80211_CHAN_TURBO;
3829         ieee80211_dturbo_switch(ic, newflags);
3830         /* XXX ieee80211_reset_erp? */
3831 }
3832 #endif /* ATH_SUPERG_DYNTURBO */
3833
3834 /*
3835  * Setup a h/w transmit queue for beacons.
3836  */
3837 static int
3838 ath_beaconq_setup(struct ath_hal *ah)
3839 {
3840         HAL_TXQ_INFO qi;
3841
3842         memset(&qi, 0, sizeof(qi));
3843         qi.tqi_aifs = 1;
3844         qi.tqi_cwmin = 0;
3845         qi.tqi_cwmax = 0;
3846 #ifdef ATH_SUPERG_DYNTURBO
3847         qi.tqi_qflags = HAL_TXQ_TXDESCINT_ENABLE;
3848 #endif
3849         /* NB: don't enable any interrupts */
3850         return ath_hal_setuptxqueue(ah, HAL_TX_QUEUE_BEACON, &qi);
3851 }
3852
3853 /*
3854  * Configure IFS parameter for the beacon queue.
3855  */
3856 static int
3857 ath_beaconq_config(struct ath_softc *sc)
3858 {
3859 #define ATH_EXPONENT_TO_VALUE(v)        ((1<<v)-1)
3860         struct ieee80211com *ic = &sc->sc_ic;
3861         struct ath_hal *ah = sc->sc_ah;
3862         HAL_TXQ_INFO qi;
3863
3864         ath_hal_gettxqueueprops(ah, sc->sc_bhalq, &qi);
3865         if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
3866                 /*
3867                  * Always burst out beacon and CAB traffic.
3868                  */
3869                 qi.tqi_aifs = 1;
3870                 qi.tqi_cwmin = 0;
3871                 qi.tqi_cwmax = 0;
3872         } else {
3873                 struct wmeParams *wmep =
3874                         &ic->ic_wme.wme_chanParams.cap_wmeParams[WME_AC_BE];
3875                 /*
3876                  * Adhoc mode; important thing is to use 2x cwmin.
3877                  */
3878                 qi.tqi_aifs = wmep->wmep_aifsn;
3879                 qi.tqi_cwmin = 2 * ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmin);
3880                 qi.tqi_cwmax = ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmax);
3881         }
3882
3883         if (!ath_hal_settxqueueprops(ah, sc->sc_bhalq, &qi)) {
3884                 printk("%s: unable to update h/w beacon queue parameters\n",
3885                         sc->sc_dev->name);
3886                 return 0;
3887         } else {
3888                 ath_hal_resettxqueue(ah, sc->sc_bhalq); /* push to h/w */
3889                 return 1;
3890         }
3891 #undef ATH_EXPONENT_TO_VALUE
3892 }
3893
3894 /*
3895  * Allocate and setup an initial beacon frame.