Documentation/cImages/baseline-2.4.ndz: patch-02-adhoc-beacon.diff

File patch-02-adhoc-beacon.diff, 461.0 KB (added by mcgrof, 12 years ago)

adhoc beacon fix for madwifi-0.9.3.3

  • madwifi-0.9.3.3

    Ad-hoc mode beacons are not transmitted for a while after a merge
    with another network.
    
    http://madwifi.org/ticket/1033
    
    This patch was rebased for madwifi-0.9.3.1
    
    Signed-Off by: Luis Rodriguez <mcgrof@winlab.rutgers.edu>
    
    diff -Naurp madwifi-0.9.3.3.old/ath/if_ath.c madwifi-0.9.3.3/ath/if_ath.c
    old new ath_beacon_free(struct ath_softc *sc) 
    44264426 * the beacon miss handling so we'll receive a BMISS
    44274427 * interrupt when we stop seeing beacons from the AP
    44284428 * we've associated with.
     4429 *
     4430 * Note : TBTT is Target Beacon Transmission Time (see IEEE
     4431 * 802.11-1999: 4 & 11.2.1.3).
    44294432 */
    44304433static void
    44314434ath_beacon_config(struct ath_softc *sc, struct ieee80211vap *vap)
    ath_beacon_config(struct ath_softc *sc,  
    44354438        struct ieee80211com *ic = &sc->sc_ic;
    44364439        struct ath_hal *ah = sc->sc_ah;
    44374440        struct ieee80211_node *ni;
    4438         u_int32_t nexttbtt, intval;
     4441        u_int32_t nexttbtt = 0;
     4442        u_int32_t intval;
     4443        u_int64_t tsf, hw_tsf;
     4444        u_int32_t tsftu, hw_tsftu;
     4445        int reset_tsf = 0;
    44394446
    44404447        if (vap == NULL)
    44414448                vap = TAILQ_FIRST(&ic->ic_vaps);   /* XXX */
    44424449
    44434450        ni = vap->iv_bss;
    44444451
    4445         /* extract tstamp from last beacon and convert to TU */
    4446         nexttbtt = TSF_TO_TU(LE_READ_4(ni->ni_tstamp.data + 4),
    4447                              LE_READ_4(ni->ni_tstamp.data));
    4448         /* XXX conditionalize multi-bss support? */
     4452        hw_tsf = ath_hal_gettsf64(ah);
     4453        tsf = le64_to_cpu(ni->ni_tstamp.tsf);
     4454        hw_tsftu = hw_tsf >> 10;
     4455        tsftu = tsf >> 10;
     4456
     4457        /* We should reset hw TSF only once, so we increment
     4458         * ni_tstamp.tsf to avoid resetting the hw TSF multiple
     4459         * times */
     4460
     4461        if (tsf == 0) {
     4462                reset_tsf = 1;
     4463                ni->ni_tstamp.tsf = cpu_to_le64(1);
     4464        }
     4465
     4466        /* XXX: Conditionalize multi-bss support? */
    44494467        if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
    4450                 /*
    4451                  * For multi-bss ap support beacons are either staggered
     4468                /* For multi-bss ap support beacons are either staggered
    44524469                 * evenly over N slots or burst together.  For the former
    44534470                 * arrange for the SWBA to be delivered for each slot.
    4454                  * Slots that are not occupied will generate nothing.
    4455                  */
     4471                 * Slots that are not occupied will generate nothing. */
    44564472                /* NB: the beacon interval is kept internally in TU's */
    44574473                intval = ic->ic_lintval & HAL_BEACON_PERIOD;
    44584474                if (sc->sc_stagbeacons)
    44594475                        intval /= ATH_BCBUF;    /* for staggered beacons */
    44604476                if ((sc->sc_nostabeacons) &&
    4461                     (vap->iv_opmode == IEEE80211_M_HOSTAP))
    4462                         nexttbtt = 0;
     4477                        (vap->iv_opmode == IEEE80211_M_HOSTAP))
     4478                        reset_tsf = 1;
    44634479        } else
    44644480                intval = ni->ni_intval & HAL_BEACON_PERIOD;
    4465         if (nexttbtt == 0)              /* e.g. for ap mode */
     4481
     4482#define        FUDGE   2
     4483        sc->sc_syncbeacon = 0;
     4484
     4485        if (reset_tsf) {
     4486                /* We just created the interface and TSF will be reset to
     4487                * zero, so next beacon will be sent at the next intval
     4488                * time */
    44664489                nexttbtt = intval;
    4467         else if (intval)                /* NB: can be 0 for monitor mode */
    4468                 nexttbtt = roundup(nexttbtt, intval);
    4469         DPRINTF(sc, ATH_DEBUG_BEACON, "%s: nexttbtt %u intval %u (%u)\n",
    4470                 __func__, nexttbtt, intval, ni->ni_intval);
     4490        } else if (intval) {    /* NB: can be 0 for monitor mode */
     4491                if (tsf == 1) {
     4492                        /* We have not received any beacons or probe responses.
     4493                        * The next TBTT must be at least FUDGE ms ahead of the
     4494                        * hw_tsftu. Also, TSF == 0 is a TBTT - IEEE802.11-1999
     4495                        * 11.1.2.2, although I'm not sure it applies here... */
     4496                        nexttbtt = roundup(hw_tsftu + FUDGE, intval);
     4497                } else {
     4498                        if (tsf > hw_tsf) {
     4499                                /* We received a beacon, but the HW TSF has
     4500                                * not been updated (otherwise hw_tsf > tsf).
     4501                                * We cannot use the hardware TSF, so we wait
     4502                                * to synchronise beacons again. */
     4503                                sc->sc_syncbeacon = 1;
     4504                                goto ath_beacon_config_debug;
     4505                        } else {
     4506                                /* Normal case: we received a beacon to which
     4507                                * we have synchornised. Make sure that
     4508                                * nexttbtt is at least FUDGE ms ahead of
     4509                                * hw_tsf. */
     4510                                nexttbtt = tsftu + roundup(hw_tsftu +
     4511                                FUDGE - tsftu, intval);
     4512                        }
     4513                }
     4514        }
     4515
    44714516        if (ic->ic_opmode == IEEE80211_M_STA && !(sc->sc_nostabeacons)) {
    44724517                HAL_BEACON_STATE bs;
    4473                 u_int64_t tsf;
    4474                 u_int32_t tsftu;
    44754518                int dtimperiod, dtimcount;
    44764519                int cfpperiod, cfpcount;
    44774520
    4478                 /*
    4479                  * Setup dtim and cfp parameters according to
    4480                  * last beacon we received (which may be none).
    4481                  */
     4521                /* Setup DTIM and CFP parameters according to the last beacon
     4522                 * we have received (which may not have happened). */
    44824523                dtimperiod = vap->iv_dtim_period;
    44834524                if (dtimperiod <= 0)            /* NB: 0 if not known */
    44844525                        dtimperiod = 1;
    ath_beacon_config(struct ath_softc *sc,  
    44874528                        dtimcount = 0;          /* XXX? */
    44884529                cfpperiod = 1;                  /* NB: no PCF support yet */
    44894530                cfpcount = 0;
    4490 #define FUDGE   2
    44914531                /*
    44924532                 * Pull nexttbtt forward to reflect the current
    44934533                 * TSF and calculate dtim+cfp state for the result.
    44944534                 */
    4495                 tsf = ath_hal_gettsf64(ah);
    4496                 tsftu = TSF_TO_TU(tsf>>32, tsf) + FUDGE;
     4535                nexttbtt = tsftu;
     4536                if (nexttbtt == 0)              /* e.g. for ap mode */
     4537                        nexttbtt = intval;
    44974538                do {
    44984539                        nexttbtt += intval;
    44994540                        if (--dtimcount < 0) {
    ath_beacon_config(struct ath_softc *sc,  
    45014542                                if (--cfpcount < 0)
    45024543                                        cfpcount = cfpperiod - 1;
    45034544                        }
    4504                 } while (nexttbtt < tsftu);
     4545                } while (nexttbtt < hw_tsftu + FUDGE);
    45054546#undef FUDGE
    45064547                memset(&bs, 0, sizeof(bs));
    45074548                bs.bs_intval = intval;
    ath_beacon_config(struct ath_softc *sc,  
    45754616                ath_hal_intrset(ah, sc->sc_imask);
    45764617        } else {
    45774618                ath_hal_intrset(ah, 0);
    4578                 if (nexttbtt == intval)
     4619                if (reset_tsf)
    45794620                        intval |= HAL_BEACON_RESET_TSF;
    45804621                if (ic->ic_opmode == IEEE80211_M_IBSS) {
    45814622                        /*
    ath_beacon_config(struct ath_softc *sc,  
    46124653                if (ic->ic_opmode == IEEE80211_M_IBSS && sc->sc_hasveol)
    46134654                        ath_beacon_start_adhoc(sc, vap);
    46144655        }
    4615         sc->sc_syncbeacon = 0;
    46164656#undef TSF_TO_TU
     4657
     4658        ath_beacon_config_debug:
     4659        /* We print all debug messages here, in order to preserve the
     4660         * time critical aspect of this function */
     4661        DPRINTF(sc, ATH_DEBUG_BEACON,
     4662                "%s: ni=%p tsf=%llu hw_tsf=%llu tsftu=%u hw_tsftu=%u\n",
     4663                __func__, ni, tsf, hw_tsf, tsftu, hw_tsftu);
     4664
     4665        if (reset_tsf)
     4666                /* We just created the interface */
     4667                DPRINTF(sc, ATH_DEBUG_BEACON, "%s: first beacon\n", __func__);
     4668        else if (tsf == 1)
     4669                /* We do not receive any beacons or probe response */
     4670                DPRINTF(sc, ATH_DEBUG_BEACON,
     4671                                "%s: no beacon received...\n",__func__);
     4672        else if (tsf > hw_tsf)
     4673                /* We do receive a beacon and the hw TSF has not been updated */
     4674                DPRINTF(sc, ATH_DEBUG_BEACON,
     4675                                "%s: beacon received, but TSF is incorrect\n",
     4676                                __func__);
     4677        else
     4678                /* We do receive a beacon in the past, normal case */
     4679                DPRINTF(sc, ATH_DEBUG_BEACON,
     4680                                "%s: beacon received, TSF is correct\n",
     4681                                __func__);
     4682
     4683        DPRINTF(sc, ATH_DEBUG_BEACON, "%s: nexttbtt=%u intval=%u\n",
     4684                __func__, nexttbtt, intval & HAL_BEACON_PERIOD);
    46174685}
    46184686
    46194687static int
    ath_recv_mgmt(struct ieee80211_node *ni, 
    54425510        struct ath_softc *sc = ni->ni_ic->ic_dev->priv;
    54435511        struct ieee80211vap *vap = ni->ni_vap;
    54445512
    5445         /*
    5446          * Call up first so subsequent work can use information
    5447          * potentially stored in the node (e.g. for ibss merge).
    5448          */
     5513        /* Call up first so subsequent work can use information
     5514         * potentially stored in the node (e.g. for ibss merge). */
    54495515        sc->sc_recv_mgmt(ni, skb, subtype, rssi, rstamp);
    54505516        switch (subtype) {
    54515517        case IEEE80211_FC0_SUBTYPE_BEACON:
    5452                 /* update rssi statistics for use by the HAL */
     5518                /* Update RSSI statistics for use by the HAL */
    54535519                ATH_RSSI_LPF(ATH_NODE(ni)->an_halstats.ns_avgbrssi, rssi);
    54545520                if ((sc->sc_syncbeacon || (vap->iv_flags_ext & IEEE80211_FEXT_APPIE_UPDATE)) &&
    54555521                    ni == vap->iv_bss && vap->iv_state == IEEE80211_S_RUN) {
    5456                         /*
    5457                          * Resync beacon timers using the tsf of the
    5458                          * beacon frame we just received.
    5459                          */
     5522                        /* Resync beacon timers using the TSF of the
     5523                         * beacon frame we just received. */
    54605524                        vap->iv_flags_ext &= ~IEEE80211_FEXT_APPIE_UPDATE;
    54615525                        ath_beacon_config(sc, vap);
    54625526                }
    5463                 /* fall thru... */
     5527                /* NB: Fall Through */
    54645528        case IEEE80211_FC0_SUBTYPE_PROBE_RESP:
    54655529                if (vap->iv_opmode == IEEE80211_M_IBSS &&
    5466                     vap->iv_state == IEEE80211_S_RUN) {
    5467                         u_int64_t tsf = ath_extend_tsf(sc->sc_ah, rstamp);
    5468                         /*
    5469                          * Handle ibss merge as needed; check the tsf on the
     5530                                vap->iv_state == IEEE80211_S_RUN) {
     5531                        /* Don't merge if we have a desired BSSID */
     5532                        if (vap->iv_flags & IEEE80211_F_DESBSSID)
     5533                                break;
     5534
     5535                        /* To handle IBSS merge, we need the struct
     5536                         * ieee80211_node which has been updated with the
     5537                         * BSSID and TSF from the last beacon */
     5538                        ni = ieee80211_find_rxnode(ni->ni_ic,
     5539                                (const struct ieee80211_frame_min *) skb->data);
     5540                        if (ni == NULL)
     5541                                break;
     5542
     5543                        /* Handle IBSS merge as needed; check the TSF on the
    54705544                         * frame before attempting the merge.  The 802.11 spec
    54715545                         * says the station should change it's bssid to match
    54725546                         * the oldest station with the same ssid, where oldest
    54735547                         * is determined by the tsf.  Note that hardware
    54745548                         * reconfiguration happens through callback to
    54755549                         * ath_newstate as the state machine will go from
    5476                          * RUN -> RUN when this happens.
    5477                          */
    5478                         /* jal: added: don't merge if we have a desired
    5479                            BSSID */
    5480                         if (!(vap->iv_flags & IEEE80211_F_DESBSSID) &&
    5481                                 le64_to_cpu(ni->ni_tstamp.tsf) >= tsf) {
    5482                                 DPRINTF(sc, ATH_DEBUG_STATE,
    5483                                         "ibss merge, rstamp %u tsf %llu "
    5484                                         "tstamp %llu\n", rstamp, (long long) tsf,
    5485                                         (long long) le64_to_cpu(ni->ni_tstamp.tsf));
    5486                                 (void) ieee80211_ibss_merge(ni);
     5550                         * RUN -> RUN when this happens. */
     5551                        DPRINTF(sc, ATH_DEBUG_BEACON,
     5552                                "check for ibss merge for ni=%p TSF1(t4)=%10u TSF2(t3)=%10llu\n",
     5553                                ni, rstamp, le64_to_cpu(ni->ni_tstamp.tsf));
     5554
     5555                        if (rstamp < le64_to_cpu(ni->ni_tstamp.tsf)) {
     5556                                DPRINTF(sc, ATH_DEBUG_BEACON,
     5557                                "ibss merge, rstamp %10u local tsf %10llu\n",
     5558                                rstamp, le64_to_cpu(ni->ni_tstamp.tsf));
     5559                                ieee80211_ibss_merge(ni);
    54875560                        }
    54885561                }
    54895562                break;
  • ath/if_ath.c.orig

    diff -Naurp madwifi-0.9.3.3.old/ath/if_ath.c.orig madwifi-0.9.3.3/ath/if_ath.c.orig
    old new  
     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 2616 2007-07-26 13:42:40Z mrenzmann $
     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
     112enum {
     113        ATH_LED_TX,
     114        ATH_LED_RX,
     115        ATH_LED_POLL,
     116};
     117
     118static struct ieee80211vap *ath_vap_create(struct ieee80211com *,
     119        const char *, int, int, int, struct net_device *);
     120static void ath_vap_delete(struct ieee80211vap *);
     121static int ath_init(struct net_device *);
     122static int ath_set_ack_bitrate(struct ath_softc *, int);
     123static int ath_reset(struct net_device *);
     124static void ath_fatal_tasklet(TQUEUE_ARG);
     125static void ath_rxorn_tasklet(TQUEUE_ARG);
     126static void ath_bmiss_tasklet(TQUEUE_ARG);
     127static void ath_bstuck_tasklet(TQUEUE_ARG);
     128static void ath_radar_task(struct work_struct *);
     129static void ath_dfs_test_return(unsigned long);
     130
     131static int ath_stop_locked(struct net_device *);
     132static int ath_stop(struct net_device *);
     133#if 0
     134static void ath_initkeytable(struct ath_softc *);
     135#endif
     136static int ath_key_alloc(struct ieee80211vap *, const struct ieee80211_key *);
     137static int ath_key_delete(struct ieee80211vap *, const struct ieee80211_key *,
     138        struct ieee80211_node *);
     139static int ath_key_set(struct ieee80211vap *, const struct ieee80211_key *,
     140        const u_int8_t mac[IEEE80211_ADDR_LEN]);
     141static void ath_key_update_begin(struct ieee80211vap *);
     142static void ath_key_update_end(struct ieee80211vap *);
     143static void ath_mode_init(struct net_device *);
     144static void ath_setslottime(struct ath_softc *);
     145static void ath_updateslot(struct net_device *);
     146static int ath_beaconq_setup(struct ath_hal *);
     147static int ath_beacon_alloc(struct ath_softc *, struct ieee80211_node *);
     148#ifdef ATH_SUPERG_DYNTURBO
     149static void ath_beacon_dturbo_update(struct ieee80211vap *, int *, u_int8_t);
     150static void ath_beacon_dturbo_config(struct ieee80211vap *, u_int32_t);
     151static void ath_turbo_switch_mode(unsigned long);
     152static int ath_check_beacon_done(struct ath_softc *);
     153#endif
     154static void ath_beacon_send(struct ath_softc *, int *);
     155static void ath_beacon_start_adhoc(struct ath_softc *, struct ieee80211vap *);
     156static void ath_beacon_return(struct ath_softc *, struct ath_buf *);
     157static void ath_beacon_free(struct ath_softc *);
     158static void ath_beacon_config(struct ath_softc *, struct ieee80211vap *);
     159static int ath_desc_alloc(struct ath_softc *);
     160static void ath_desc_free(struct ath_softc *);
     161static void ath_desc_swap(struct ath_desc *);
     162static struct ieee80211_node *ath_node_alloc(struct ieee80211_node_table *,
     163        struct ieee80211vap *);
     164static void ath_node_cleanup(struct ieee80211_node *);
     165static void ath_node_free(struct ieee80211_node *);
     166static u_int8_t ath_node_getrssi(const struct ieee80211_node *);
     167static int ath_rxbuf_init(struct ath_softc *, struct ath_buf *);
     168static void ath_recv_mgmt(struct ieee80211_node *, struct sk_buff *, int,
     169        int, u_int32_t);
     170static void ath_setdefantenna(struct ath_softc *, u_int);
     171static struct ath_txq *ath_txq_setup(struct ath_softc *, int, int);
     172static void ath_rx_tasklet(TQUEUE_ARG);
     173static int ath_hardstart(struct sk_buff *, struct net_device *);
     174static int ath_mgtstart(struct ieee80211com *, struct sk_buff *);
     175#ifdef ATH_SUPERG_COMP
     176static u_int32_t ath_get_icvlen(struct ieee80211_key *);
     177static u_int32_t ath_get_ivlen(struct ieee80211_key *);
     178static void ath_setup_comp(struct ieee80211_node *, int);
     179static void ath_comp_set(struct ieee80211vap *, struct ieee80211_node *, int); 
     180#endif
     181static int ath_tx_setup(struct ath_softc *, int, int);
     182static int ath_wme_update(struct ieee80211com *);
     183static void ath_uapsd_flush(struct ieee80211_node *);
     184static void ath_tx_cleanupq(struct ath_softc *, struct ath_txq *);
     185static void ath_tx_cleanup(struct ath_softc *);
     186static void ath_tx_uapsdqueue(struct ath_softc *, struct ath_node *,
     187        struct ath_buf *);
     188
     189static int ath_tx_start(struct net_device *, struct ieee80211_node *,
     190        struct ath_buf *, struct sk_buff *, int);
     191static void ath_tx_tasklet_q0(TQUEUE_ARG);
     192static void ath_tx_tasklet_q0123(TQUEUE_ARG);
     193static void ath_tx_tasklet(TQUEUE_ARG);
     194static void ath_tx_timeout(struct net_device *);
     195static void ath_tx_draintxq(struct ath_softc *, struct ath_txq *);
     196static int ath_chan_set(struct ath_softc *, struct ieee80211_channel *);
     197static void ath_draintxq(struct ath_softc *);
     198static __inline void ath_tx_txqaddbuf(struct ath_softc *, struct ieee80211_node *,
     199        struct ath_txq *, struct ath_buf *, struct ath_desc *, int);
     200static void ath_stoprecv(struct ath_softc *);
     201static int ath_startrecv(struct ath_softc *);
     202static void ath_flushrecv(struct ath_softc *);
     203static void ath_chan_change(struct ath_softc *, struct ieee80211_channel *);
     204static void ath_calibrate(unsigned long);
     205static int ath_newstate(struct ieee80211vap *, enum ieee80211_state, int);
     206
     207static void ath_scan_start(struct ieee80211com *);
     208static void ath_scan_end(struct ieee80211com *);
     209static void ath_set_channel(struct ieee80211com *);
     210static void ath_set_coverageclass(struct ieee80211com *);
     211static u_int ath_mhz2ieee(struct ieee80211com *, u_int, u_int);
     212#ifdef ATH_SUPERG_FF
     213static int athff_can_aggregate(struct ath_softc *, struct ether_header *,
     214        struct ath_node *, struct sk_buff *, u_int16_t, int *);
     215#endif
     216static struct net_device_stats *ath_getstats(struct net_device *);
     217static void ath_setup_stationkey(struct ieee80211_node *);
     218static void ath_setup_stationwepkey(struct ieee80211_node *);
     219static void ath_setup_keycacheslot(struct ath_softc *, struct ieee80211_node *);
     220static void ath_newassoc(struct ieee80211_node *, int);
     221static int ath_getchannels(struct net_device *, u_int, HAL_BOOL, HAL_BOOL);
     222static void ath_led_event(struct ath_softc *, int);
     223static void ath_update_txpow(struct ath_softc *);
     224
     225static int ath_set_mac_address(struct net_device *, void *);
     226static int ath_change_mtu(struct net_device *, int);
     227static int ath_ioctl(struct net_device *, struct ifreq *, int);
     228
     229static int ath_rate_setup(struct net_device *, u_int);
     230static void ath_setup_subrates(struct net_device *);
     231#ifdef ATH_SUPERG_XR
     232static int ath_xr_rate_setup(struct net_device *);
     233static void ath_grppoll_txq_setup(struct ath_softc *, int, int);
     234static void ath_grppoll_start(struct ieee80211vap *, int);
     235static void ath_grppoll_stop(struct ieee80211vap *);
     236static u_int8_t ath_node_move_data(const struct ieee80211_node *);
     237static void ath_grppoll_txq_update(struct ath_softc *, int);
     238static void ath_grppoll_period_update(struct ath_softc *);
     239#endif
     240static void ath_setcurmode(struct ath_softc *, enum ieee80211_phymode);
     241
     242static void ath_dynamic_sysctl_register(struct ath_softc *);
     243static void ath_dynamic_sysctl_unregister(struct ath_softc *);
     244static void ath_announce(struct net_device *);
     245static int ath_descdma_setup(struct ath_softc *, struct ath_descdma *,
     246        ath_bufhead *, const char *, int, int);
     247static void ath_descdma_cleanup(struct ath_softc *, struct ath_descdma *,
     248        ath_bufhead *, int);
     249static void ath_check_dfs_clear(unsigned long);
     250static const char *ath_get_hal_status_desc(HAL_STATUS status);
     251static int ath_rcv_dev_event(struct notifier_block *, unsigned long, void *);
     252       
     253static int ath_calinterval = ATH_SHORT_CALINTERVAL;             /*
     254                                                                 * calibrate every 30 secs in steady state
     255                                                                 * but check every second at first.
     256                                                                 */
     257static int ath_countrycode = CTRY_DEFAULT;      /* country code */
     258static int ath_outdoor = AH_FALSE;              /* enable outdoor use */
     259static int ath_xchanmode = AH_TRUE;             /* enable extended channels */
     260static char *autocreate = NULL;
     261static char *ratectl = DEF_RATE_CTL;
     262static int rfkill = -1;
     263static int countrycode = -1;
     264static int outdoor = -1;
     265static int xchanmode = -1;
     266
     267static const char *hal_status_desc[] = {
     268        "No error",
     269        "No hardware present or device not yet supported",
     270        "Memory allocation failed",
     271        "Hardware didn't respond as expected",
     272        "EEPROM magic number invalid",
     273        "EEPROM version invalid",
     274        "EEPROM unreadable",
     275        "EEPROM checksum invalid",
     276        "EEPROM read problem",
     277        "EEPROM mac address invalid",
     278        "EEPROM size not supported",
     279        "Attempt to change write-locked EEPROM",
     280        "Invalid parameter to function",
     281        "Hardware revision not supported",
     282        "Hardware self-test failed",
     283        "Operation incomplete"
     284};
     285
     286static struct notifier_block ath_event_block = {
     287        .notifier_call = ath_rcv_dev_event
     288};
     289
     290#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,52))
     291MODULE_PARM(countrycode, "i");
     292MODULE_PARM(outdoor, "i");
     293MODULE_PARM(xchanmode, "i");
     294MODULE_PARM(rfkill, "i");
     295MODULE_PARM(autocreate, "s");
     296MODULE_PARM(ratectl, "s");
     297#else
     298#include <linux/moduleparam.h>
     299module_param(countrycode, int, 0600);
     300module_param(outdoor, int, 0600);
     301module_param(xchanmode, int, 0600);
     302module_param(rfkill, int, 0600);
     303module_param(autocreate, charp, 0600);
     304module_param(ratectl, charp, 0600);
     305#endif
     306MODULE_PARM_DESC(countrycode, "Override default country code");
     307MODULE_PARM_DESC(outdoor, "Enable/disable outdoor use");
     308MODULE_PARM_DESC(xchanmode, "Enable/disable extended channel mode");
     309MODULE_PARM_DESC(rfkill, "Enable/disable RFKILL capability");
     310MODULE_PARM_DESC(autocreate, "Create ath device in [sta|ap|wds|adhoc|ahdemo|monitor] mode. defaults to sta, use 'none' to disable");
     311MODULE_PARM_DESC(ratectl, "Rate control algorithm [amrr|onoe|sample], defaults to '" DEF_RATE_CTL "'");
     312
     313static int      ath_debug = 0;
     314#ifdef AR_DEBUG
     315#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,52))
     316MODULE_PARM(ath_debug, "i");
     317#else
     318module_param(ath_debug, int, 0600);
     319#endif
     320MODULE_PARM_DESC(ath_debug, "Load-time debug output enable");
     321
     322#define IFF_DUMPPKTS(sc, _m) \
     323        ((sc->sc_debug & _m))
     324static void ath_printrxbuf(struct ath_buf *, int);
     325static void ath_printtxbuf(struct ath_buf *, int);
     326enum {
     327        ATH_DEBUG_XMIT          = 0x00000001,   /* basic xmit operation */
     328        ATH_DEBUG_XMIT_DESC     = 0x00000002,   /* xmit descriptors */
     329        ATH_DEBUG_RECV          = 0x00000004,   /* basic recv operation */
     330        ATH_DEBUG_RECV_DESC     = 0x00000008,   /* recv descriptors */
     331        ATH_DEBUG_RATE          = 0x00000010,   /* rate control */
     332        ATH_DEBUG_RESET         = 0x00000020,   /* reset processing */
     333        /* 0x00000040 was ATH_DEBUG_MODE */
     334        ATH_DEBUG_BEACON        = 0x00000080,   /* beacon handling */
     335        ATH_DEBUG_WATCHDOG      = 0x00000100,   /* watchdog timeout */
     336        ATH_DEBUG_INTR          = 0x00001000,   /* ISR */
     337        ATH_DEBUG_TX_PROC       = 0x00002000,   /* tx ISR proc */
     338        ATH_DEBUG_RX_PROC       = 0x00004000,   /* rx ISR proc */
     339        ATH_DEBUG_BEACON_PROC   = 0x00008000,   /* beacon ISR proc */
     340        ATH_DEBUG_CALIBRATE     = 0x00010000,   /* periodic calibration */
     341        ATH_DEBUG_KEYCACHE      = 0x00020000,   /* key cache management */
     342        ATH_DEBUG_STATE         = 0x00040000,   /* 802.11 state transitions */
     343        ATH_DEBUG_NODE          = 0x00080000,   /* node management */
     344        ATH_DEBUG_LED           = 0x00100000,   /* led management */
     345        ATH_DEBUG_FF            = 0x00200000,   /* fast frames */
     346        ATH_DEBUG_TURBO         = 0x00400000,   /* turbo/dynamic turbo */
     347        ATH_DEBUG_UAPSD         = 0x00800000,   /* uapsd */
     348        ATH_DEBUG_DOTH          = 0x01000000,   /* 11.h */
     349        ATH_DEBUG_FATAL         = 0x80000000,   /* fatal errors */
     350        ATH_DEBUG_ANY           = 0xffffffff
     351};
     352#define DPRINTF(sc, _m, _fmt, ...) do {                         \
     353        if (sc->sc_debug & (_m))                                \
     354                printk(_fmt, __VA_ARGS__);                      \
     355} while (0)
     356#define KEYPRINTF(sc, ix, hk, mac) do {                         \
     357        if (sc->sc_debug & ATH_DEBUG_KEYCACHE)                  \
     358                ath_keyprint(sc, __func__, ix, hk, mac);        \
     359} while (0)
     360#else /* defined(AR_DEBUG) */
     361#define IFF_DUMPPKTS(sc, _m)    netif_msg_dumppkts(&sc->sc_ic)
     362#define DPRINTF(sc, _m, _fmt, ...)
     363#define KEYPRINTF(sc, k, ix, mac)
     364#endif /* defined(AR_DEBUG) */
     365
     366#define ATH_SETUP_XR_VAP(sc,vap,rfilt) \
     367        do { \
     368                if (sc->sc_curchan.privFlags & CHANNEL_4MS_LIMIT) \
     369                        vap->iv_fragthreshold = XR_4MS_FRAG_THRESHOLD; \
     370                else \
     371                        vap->iv_fragthreshold = vap->iv_xrvap->iv_fragthreshold; \
     372                if (!sc->sc_xrgrppoll) { \
     373                        ath_grppoll_txq_setup(sc, HAL_TX_QUEUE_DATA, GRP_POLL_PERIOD_NO_XR_STA(sc)); \
     374                        ath_grppoll_start(vap, sc->sc_xrpollcount); \
     375                        ath_hal_setrxfilter(sc->sc_ah, rfilt|HAL_RX_FILTER_XRPOLL); \
     376                } \
     377        } while(0)
     378
     379/*
     380 * Define the scheme that we select MAC address for multiple BSS on the same radio.
     381 * The very first VAP will just use the MAC address from the EEPROM.
     382 * For the next 3 VAPs, we set the U/L bit (bit 1) in MAC address,
     383 * and use the next two bits as the index of the VAP.
     384 */
     385#define ATH_SET_VAP_BSSID_MASK(bssid_mask)      ((bssid_mask)[0] &= ~(((ATH_BCBUF-1)<<2)|0x02))
     386#define ATH_GET_VAP_ID(bssid)                   ((bssid)[0] >> 2)
     387#define ATH_SET_VAP_BSSID(bssid, id)            \
     388        do {                                    \
     389                if (id)                            \
     390                        (bssid)[0] |= (((id) << 2) | 0x02); \
     391        } while(0)
     392
     393int
     394ath_attach(u_int16_t devid, struct net_device *dev, HAL_BUS_TAG tag)
     395{
     396        struct ath_softc *sc = dev->priv;
     397        struct ieee80211com *ic = &sc->sc_ic;
     398        struct ath_hal *ah;
     399        HAL_STATUS status;
     400        int error = 0, i;
     401        int autocreatemode = IEEE80211_M_STA;
     402        u_int8_t csz;
     403
     404        sc->devid = devid;
     405        sc->sc_debug = ath_debug;
     406        DPRINTF(sc, ATH_DEBUG_ANY, "%s: devid 0x%x\n", __func__, devid);
     407
     408        /*
     409         * Cache line size is used to size and align various
     410         * structures used to communicate with the hardware.
     411         */
     412        bus_read_cachesize(sc, &csz);
     413        /* XXX assert csz is non-zero */
     414        sc->sc_cachelsz = csz << 2;             /* convert to bytes */
     415
     416        ATH_LOCK_INIT(sc);
     417        ATH_TXBUF_LOCK_INIT(sc);
     418        ATH_RXBUF_LOCK_INIT(sc);
     419
     420        ATH_INIT_TQUEUE(&sc->sc_rxtq,    ath_rx_tasklet,        dev);
     421        ATH_INIT_TQUEUE(&sc->sc_txtq,    ath_tx_tasklet,        dev);
     422        ATH_INIT_TQUEUE(&sc->sc_bmisstq, ath_bmiss_tasklet,     dev);
     423        ATH_INIT_TQUEUE(&sc->sc_bstucktq,ath_bstuck_tasklet,    dev);
     424        ATH_INIT_TQUEUE(&sc->sc_rxorntq, ath_rxorn_tasklet,     dev);
     425        ATH_INIT_TQUEUE(&sc->sc_fataltq, ath_fatal_tasklet,     dev);
     426        ATH_INIT_WORK(&sc->sc_radartask, ath_radar_task);
     427
     428        /*
     429         * Attach the HAL and verify ABI compatibility by checking
     430         * the HAL's ABI signature against the one the driver was
     431         * compiled with.  A mismatch indicates the driver was
     432         * built with an ah.h that does not correspond to the HAL
     433         * module loaded in the kernel.
     434         */
     435        ah = _ath_hal_attach(devid, sc, tag, sc->sc_iobase, &status);
     436        if (ah == NULL) {
     437                printk(KERN_ERR "%s: unable to attach hardware: '%s' (HAL status %u)\n",
     438                        dev->name, ath_get_hal_status_desc(status), status);
     439                error = ENXIO;
     440                goto bad;
     441        }
     442        if (ah->ah_abi != HAL_ABI_VERSION) {
     443                printk(KERN_ERR "%s: HAL ABI mismatch; "
     444                        "driver expects 0x%x, HAL reports 0x%x\n",
     445                        dev->name, HAL_ABI_VERSION, ah->ah_abi);
     446                error = ENXIO;          /* XXX */
     447                goto bad;
     448        }
     449        sc->sc_ah = ah;
     450
     451        /*
     452         * Check if the MAC has multi-rate retry support.
     453         * We do this by trying to setup a fake extended
     454         * descriptor.  MAC's that don't have support will
     455         * return false w/o doing anything.  MAC's that do
     456         * support it will return true w/o doing anything.
     457         */
     458        sc->sc_mrretry = ath_hal_setupxtxdesc(ah, NULL, 0,0, 0,0, 0,0);
     459
     460        /*
     461         * Check if the device has hardware counters for PHY
     462         * errors.  If so we need to enable the MIB interrupt
     463         * so we can act on stat triggers.
     464         */
     465        if (ath_hal_hwphycounters(ah))
     466                sc->sc_needmib = 1;
     467
     468        /*
     469         * Get the hardware key cache size.
     470         */
     471        sc->sc_keymax = ath_hal_keycachesize(ah);
     472        if (sc->sc_keymax > ATH_KEYMAX) {
     473                printk("%s: Warning, using only %u entries in %u key cache\n",
     474                        dev->name, ATH_KEYMAX, sc->sc_keymax);
     475                sc->sc_keymax = ATH_KEYMAX;
     476        }
     477        /*
     478         * Reset the key cache since some parts do not
     479         * reset the contents on initial power up.
     480         */
     481        for (i = 0; i < sc->sc_keymax; i++)
     482                ath_hal_keyreset(ah, i);
     483
     484        /*
     485         * Collect the channel list using the default country
     486         * code and including outdoor channels.  The 802.11 layer
     487         * is responsible for filtering this list based on settings
     488         * like the phy mode.
     489         */
     490        if (countrycode != -1)
     491                ath_countrycode = countrycode;
     492        if (outdoor != -1)
     493                ath_outdoor = outdoor;
     494        if (xchanmode != -1)
     495                ath_xchanmode = xchanmode;
     496        error = ath_getchannels(dev, ath_countrycode,
     497                        ath_outdoor, ath_xchanmode);
     498        if (error != 0)
     499                goto bad;
     500
     501        ic->ic_country_code = ath_countrycode;
     502        ic->ic_country_outdoor = ath_outdoor;
     503
     504        if (rfkill != -1) {
     505                printk(KERN_INFO "ath_pci: switching rfkill capability %s\n",
     506                        rfkill ? "on" : "off");
     507                ath_hal_setrfsilent(ah, rfkill);
     508        }
     509
     510        /*
     511         * Setup rate tables for all potential media types.
     512         */
     513        ath_rate_setup(dev, IEEE80211_MODE_11A);
     514        ath_rate_setup(dev, IEEE80211_MODE_11B);
     515        ath_rate_setup(dev, IEEE80211_MODE_11G);
     516        ath_rate_setup(dev, IEEE80211_MODE_TURBO_A);
     517        ath_rate_setup(dev, IEEE80211_MODE_TURBO_G);
     518
     519        /* Setup for half/quarter rates */
     520        ath_setup_subrates(dev);
     521
     522        /* NB: setup here so ath_rate_update is happy */
     523        ath_setcurmode(sc, IEEE80211_MODE_11A);
     524
     525        /*
     526         * Allocate tx+rx descriptors and populate the lists.
     527         */
     528        error = ath_desc_alloc(sc);
     529        if (error != 0) {
     530                printk(KERN_ERR "%s: failed to allocate descriptors: %d\n",
     531                        dev->name, error);
     532                goto bad;
     533        }
     534
     535        /*
     536         * Init ic_caps prior to queue init, since WME cap setting
     537         * depends on queue setup.
     538         */
     539        ic->ic_caps = 0;
     540
     541        /*
     542         * Allocate hardware transmit queues: one queue for
     543         * beacon frames and one data queue for each QoS
     544         * priority.  Note that the HAL handles resetting
     545         * these queues at the needed time.
     546         *
     547         * XXX PS-Poll
     548         */
     549        sc->sc_bhalq = ath_beaconq_setup(ah);
     550        if (sc->sc_bhalq == (u_int) -1) {
     551                printk(KERN_ERR "%s: unable to setup a beacon xmit queue!\n",
     552                        dev->name);
     553                error = EIO;
     554                goto bad2;
     555        }
     556        sc->sc_cabq = ath_txq_setup(sc, HAL_TX_QUEUE_CAB, 0);
     557        if (sc->sc_cabq == NULL) {
     558                printk(KERN_ERR "%s: unable to setup CAB xmit queue!\n",
     559                        dev->name);
     560                error = EIO;
     561                goto bad2;
     562        }
     563        /* NB: ensure BK queue is the lowest priority h/w queue */
     564        if (!ath_tx_setup(sc, WME_AC_BK, HAL_WME_AC_BK)) {
     565                printk(KERN_ERR "%s: unable to setup xmit queue for %s traffic!\n",
     566                        dev->name, ieee80211_wme_acnames[WME_AC_BK]);
     567                error = EIO;
     568                goto bad2;
     569        }
     570        if (!ath_tx_setup(sc, WME_AC_BE, HAL_WME_AC_BE) ||
     571            !ath_tx_setup(sc, WME_AC_VI, HAL_WME_AC_VI) ||
     572            !ath_tx_setup(sc, WME_AC_VO, HAL_WME_AC_VO)) {
     573                /*
     574                 * Not enough hardware tx queues to properly do WME;
     575                 * just punt and assign them all to the same h/w queue.
     576                 * We could do a better job of this if, for example,
     577                 * we allocate queues when we switch from station to
     578                 * AP mode.
     579                 */
     580                if (sc->sc_ac2q[WME_AC_VI] != NULL)
     581                        ath_tx_cleanupq(sc, sc->sc_ac2q[WME_AC_VI]);
     582                if (sc->sc_ac2q[WME_AC_BE] != NULL)
     583                        ath_tx_cleanupq(sc, sc->sc_ac2q[WME_AC_BE]);
     584                sc->sc_ac2q[WME_AC_BE] = sc->sc_ac2q[WME_AC_BK];
     585                sc->sc_ac2q[WME_AC_VI] = sc->sc_ac2q[WME_AC_BK];
     586                sc->sc_ac2q[WME_AC_VO] = sc->sc_ac2q[WME_AC_BK];
     587        } else {
     588                /*
     589                 * Mark WME capability since we have sufficient
     590                 * hardware queues to do proper priority scheduling.
     591                 */
     592                ic->ic_caps |= IEEE80211_C_WME;
     593                sc->sc_uapsdq = ath_txq_setup(sc, HAL_TX_QUEUE_UAPSD, 0);
     594                if (sc->sc_uapsdq == NULL)
     595                        DPRINTF(sc, ATH_DEBUG_UAPSD, "%s: unable to setup UAPSD xmit queue!\n",
     596                                __func__);
     597                else {
     598                        ic->ic_caps |= IEEE80211_C_UAPSD;
     599                        /*
     600                         * default UAPSD on if HW capable
     601                         */
     602                        IEEE80211_COM_UAPSD_ENABLE(ic);
     603                }
     604        }
     605#ifdef ATH_SUPERG_XR
     606        ath_xr_rate_setup(dev);
     607        sc->sc_xrpollint = XR_DEFAULT_POLL_INTERVAL;
     608        sc->sc_xrpollcount = XR_DEFAULT_POLL_COUNT;
     609        strcpy(sc->sc_grppoll_str, XR_DEFAULT_GRPPOLL_RATE_STR);
     610        sc->sc_grpplq.axq_qnum = -1;
     611        sc->sc_xrtxq = ath_txq_setup(sc, HAL_TX_QUEUE_DATA, HAL_XR_DATA);
     612#endif
     613
     614        /*
     615         * Special case certain configurations.  Note the
     616         * CAB queue is handled by these specially so don't
     617         * include them when checking the txq setup mask.
     618         */
     619        switch (sc->sc_txqsetup &~ ((1<<sc->sc_cabq->axq_qnum) |
     620                                (sc->sc_uapsdq ? (1<<sc->sc_uapsdq->axq_qnum) : 0))) {
     621        case 0x01:
     622                ATH_INIT_TQUEUE(&sc->sc_txtq, ath_tx_tasklet_q0, dev);
     623                break;
     624        case 0x0f:
     625                ATH_INIT_TQUEUE(&sc->sc_txtq, ath_tx_tasklet_q0123, dev);
     626                break;
     627        }
     628
     629        sc->sc_setdefantenna = ath_setdefantenna;
     630        sc->sc_rc = ieee80211_rate_attach(sc, ratectl);
     631        if (sc->sc_rc == NULL) {
     632                error = EIO;
     633                goto bad2;
     634        }
     635
     636        init_timer(&sc->sc_cal_ch);
     637        sc->sc_cal_ch.function = ath_calibrate;
     638        sc->sc_cal_ch.data = (unsigned long) dev;
     639
     640#ifdef ATH_SUPERG_DYNTURBO
     641        init_timer(&sc->sc_dturbo_switch_mode);
     642        sc->sc_dturbo_switch_mode.function = ath_turbo_switch_mode;
     643        sc->sc_dturbo_switch_mode.data = (unsigned long) dev;
     644#endif
     645
     646        sc->sc_blinking = 0;
     647        sc->sc_ledstate = 1;
     648        sc->sc_ledon = 0;                       /* low true */
     649        sc->sc_ledidle = msecs_to_jiffies(2700);        /* 2.7 sec */
     650        sc->sc_dfstesttime = ATH_DFS_TEST_RETURN_PERIOD;
     651        init_timer(&sc->sc_ledtimer);
     652        init_timer(&sc->sc_dfswaittimer);
     653        init_timer(&sc->sc_dfstesttimer);
     654        sc->sc_ledtimer.data = (unsigned long) sc;
     655        if (sc->sc_softled) {
     656                ath_hal_gpioCfgOutput(ah, sc->sc_ledpin);
     657                ath_hal_gpioset(ah, sc->sc_ledpin, !sc->sc_ledon);
     658        }
     659
     660        /* NB: ether_setup is done by bus-specific code */
     661        dev->open = ath_init;
     662        dev->stop = ath_stop;
     663        dev->hard_start_xmit = ath_hardstart;
     664        dev->tx_timeout = ath_tx_timeout;
     665        dev->watchdog_timeo = 5 * HZ;                   /* XXX */
     666        dev->set_multicast_list = ath_mode_init;
     667        dev->do_ioctl = ath_ioctl;
     668        dev->get_stats = ath_getstats;
     669        dev->set_mac_address = ath_set_mac_address;
     670        dev->change_mtu = ath_change_mtu;
     671        dev->tx_queue_len = ATH_TXBUF - 1;              /* 1 for mgmt frame */
     672#ifdef USE_HEADERLEN_RESV
     673        dev->hard_header_len += sizeof(struct ieee80211_qosframe) +
     674                                sizeof(struct llc) +
     675                                IEEE80211_ADDR_LEN +
     676                                IEEE80211_WEP_IVLEN +
     677                                IEEE80211_WEP_KIDLEN;
     678#ifdef ATH_SUPERG_FF
     679        dev->hard_header_len += ATH_FF_MAX_HDR;
     680#endif
     681#endif
     682        ic->ic_dev = dev;
     683        ic->ic_mgtstart = ath_mgtstart;
     684        ic->ic_init = ath_init;
     685        ic->ic_reset = ath_reset;
     686        ic->ic_newassoc = ath_newassoc;
     687        ic->ic_updateslot = ath_updateslot;
     688
     689        ic->ic_wme.wme_update = ath_wme_update;
     690        ic->ic_uapsd_flush = ath_uapsd_flush;
     691
     692        /* XXX not right but it's not used anywhere important */
     693        ic->ic_phytype = IEEE80211_T_OFDM;
     694        ic->ic_opmode = IEEE80211_M_STA;
     695        sc->sc_opmode = HAL_M_STA;
     696        /*
     697         * Set the Atheros Advanced Capabilities from station config before
     698         * starting 802.11 state machine.  Currently, set only fast-frames
     699         * capability.
     700         */
     701        ic->ic_ath_cap = 0;
     702        sc->sc_fftxqmin = ATH_FF_TXQMIN;
     703#ifdef ATH_SUPERG_FF
     704        ic->ic_ath_cap |= (ath_hal_fastframesupported(ah) ? IEEE80211_ATHC_FF : 0);
     705#endif
     706        ic->ic_ath_cap |= (ath_hal_burstsupported(ah) ? IEEE80211_ATHC_BURST : 0);
     707
     708#ifdef ATH_SUPERG_COMP
     709        ic->ic_ath_cap |= (ath_hal_compressionsupported(ah) ? IEEE80211_ATHC_COMP : 0);
     710#endif
     711
     712#ifdef ATH_SUPERG_DYNTURBO
     713        ic->ic_ath_cap |= (ath_hal_turboagsupported(ah) ? (IEEE80211_ATHC_TURBOP |
     714                                                        IEEE80211_ATHC_AR) : 0);
     715#endif
     716#ifdef ATH_SUPERG_XR
     717        ic->ic_ath_cap |= (ath_hal_xrsupported(ah) ? IEEE80211_ATHC_XR : 0);
     718#endif
     719
     720        ic->ic_caps |=
     721                  IEEE80211_C_IBSS              /* ibss, nee adhoc, mode */
     722                | IEEE80211_C_HOSTAP            /* hostap mode */
     723                | IEEE80211_C_MONITOR           /* monitor mode */
     724                | IEEE80211_C_AHDEMO            /* adhoc demo mode */
     725                | IEEE80211_C_SHPREAMBLE        /* short preamble supported */
     726                | IEEE80211_C_SHSLOT            /* short slot time supported */
     727                | IEEE80211_C_WPA               /* capable of WPA1+WPA2 */
     728                | IEEE80211_C_BGSCAN            /* capable of bg scanning */
     729                ;
     730        /*
     731         * Query the HAL to figure out h/w crypto support.
     732         */
     733        if (ath_hal_ciphersupported(ah, HAL_CIPHER_WEP))
     734                ic->ic_caps |= IEEE80211_C_WEP;
     735        if (ath_hal_ciphersupported(ah, HAL_CIPHER_AES_OCB))
     736                ic->ic_caps |= IEEE80211_C_AES;
     737        if (ath_hal_ciphersupported(ah, HAL_CIPHER_AES_CCM))
     738                ic->ic_caps |= IEEE80211_C_AES_CCM;
     739        if (ath_hal_ciphersupported(ah, HAL_CIPHER_CKIP))
     740                ic->ic_caps |= IEEE80211_C_CKIP;
     741        if (ath_hal_ciphersupported(ah, HAL_CIPHER_TKIP)) {
     742                ic->ic_caps |= IEEE80211_C_TKIP;
     743                /*
     744                 * Check if h/w does the MIC and/or whether the
     745                 * separate key cache entries are required to
     746                 * handle both tx+rx MIC keys.
     747                 */
     748                if (ath_hal_ciphersupported(ah, HAL_CIPHER_MIC)) {
     749                        ic->ic_caps |= IEEE80211_C_TKIPMIC;
     750                        /*
     751                         * Check if h/w does MIC correctly when
     752                         * WMM is turned on.
     753                         */
     754                        if (ath_hal_wmetkipmic(ah))
     755                                ic->ic_caps |= IEEE80211_C_WME_TKIPMIC;
     756                }
     757
     758                /*
     759                 * If the h/w supports storing tx+rx MIC keys
     760                 * in one cache slot automatically enable use.
     761                 */
     762                if (ath_hal_hastkipsplit(ah) ||
     763                    !ath_hal_settkipsplit(ah, AH_FALSE))
     764                        sc->sc_splitmic = 1;
     765        }
     766        sc->sc_hasclrkey = ath_hal_ciphersupported(ah, HAL_CIPHER_CLR);
     767#if 0
     768        sc->sc_mcastkey = ath_hal_getmcastkeysearch(ah);
     769#endif
     770        /*
     771         * Mark key cache slots associated with global keys
     772         * as in use.  If we knew TKIP was not to be used we
     773         * could leave the +32, +64, and +32+64 slots free.
     774         */
     775        for (i = 0; i < IEEE80211_WEP_NKID; i++) {
     776                setbit(sc->sc_keymap, i);
     777                setbit(sc->sc_keymap, i+64);
     778                if (sc->sc_splitmic) {
     779                        setbit(sc->sc_keymap, i+32);
     780                        setbit(sc->sc_keymap, i+32+64);
     781                }
     782        }
     783        /*
     784         * TPC support can be done either with a global cap or
     785         * per-packet support.  The latter is not available on
     786         * all parts.  We're a bit pedantic here as all parts
     787         * support a global cap.
     788         */
     789        sc->sc_hastpc = ath_hal_hastpc(ah);
     790        if (sc->sc_hastpc || ath_hal_hastxpowlimit(ah))
     791                ic->ic_caps |= IEEE80211_C_TXPMGT;
     792
     793        /*
     794         * Default 11.h to start enabled.
     795         */
     796        ic->ic_flags |= IEEE80211_F_DOTH;
     797       
     798        /*
     799         * Check for misc other capabilities.
     800         */
     801        if (ath_hal_hasbursting(ah))
     802                ic->ic_caps |= IEEE80211_C_BURST;
     803        sc->sc_hasbmask = ath_hal_hasbssidmask(ah);
     804        sc->sc_hastsfadd = ath_hal_hastsfadjust(ah);
     805        /*
     806         * Indicate we need the 802.11 header padded to a
     807         * 32-bit boundary for 4-address and QoS frames.
     808         */
     809        ic->ic_flags |= IEEE80211_F_DATAPAD;
     810
     811        /*
     812         * Query the HAL about antenna support
     813         * Enable rx fast diversity if HAL has support
     814         */
     815        if (ath_hal_hasdiversity(ah)) {
     816                sc->sc_hasdiversity = 1;
     817                ath_hal_setdiversity(ah, AH_TRUE);
     818                sc->sc_diversity = 1;
     819        } else {
     820                sc->sc_hasdiversity = 0;
     821                sc->sc_diversity = 0;
     822                ath_hal_setdiversity(ah, AH_FALSE);
     823        }
     824        sc->sc_defant = ath_hal_getdefantenna(ah);
     825
     826        /*
     827         * Not all chips have the VEOL support we want to
     828         * use with IBSS beacons; check here for it.
     829         */
     830        sc->sc_hasveol = ath_hal_hasveol(ah);
     831
     832        /* get mac address from hardware */
     833        ath_hal_getmac(ah, ic->ic_myaddr);
     834        if (sc->sc_hasbmask) {
     835                ath_hal_getbssidmask(ah, sc->sc_bssidmask);
     836                ATH_SET_VAP_BSSID_MASK(sc->sc_bssidmask);
     837                ath_hal_setbssidmask(ah, sc->sc_bssidmask);
     838        }
     839        IEEE80211_ADDR_COPY(dev->dev_addr, ic->ic_myaddr);
     840
     841        /* call MI attach routine. */
     842        ieee80211_ifattach(ic);
     843        /* override default methods */
     844        ic->ic_node_alloc = ath_node_alloc;
     845        sc->sc_node_free = ic->ic_node_free;
     846        ic->ic_node_free = ath_node_free;
     847        ic->ic_node_getrssi = ath_node_getrssi;
     848#ifdef ATH_SUPERG_XR
     849        ic->ic_node_move_data = ath_node_move_data;
     850#endif
     851        sc->sc_node_cleanup = ic->ic_node_cleanup;
     852        ic->ic_node_cleanup = ath_node_cleanup;
     853        sc->sc_recv_mgmt = ic->ic_recv_mgmt;
     854        ic->ic_recv_mgmt = ath_recv_mgmt;
     855
     856        ic->ic_vap_create = ath_vap_create;
     857        ic->ic_vap_delete = ath_vap_delete;
     858
     859        ic->ic_scan_start = ath_scan_start;
     860        ic->ic_scan_end = ath_scan_end;
     861        ic->ic_set_channel = ath_set_channel;
     862
     863        ic->ic_set_coverageclass = ath_set_coverageclass;
     864        ic->ic_mhz2ieee = ath_mhz2ieee;
     865
     866        if (register_netdev(dev)) {
     867                printk(KERN_ERR "%s: unable to register device\n", dev->name);
     868                goto bad3;
     869        }
     870        /*
     871         * Attach dynamic MIB vars and announce support
     872         * now that we have a device name with unit number.
     873         */
     874        ath_dynamic_sysctl_register(sc);
     875        ieee80211_announce(ic);
     876        ath_announce(dev);
     877#ifdef ATH_TX99_DIAG
     878        printk("%s: TX99 support enabled\n", dev->name);
     879#endif
     880        sc->sc_invalid = 0;
     881
     882        if (autocreate) {
     883                if (!strcmp(autocreate, "none"))
     884                        autocreatemode = -1;
     885                else if (!strcmp(autocreate, "sta"))
     886                        autocreatemode = IEEE80211_M_STA;
     887                else if (!strcmp(autocreate, "ap"))
     888                        autocreatemode = IEEE80211_M_HOSTAP;
     889                else if (!strcmp(autocreate, "adhoc"))
     890                        autocreatemode = IEEE80211_M_IBSS;
     891                else if (!strcmp(autocreate, "ahdemo"))
     892                        autocreatemode = IEEE80211_M_AHDEMO;
     893                else if (!strcmp(autocreate, "wds"))
     894                        autocreatemode = IEEE80211_M_WDS;
     895                else if (!strcmp(autocreate, "monitor"))
     896                        autocreatemode = IEEE80211_M_MONITOR;
     897                else {
     898                        printk(KERN_INFO "Unknown autocreate mode: %s\n",
     899                                autocreate);
     900                        autocreatemode = -1;
     901                }
     902        }
     903       
     904        if (autocreatemode != -1) {
     905                rtnl_lock();
     906                error = ieee80211_create_vap(ic, "ath%d", dev,
     907                                autocreatemode, IEEE80211_CLONE_BSSID);
     908                rtnl_unlock();
     909                if (error)
     910                        printk(KERN_ERR "%s: autocreation of VAP failed: %d\n",
     911                                dev->name, error);
     912        }
     913
     914        return 0;
     915bad3:
     916        ieee80211_ifdetach(ic);
     917        ieee80211_rate_detach(sc->sc_rc);
     918bad2:
     919        ath_tx_cleanup(sc);
     920        ath_desc_free(sc);
     921bad:
     922        if (ah)
     923                ath_hal_detach(ah);
     924        ATH_TXBUF_LOCK_DESTROY(sc);
     925        ATH_LOCK_DESTROY(sc);
     926        sc->sc_invalid = 1;
     927
     928        return error;
     929}
     930
     931int
     932ath_detach(struct net_device *dev)
     933{
     934        struct ath_softc *sc = dev->priv;
     935        struct ath_hal *ah = sc->sc_ah;
     936
     937        HAL_INT tmp;
     938        DPRINTF(sc, ATH_DEBUG_ANY, "%s: flags %x\n", __func__, dev->flags);
     939        ath_stop(dev);
     940
     941        ath_hal_setpower(sc->sc_ah, HAL_PM_AWAKE);
     942        /* Flush the radar task if it's scheduled */
     943        if (sc->sc_rtasksched == 1)
     944                flush_scheduled_work();
     945
     946        sc->sc_invalid = 1;
     947
     948        /*
     949         * NB: the order of these is important:
     950         * o call the 802.11 layer before detaching the HAL to
     951         *   ensure callbacks into the driver to delete global
     952         *   key cache entries can be handled
     953         * o reclaim the tx queue data structures after calling
     954         *   the 802.11 layer as we'll get called back to reclaim
     955         *   node state and potentially want to use them
     956         * o to cleanup the tx queues the HAL is called, so detach
     957         *   it last
     958         * Other than that, it's straightforward...
     959         */
     960        ieee80211_ifdetach(&sc->sc_ic);
     961
     962        ath_hal_intrset(ah, 0);         /* disable further intr's */
     963        ath_hal_getisr(ah, &tmp);       /* clear ISR */
     964        if(dev->irq) {
     965                free_irq(dev->irq, dev);
     966                dev->irq = 0;
     967        }
     968#ifdef ATH_TX99_DIAG
     969        if (sc->sc_tx99 != NULL)
     970                sc->sc_tx99->detach(sc->sc_tx99);
     971#endif
     972        ieee80211_rate_detach(sc->sc_rc);
     973        ath_desc_free(sc);
     974        ath_tx_cleanup(sc);
     975        ath_hal_detach(ah);
     976
     977        ath_dynamic_sysctl_unregister(sc);
     978        ATH_LOCK_DESTROY(sc);
     979        dev->stop = NULL; /* prevent calling ath_stop again */
     980        unregister_netdev(dev);
     981        return 0;
     982}
     983
     984static struct ieee80211vap *
     985ath_vap_create(struct ieee80211com *ic, const char *name, int unit,
     986        int opmode, int flags, struct net_device *mdev)
     987{
     988        struct ath_softc *sc = ic->ic_dev->priv;
     989        struct ath_hal *ah = sc->sc_ah;
     990        struct net_device *dev;
     991        struct ath_vap *avp;
     992        struct ieee80211vap *vap;
     993        int ic_opmode;
     994
     995        if (ic->ic_dev->flags & IFF_RUNNING) {
     996                /* needs to disable hardware too */
     997                ath_hal_intrset(ah, 0);         /* disable interrupts */
     998                ath_draintxq(sc);               /* stop xmit side */
     999                ath_stoprecv(sc);               /* stop recv side */
     1000        }
     1001        /* XXX ic unlocked and race against add */
     1002        switch (opmode) {
     1003        case IEEE80211_M_STA:   /* ap+sta for repeater application */
     1004                if (sc->sc_nstavaps != 0)  /* only one sta regardless */
     1005                        return NULL;
     1006                if ((sc->sc_nvaps != 0) && (!(flags & IEEE80211_NO_STABEACONS)))
     1007                        return NULL;   /* If using station beacons, must first up */
     1008                if (flags & IEEE80211_NO_STABEACONS) {
     1009                        sc->sc_nostabeacons = 1;
     1010                        ic_opmode = IEEE80211_M_HOSTAP; /* Run with chip in AP mode */
     1011                } else
     1012                        ic_opmode = opmode;
     1013                break;
     1014        case IEEE80211_M_IBSS:
     1015                if (sc->sc_nvaps != 0)          /* only one */
     1016                        return NULL;
     1017                ic_opmode = opmode;
     1018                break;
     1019        case IEEE80211_M_AHDEMO:
     1020        case IEEE80211_M_MONITOR:
     1021                if (sc->sc_nvaps != 0 && ic->ic_opmode != opmode) {
     1022                        /* preserve existing mode */
     1023                        ic_opmode = ic->ic_opmode;
     1024                } else
     1025                        ic_opmode = opmode;
     1026                break;
     1027        case IEEE80211_M_HOSTAP:
     1028        case IEEE80211_M_WDS:
     1029                /* permit multiple ap's and/or wds links */
     1030                /* XXX sta+ap for repeater/bridge application */
     1031                if ((sc->sc_nvaps != 0) && (ic->ic_opmode == IEEE80211_M_STA))
     1032                        return NULL;
     1033                /* XXX not right, beacon buffer is allocated on RUN trans */
     1034                if (opmode == IEEE80211_M_HOSTAP && STAILQ_EMPTY(&sc->sc_bbuf))
     1035                        return NULL;
     1036                /*
     1037                 * XXX Not sure if this is correct when operating only
     1038                 * with WDS links.
     1039                 */
     1040                ic_opmode = IEEE80211_M_HOSTAP;
     1041
     1042                break;
     1043        default:
     1044                return NULL;
     1045        }
     1046
     1047        if (sc->sc_nvaps >= ATH_BCBUF) {
     1048                printk(KERN_WARNING "too many virtual ap's (already got %d)\n", sc->sc_nvaps);
     1049                return NULL;
     1050        }
     1051
     1052        dev = alloc_etherdev(sizeof(struct ath_vap) + sc->sc_rc->arc_vap_space);
     1053        if (dev == NULL) {
     1054                /* XXX msg */
     1055                return NULL;
     1056        }
     1057       
     1058        avp = dev->priv;
     1059        ieee80211_vap_setup(ic, dev, name, unit, opmode, flags);
     1060        /* override with driver methods */
     1061        vap = &avp->av_vap;
     1062        avp->av_newstate = vap->iv_newstate;
     1063        vap->iv_newstate = ath_newstate;
     1064        vap->iv_key_alloc = ath_key_alloc;
     1065        vap->iv_key_delete = ath_key_delete;
     1066        vap->iv_key_set = ath_key_set;
     1067        vap->iv_key_update_begin = ath_key_update_begin;
     1068        vap->iv_key_update_end = ath_key_update_end;
     1069#ifdef ATH_SUPERG_COMP
     1070        vap->iv_comp_set = ath_comp_set;
     1071#endif
     1072
     1073        /* Let rate control register proc entries for the VAP */
     1074        if (sc->sc_rc->ops->dynamic_proc_register)
     1075                sc->sc_rc->ops->dynamic_proc_register(vap);
     1076
     1077        /*
     1078         * Change the interface type for monitor mode.
     1079         */
     1080        if (opmode == IEEE80211_M_MONITOR)
     1081                dev->type = ARPHRD_IEEE80211_PRISM;
     1082        if ((flags & IEEE80211_CLONE_BSSID) &&
     1083            sc->sc_nvaps != 0 && opmode != IEEE80211_M_WDS && sc->sc_hasbmask) {
     1084                struct ieee80211vap *v;
     1085                int id_mask, id;
     1086               
     1087                /*
     1088                 * Hardware supports the bssid mask and a unique
     1089                 * bssid was requested.  Assign a new mac address
     1090                 * and expand our bssid mask to cover the active
     1091                 * virtual ap's with distinct addresses.
     1092                 */
     1093               
     1094                /* do a full search to mark all the allocated VAPs */
     1095                id_mask = 0;
     1096                TAILQ_FOREACH(v, &ic->ic_vaps, iv_next)
     1097                        id_mask |= (1 << ATH_GET_VAP_ID(v->iv_myaddr));
     1098               
     1099                for (id = 0; id < ATH_BCBUF; id++) {
     1100                        /* get the first available slot */
     1101                        if ((id_mask & (1 << id)) == 0) {
     1102                                ATH_SET_VAP_BSSID(vap->iv_myaddr, id);
     1103                                break;
     1104                        }
     1105                }
     1106        }
     1107        avp->av_bslot = -1;
     1108        STAILQ_INIT(&avp->av_mcastq.axq_q);
     1109        ATH_TXQ_LOCK_INIT(&avp->av_mcastq);
     1110        if (opmode == IEEE80211_M_HOSTAP || opmode == IEEE80211_M_IBSS) {
     1111                /*
     1112                 * Allocate beacon state for hostap/ibss.  We know
     1113                 * a buffer is available because of the check above.
     1114                 */
     1115                avp->av_bcbuf = STAILQ_FIRST(&sc->sc_bbuf);
     1116                STAILQ_REMOVE_HEAD(&sc->sc_bbuf, bf_list);
     1117                if (opmode == IEEE80211_M_HOSTAP || !sc->sc_hasveol) {
     1118                        int slot;
     1119                        /*
     1120                         * Assign the VAP to a beacon xmit slot.  As
     1121                         * above, this cannot fail to find one.
     1122                         */
     1123                        avp->av_bslot = 0;
     1124                        for (slot = 0; slot < ATH_BCBUF; slot++)
     1125                                if (sc->sc_bslot[slot] == NULL) {
     1126                                        /*
     1127                                         * XXX hack, space out slots to better
     1128                                         * deal with misses
     1129                                         */
     1130                                        if (slot + 1 < ATH_BCBUF &&
     1131                                            sc->sc_bslot[slot+1] == NULL) {
     1132                                                avp->av_bslot = slot + 1;
     1133                                                break;
     1134                                        }
     1135                                        avp->av_bslot = slot;
     1136                                        /* NB: keep looking for a double slot */
     1137                                }
     1138                        KASSERT(sc->sc_bslot[avp->av_bslot] == NULL,
     1139                                ("beacon slot %u not empty?", avp->av_bslot));
     1140                        sc->sc_bslot[avp->av_bslot] = vap;
     1141                        sc->sc_nbcnvaps++;
     1142                }
     1143                if ((opmode == IEEE80211_M_HOSTAP) && (sc->sc_hastsfadd)) {
     1144                        /*
     1145                         * Multiple VAPs are to transmit beacons and we
     1146                         * have h/w support for TSF adjusting; enable use
     1147                         * of staggered beacons.
     1148                         */
     1149                        /* XXX check for beacon interval too small */
     1150                        sc->sc_stagbeacons = 1;
     1151                }
     1152        }
     1153        if (sc->sc_hastsfadd)
     1154                ath_hal_settsfadjust(sc->sc_ah, sc->sc_stagbeacons);
     1155        SET_NETDEV_DEV(dev, ATH_GET_NETDEV_DEV(mdev));
     1156        /* complete setup */
     1157        (void) ieee80211_vap_attach(vap,
     1158                ieee80211_media_change, ieee80211_media_status);
     1159
     1160        ic->ic_opmode = ic_opmode;
     1161       
     1162        if (opmode != IEEE80211_M_WDS)
     1163                sc->sc_nvaps++;
     1164               
     1165        if (opmode == IEEE80211_M_STA)
     1166                sc->sc_nstavaps++;
     1167        else if (opmode == IEEE80211_M_MONITOR)
     1168                sc->sc_nmonvaps++;
     1169        /*
     1170         * Adhoc demo mode is a pseudo mode; to the HAL it's
     1171         * just ibss mode and the driver doesn't use management
     1172         * frames.  Other modes carry over directly to the HAL.
     1173         */
     1174        if (ic->ic_opmode == IEEE80211_M_AHDEMO)
     1175                sc->sc_opmode = HAL_M_IBSS;
     1176        else
     1177                sc->sc_opmode = (HAL_OPMODE) ic->ic_opmode;     /* NB: compatible */
     1178
     1179#ifdef ATH_SUPERG_XR
     1180        if ( vap->iv_flags & IEEE80211_F_XR ) {
     1181                if (ath_descdma_setup(sc, &sc->sc_grppolldma, &sc->sc_grppollbuf,
     1182                        "grppoll", (sc->sc_xrpollcount+1) * HAL_ANTENNA_MAX_MODE, 1) != 0)
     1183                        printk("%s:grppoll Buf allocation failed \n",__func__);
     1184                if (!sc->sc_xrtxq)
     1185                        sc->sc_xrtxq = ath_txq_setup(sc, HAL_TX_QUEUE_DATA, HAL_XR_DATA);
     1186                if (sc->sc_hasdiversity) {
     1187                        /* Save current diversity state if user destroys XR VAP */
     1188                        sc->sc_olddiversity = sc->sc_diversity;
     1189                        ath_hal_setdiversity(sc->sc_ah, 0);
     1190                        sc->sc_diversity = 0;
     1191                }
     1192        }
     1193#endif
     1194        if (ic->ic_dev->flags & IFF_RUNNING) {
     1195                /* restart hardware */
     1196                if (ath_startrecv(sc) != 0)     /* restart recv */
     1197                        printk("%s: %s: unable to start recv logic\n",
     1198                                dev->name, __func__);
     1199                if (sc->sc_beacons)
     1200                        ath_beacon_config(sc, NULL);    /* restart beacons */
     1201                ath_hal_intrset(ah, sc->sc_imask);
     1202        }
     1203
     1204        return vap;
     1205}
     1206
     1207static void
     1208ath_vap_delete(struct ieee80211vap *vap)
     1209{
     1210        struct net_device *dev = vap->iv_ic->ic_dev;
     1211        struct ath_softc *sc = dev->priv;
     1212        struct ath_hal *ah = sc->sc_ah;
     1213        struct ath_vap *avp = ATH_VAP(vap);
     1214        int decrease = 1;
     1215        int i;
     1216        KASSERT(vap->iv_state == IEEE80211_S_INIT, ("VAP not stopped"));
     1217
     1218        if (dev->flags & IFF_RUNNING) {
     1219                /*
     1220                 * Quiesce the hardware while we remove the VAP.  In
     1221                 * particular we need to reclaim all references to the
     1222                 * VAP state by any frames pending on the tx queues.
     1223                 *
     1224                 * XXX can we do this w/o affecting other VAPs?
     1225                 */
     1226                ath_hal_intrset(ah, 0);         /* disable interrupts */
     1227                ath_draintxq(sc);               /* stop xmit side */
     1228                ath_stoprecv(sc);               /* stop recv side */
     1229        }
     1230
     1231        /*
     1232         * Reclaim any pending mcast bufs on the VAP.
     1233         */
     1234        ath_tx_draintxq(sc, &avp->av_mcastq);
     1235        ATH_TXQ_LOCK_DESTROY(&avp->av_mcastq);
     1236
     1237        /*
     1238         * Reclaim beacon state.  Note this must be done before
     1239         * VAP instance is reclaimed as we may have a reference
     1240         * to it in the buffer for the beacon frame.
     1241         */
     1242        if (avp->av_bcbuf != NULL) {
     1243                if (avp->av_bslot != -1) {
     1244                        sc->sc_bslot[avp->av_bslot] = NULL;
     1245                        sc->sc_nbcnvaps--;
     1246                }
     1247                ath_beacon_return(sc, avp->av_bcbuf);
     1248                avp->av_bcbuf = NULL;
     1249                if (sc->sc_nbcnvaps == 0)
     1250                        sc->sc_stagbeacons = 0;
     1251        }
     1252        if (vap->iv_opmode == IEEE80211_M_STA) {
     1253                sc->sc_nstavaps--;
     1254                if (sc->sc_nostabeacons)
     1255                        sc->sc_nostabeacons = 0;
     1256        } else if (vap->iv_opmode == IEEE80211_M_MONITOR) {
     1257                sc->sc_nmonvaps--;
     1258        } else if (vap->iv_opmode == IEEE80211_M_WDS) {
     1259                decrease = 0;
     1260        }
     1261        ieee80211_vap_detach(vap);
     1262        /* NB: memory is reclaimed through dev->destructor callback */
     1263        if (decrease)
     1264                sc->sc_nvaps--;
     1265
     1266#ifdef ATH_SUPERG_XR
     1267        /*
     1268         * If it's an XR VAP, free the memory allocated explicitly.
     1269         * Since the XR VAP is not registered, OS cannot free the memory.
     1270         */
     1271        if (vap->iv_flags & IEEE80211_F_XR) {
     1272                ath_grppoll_stop(vap);
     1273                ath_descdma_cleanup(sc, &sc->sc_grppolldma, &sc->sc_grppollbuf, BUS_DMA_FROMDEVICE);
     1274                memset(&sc->sc_grppollbuf, 0, sizeof(sc->sc_grppollbuf));
     1275                memset(&sc->sc_grppolldma, 0, sizeof(sc->sc_grppolldma));
     1276                if (vap->iv_xrvap)
     1277                        vap->iv_xrvap->iv_xrvap = NULL;
     1278                kfree(vap->iv_dev);
     1279                ath_tx_cleanupq(sc,sc->sc_xrtxq);
     1280                sc->sc_xrtxq = NULL;
     1281                if (sc->sc_hasdiversity) {
     1282                        /* Restore diversity setting to old diversity setting */
     1283                        ath_hal_setdiversity(ah, sc->sc_olddiversity);
     1284                        sc->sc_diversity = sc->sc_olddiversity;
     1285                }
     1286        }
     1287#endif
     1288
     1289        for (i = 0; i < IEEE80211_APPIE_NUM_OF_FRAME; i++) {
     1290                if (vap->app_ie[i].ie != NULL) {
     1291                        FREE(vap->app_ie[i].ie, M_DEVBUF);
     1292                        vap->app_ie[i].ie = NULL;
     1293                        vap->app_ie[i].length = 0;
     1294                }
     1295        }
     1296
     1297        if (dev->flags & IFF_RUNNING) {
     1298                /*
     1299                 * Restart rx+tx machines if device is still running.
     1300                 */
     1301                if (ath_startrecv(sc) != 0)     /* restart recv */
     1302                        printk("%s: %s: unable to start recv logic\n",
     1303                                dev->name, __func__);
     1304                if (sc->sc_beacons)
     1305                        ath_beacon_config(sc, NULL);    /* restart beacons */
     1306                ath_hal_intrset(ah, sc->sc_imask);
     1307        }
     1308}
     1309
     1310void
     1311ath_suspend(struct net_device *dev)
     1312{
     1313        struct ath_softc *sc = dev->priv;
     1314
     1315        DPRINTF(sc, ATH_DEBUG_ANY, "%s: flags %x\n", __func__, dev->flags);
     1316        ath_stop(dev);
     1317}
     1318
     1319void
     1320ath_resume(struct net_device *dev)
     1321{
     1322        struct ath_softc *sc = dev->priv;
     1323
     1324        DPRINTF(sc, ATH_DEBUG_ANY, "%s: flags %x\n", __func__, dev->flags);
     1325        ath_init(dev);
     1326}
     1327
     1328static void
     1329ath_uapsd_processtriggers(struct ath_softc *sc)
     1330{
     1331        struct ath_hal *ah = sc->sc_ah;
     1332        struct ath_buf *bf;
     1333        struct ath_desc *ds;
     1334        struct sk_buff *skb;
     1335        struct ieee80211_node *ni;
     1336        struct ath_node *an;
     1337        struct ieee80211_qosframe *qwh;
     1338        struct ath_txq *uapsd_xmit_q = sc->sc_uapsdq;
     1339        struct ieee80211com *ic = &sc->sc_ic;
     1340        int ac, retval;
     1341        u_int8_t tid;
     1342        u_int16_t frame_seq;
     1343        u_int64_t tsf;
     1344#define PA2DESC(_sc, _pa) \
     1345        ((struct ath_desc *)((caddr_t)(_sc)->sc_rxdma.dd_desc + \
     1346                ((_pa) - (_sc)->sc_rxdma.dd_desc_paddr)))
     1347
     1348        /* XXXAPSD: build in check against max triggers we could see
     1349         *          based on ic->ic_uapsdmaxtriggers.
     1350         */
     1351
     1352        tsf = ath_hal_gettsf64(ah);
     1353        ATH_RXBUF_LOCK(sc);
     1354        if (sc->sc_rxbufcur == NULL)
     1355                sc->sc_rxbufcur = STAILQ_FIRST(&sc->sc_rxbuf);
     1356        for (bf = sc->sc_rxbufcur; bf; bf = STAILQ_NEXT(bf, bf_list)) {
     1357                ds = bf->bf_desc;
     1358                if (ds->ds_link == bf->bf_daddr) {
     1359                        /* NB: never process the self-linked entry at the end */
     1360                        break;
     1361                }
     1362                if (bf->bf_status & ATH_BUFSTATUS_DONE) {
     1363                        /*
     1364                         * already processed this buffer (shouldn't occur if
     1365                         * we change code to always process descriptors in
     1366                         * rx intr handler - as opposed to sometimes processing
     1367                         * in the rx tasklet).
     1368                         */
     1369                        continue;
     1370                }
     1371                skb = bf->bf_skb;
     1372                if (skb == NULL) {              /* XXX ??? can this happen */
     1373                        printk("%s: no skbuff\n", __func__);
     1374                        continue;
     1375                }
     1376
     1377                /*
     1378                 * XXXAPSD: consider new HAL call that does only the subset
     1379                 *          of ath_hal_rxprocdesc we require for trigger search.
     1380                 */
     1381
     1382                /*
     1383                 * NB: descriptor memory doesn't need to be sync'd
     1384                 *     due to the way it was allocated.
     1385                 */
     1386
     1387                /*
     1388                 * Must provide the virtual address of the current
     1389                 * descriptor, the physical address, and the virtual
     1390                 * address of the next descriptor in the h/w chain.
     1391                 * This allows the HAL to look ahead to see if the
     1392                 * hardware is done with a descriptor by checking the
     1393                 * done bit in the following descriptor and the address
     1394                 * of the current descriptor the DMA engine is working
     1395                 * on.  All this is necessary because of our use of
     1396                 * a self-linked list to avoid rx overruns.
     1397                 */
     1398                retval = ath_hal_rxprocdesc(ah, ds, bf->bf_daddr, PA2DESC(sc, ds->ds_link), tsf);
     1399                if (HAL_EINPROGRESS == retval)
     1400                        break;
     1401
     1402                /* XXX: we do not support frames spanning multiple descriptors */
     1403                bf->bf_status |= ATH_BUFSTATUS_DONE;
     1404
     1405                /* errors? */
     1406                if (ds->ds_rxstat.rs_status)
     1407                        continue;
     1408
     1409                /* prepare wireless header for examination */
     1410                bus_dma_sync_single(sc->sc_bdev, bf->bf_skbaddr,
     1411                                                        sizeof(struct ieee80211_qosframe),
     1412                                                        BUS_DMA_FROMDEVICE);
     1413                qwh = (struct ieee80211_qosframe *) skb->data;
     1414
     1415                /* find the node. it MUST be in the keycache. */
     1416                if (ds->ds_rxstat.rs_keyix == HAL_RXKEYIX_INVALID ||
     1417                    (ni = sc->sc_keyixmap[ds->ds_rxstat.rs_keyix]) == NULL) {
     1418                        /*
     1419                         * XXX: this can occur if WEP mode is used for non-Atheros clients
     1420                         *      (since we do not know which of the 4 WEP keys will be used
     1421                         *      at association time, so cannot setup a key-cache entry.
     1422                         *      The Atheros client can convey this in the Atheros IE.)
     1423                         *
     1424                         * TODO: The fix is to use the hash lookup on the node here.
     1425                         */
     1426#if 0
     1427                        /*
     1428                         * This print is very chatty, so removing for now.
     1429                         */
     1430                        DPRINTF(sc, ATH_DEBUG_UAPSD, "%s: U-APSD node (%s) has invalid keycache entry\n",
     1431                                __func__, ether_sprintf(qwh->i_addr2));
     1432#endif
     1433                        continue;
     1434                }
     1435               
     1436                if (!(ni->ni_flags & IEEE80211_NODE_UAPSD))
     1437                        continue;
     1438               
     1439                /*
     1440                 * Must deal with change of state here, since otherwise there would
     1441                 * be a race (on two quick frames from STA) between this code and the
     1442                 * tasklet where we would:
     1443                 *   - miss a trigger on entry to PS if we're already trigger hunting
     1444                 *   - generate spurious SP on exit (due to frame following exit frame)
     1445                 */
     1446                if (((qwh->i_fc[1] & IEEE80211_FC1_PWR_MGT) ^
     1447                     (ni->ni_flags & IEEE80211_NODE_PWR_MGT))) {
     1448                        /*
     1449                         * NB: do not require lock here since this runs at intr
     1450                         * "proper" time and cannot be interrupted by rx tasklet
     1451                         * (code there has lock). May want to place a macro here
     1452                         * (that does nothing) to make this more clear.
     1453                         */
     1454                        ni->ni_flags |= IEEE80211_NODE_PS_CHANGED;
     1455                        ni->ni_pschangeseq = *(__le16 *)(&qwh->i_seq[0]);
     1456                        ni->ni_flags &= ~IEEE80211_NODE_UAPSD_SP;
     1457                        ni->ni_flags ^= IEEE80211_NODE_PWR_MGT;
     1458                        if (qwh->i_fc[1] & IEEE80211_FC1_PWR_MGT) {
     1459                                ni->ni_flags |= IEEE80211_NODE_UAPSD_TRIG;
     1460                                ic->ic_uapsdmaxtriggers++;
     1461                                WME_UAPSD_NODE_TRIGSEQINIT(ni);
     1462                                DPRINTF(sc, ATH_DEBUG_UAPSD,
     1463                                        "%s: Node (%s) became U-APSD triggerable (%d)\n",
     1464                                        __func__, ether_sprintf(qwh->i_addr2),
     1465                                        ic->ic_uapsdmaxtriggers);
     1466                        } else {
     1467                                ni->ni_flags &= ~IEEE80211_NODE_UAPSD_TRIG;
     1468                                ic->ic_uapsdmaxtriggers--;
     1469                                DPRINTF(sc, ATH_DEBUG_UAPSD,
     1470                                        "%s: Node (%s) no longer U-APSD triggerable (%d)\n",
     1471                                        __func__, ether_sprintf(qwh->i_addr2),
     1472                                        ic->ic_uapsdmaxtriggers);
     1473                                /*
     1474                                 * XXX: rapidly thrashing sta could get
     1475                                 * out-of-order frames due this flush placing
     1476                                 * frames on backlogged regular AC queue and
     1477                                 * re-entry to PS having fresh arrivals onto
     1478                                 * faster UPSD delivery queue. if this is a
     1479                                 * big problem we may need to drop these.
     1480                                 */
     1481                                ath_uapsd_flush(ni);
     1482                        }
     1483                       
     1484                        continue;
     1485                }
     1486
     1487                if (ic->ic_uapsdmaxtriggers == 0)
     1488                        continue;
     1489               
     1490                /* make sure the frame is QoS data/null */
     1491                /* NB: with current sub-type definitions, the
     1492                 * IEEE80211_FC0_SUBTYPE_QOS check, below, covers the
     1493                 * QoS null case too.
     1494                 */
     1495                if (((qwh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_DATA) ||
     1496                     !(qwh->i_fc[0] & IEEE80211_FC0_SUBTYPE_QOS))
     1497                        continue;
     1498               
     1499                /*
     1500                 * To be a trigger:
     1501                 *   - node is in triggerable state
     1502                 *   - QoS data/null frame with triggerable AC
     1503                 */
     1504                tid = qwh->i_qos[0] & IEEE80211_QOS_TID;
     1505                ac = TID_TO_WME_AC(tid);
     1506                if (!WME_UAPSD_AC_CAN_TRIGGER(ac, ni))
     1507                        continue;
     1508               
     1509                DPRINTF(sc, ATH_DEBUG_UAPSD,
     1510                        "%s: U-APSD trigger detected for node (%s) on AC %d\n",
     1511                        __func__, ether_sprintf(ni->ni_macaddr), ac);
     1512                if (ni->ni_flags & IEEE80211_NODE_UAPSD_SP) {
     1513                        /* have trigger, but SP in progress, so ignore */
     1514                        DPRINTF(sc, ATH_DEBUG_UAPSD,
     1515                                "%s:   SP already in progress - ignoring\n",
     1516                                __func__);
     1517                        continue;
     1518                }
     1519
     1520                /*
     1521                 * Detect duplicate triggers and drop if so.
     1522                 */
     1523                frame_seq = le16toh(*(__le16 *)qwh->i_seq);
     1524                if ((qwh->i_fc[1] & IEEE80211_FC1_RETRY) &&
     1525                    frame_seq == ni->ni_uapsd_trigseq[ac]) {
     1526                        DPRINTF(sc, ATH_DEBUG_UAPSD, "%s: dropped dup trigger, ac %d, seq %d\n",
     1527                                __func__, ac, frame_seq);
     1528                        continue;
     1529                }
     1530
     1531                an = ATH_NODE(ni);
     1532
     1533                /* start the SP */
     1534                ATH_NODE_UAPSD_LOCK(an);
     1535                ni->ni_stats.ns_uapsd_triggers++;
     1536                ni->ni_flags |= IEEE80211_NODE_UAPSD_SP;
     1537                ni->ni_uapsd_trigseq[ac] = frame_seq;
     1538                ATH_NODE_UAPSD_UNLOCK(an);
     1539
     1540                ATH_TXQ_LOCK(uapsd_xmit_q);
     1541                if (STAILQ_EMPTY(&an->an_uapsd_q)) {
     1542                        DPRINTF(sc, ATH_DEBUG_UAPSD,
     1543                                "%s: Queue empty, generating QoS NULL to send\n",
     1544                                __func__);
     1545                        /*
     1546                         * Empty queue, so need to send QoS null on this ac. Make a
     1547                         * call that will dump a QoS null onto the node's queue, then
     1548                         * we can proceed as normal.
     1549                         */
     1550                        ieee80211_send_qosnulldata(ni, ac);
     1551                }
     1552
     1553                if (STAILQ_FIRST(&an->an_uapsd_q)) {
     1554                        struct ath_buf *last_buf = STAILQ_LAST(&an->an_uapsd_q, ath_buf, bf_list);
     1555                        struct ath_desc *last_desc = last_buf->bf_desc;
     1556                        struct ieee80211_qosframe *qwhl = (struct ieee80211_qosframe *)last_buf->bf_skb->data;
     1557                        /*
     1558                         * NB: flip the bit to cause intr on the EOSP desc,
     1559                         * which is the last one
     1560                         */
     1561                        ath_hal_txreqintrdesc(sc->sc_ah, last_desc);
     1562                        qwhl->i_qos[0] |= IEEE80211_QOS_EOSP;
     1563
     1564                        if (IEEE80211_VAP_EOSPDROP_ENABLED(ni->ni_vap)) {
     1565                                /* simulate lost EOSP */
     1566                                qwhl->i_addr1[0] |= 0x40;
     1567                        }
     1568                       
     1569                        /* more data bit only for EOSP frame */
     1570                        if (an->an_uapsd_overflowqdepth)
     1571                                qwhl->i_fc[1] |= IEEE80211_FC1_MORE_DATA;
     1572                        else if (IEEE80211_NODE_UAPSD_USETIM(ni))
     1573                                ni->ni_vap->iv_set_tim(ni, 0);
     1574
     1575                        ni->ni_stats.ns_tx_uapsd += an->an_uapsd_qdepth;
     1576
     1577                        bus_dma_sync_single(sc->sc_bdev, last_buf->bf_skbaddr,
     1578                                sizeof(*qwhl), BUS_DMA_TODEVICE);
     1579                       
     1580                        if (uapsd_xmit_q->axq_link) {
     1581#ifdef AH_NEED_DESC_SWAP
     1582                                *uapsd_xmit_q->axq_link = cpu_to_le32(STAILQ_FIRST(&an->an_uapsd_q)->bf_daddr);
     1583#else
     1584                                *uapsd_xmit_q->axq_link = STAILQ_FIRST(&an->an_uapsd_q)->bf_daddr;
     1585#endif
     1586                        }
     1587                        /* below leaves an_uapsd_q NULL */
     1588                        STAILQ_CONCAT(&uapsd_xmit_q->axq_q, &an->an_uapsd_q);
     1589                        uapsd_xmit_q->axq_link = &last_desc->ds_link;
     1590                        ath_hal_puttxbuf(sc->sc_ah,
     1591                                uapsd_xmit_q->axq_qnum,
     1592                                (STAILQ_FIRST(&uapsd_xmit_q->axq_q))->bf_daddr);
     1593                        ath_hal_txstart(sc->sc_ah, uapsd_xmit_q->axq_qnum);
     1594                }
     1595                an->an_uapsd_qdepth = 0;
     1596
     1597                ATH_TXQ_UNLOCK(uapsd_xmit_q);
     1598        }
     1599        sc->sc_rxbufcur = bf;
     1600        ATH_RXBUF_UNLOCK(sc);
     1601#undef PA2DESC
     1602}
     1603
     1604/*
     1605 * Interrupt handler.  Most of the actual processing is deferred.
     1606 */
     1607irqreturn_t
     1608#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
     1609ath_intr(int irq, void *dev_id)
     1610#else
     1611ath_intr(int irq, void *dev_id, struct pt_regs *regs)
     1612#endif
     1613{
     1614        struct net_device *dev = dev_id;
     1615        struct ath_softc *sc = dev->priv;
     1616        struct ath_hal *ah = sc->sc_ah;
     1617        HAL_INT status;
     1618        int needmark;
     1619
     1620        if (sc->sc_invalid) {
     1621                /*
     1622                 * The hardware is not ready/present, don't touch anything.
     1623                 * Note this can happen early on if the IRQ is shared.
     1624                 */
     1625                return IRQ_NONE;
     1626        }
     1627        if (!ath_hal_intrpend(ah))              /* shared irq, not for us */
     1628                return IRQ_NONE;
     1629        if ((dev->flags & (IFF_RUNNING | IFF_UP)) != (IFF_RUNNING | IFF_UP)) {
     1630                DPRINTF(sc, ATH_DEBUG_INTR, "%s: flags 0x%x\n",
     1631                        __func__, dev->flags);
     1632                ath_hal_getisr(ah, &status);    /* clear ISR */
     1633                ath_hal_intrset(ah, 0);         /* disable further intr's */
     1634                return IRQ_HANDLED;
     1635        }
     1636        needmark = 0;
     1637        /*
     1638         * Figure out the reason(s) for the interrupt.  Note
     1639         * that the HAL returns a pseudo-ISR that may include
     1640         * bits we haven't explicitly enabled so we mask the
     1641         * value to ensure we only process bits we requested.
     1642         */
     1643        ath_hal_getisr(ah, &status);            /* NB: clears ISR too */
     1644        DPRINTF(sc, ATH_DEBUG_INTR, "%s: status 0x%x\n", __func__, status);
     1645        status &= sc->sc_imask;                 /* discard unasked for bits */
     1646        if (status & HAL_INT_FATAL) {
     1647                sc->sc_stats.ast_hardware++;
     1648                ath_hal_intrset(ah, 0);         /* disable intr's until reset */
     1649                ATH_SCHEDULE_TQUEUE(&sc->sc_fataltq, &needmark);
     1650        } else if (status & HAL_INT_RXORN) {
     1651                sc->sc_stats.ast_rxorn++;
     1652                ath_hal_intrset(ah, 0);         /* disable intr's until reset */
     1653                ATH_SCHEDULE_TQUEUE(&sc->sc_rxorntq, &needmark);
     1654        } else {
     1655                if (status & HAL_INT_SWBA) {
     1656                        /*
     1657                         * Software beacon alert--time to send a beacon.
     1658                         * Handle beacon transmission directly; deferring
     1659                         * this is too slow to meet timing constraints
     1660                         * under load.
     1661                         */
     1662                        ath_beacon_send(sc, &needmark);
     1663                }
     1664                if (status & HAL_INT_RXEOL) {
     1665                        /*
     1666                         * NB: the hardware should re-read the link when
     1667                         *     RXE bit is written, but it doesn't work at
     1668                         *     least on older hardware revs.
     1669                         */
     1670                        sc->sc_stats.ast_rxeol++;
     1671                }
     1672                if (status & HAL_INT_TXURN) {
     1673                        sc->sc_stats.ast_txurn++;
     1674                        /* bump tx trigger level */
     1675                        ath_hal_updatetxtriglevel(ah, AH_TRUE);
     1676                }
     1677                if (status & HAL_INT_RX) {
     1678                        ath_uapsd_processtriggers(sc);
     1679                        /* Get the noise floor data in interrupt context as we can't get it
     1680                         * per frame, so we need to get it as soon as possible (i.e. the tasklet
     1681                         * might take too long to fire */
     1682                        ath_hal_process_noisefloor(ah);
     1683                        sc->sc_channoise = ath_hal_get_channel_noise(ah, &(sc->sc_curchan));
     1684                        ATH_SCHEDULE_TQUEUE(&sc->sc_rxtq, &needmark);
     1685                }
     1686                if (status & HAL_INT_TX) {
     1687#ifdef ATH_SUPERG_DYNTURBO
     1688                        /*
     1689                         * Check if the beacon queue caused the interrupt
     1690                         * when a dynamic turbo switch
     1691                         * is pending so we can initiate the change.
     1692                         * XXX must wait for all VAPs' beacons
     1693                         */
     1694
     1695                        if (sc->sc_dturbo_switch) {
     1696                                u_int32_t txqs = (1 << sc->sc_bhalq);
     1697                                ath_hal_gettxintrtxqs(ah, &txqs);
     1698                                if(txqs & (1 << sc->sc_bhalq)) {
     1699                                        sc->sc_dturbo_switch = 0;
     1700                                        /*
     1701                                         * Hack: defer switch for 10ms to permit slow
     1702                                         * clients time to track us.  This especially
     1703                                         * noticeable with Windows clients.
     1704                                         */
     1705                                        mod_timer(&sc->sc_dturbo_switch_mode,
     1706                                                          jiffies + msecs_to_jiffies(10));
     1707                                }
     1708                        }
     1709#endif
     1710                        ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, &needmark);
     1711                }
     1712                if (status & HAL_INT_BMISS) {
     1713                        sc->sc_stats.ast_bmiss++;
     1714                        ATH_SCHEDULE_TQUEUE(&sc->sc_bmisstq, &needmark);
     1715                }
     1716                if (status & HAL_INT_MIB) {
     1717                        sc->sc_stats.ast_mib++;
     1718                        /*
     1719                         * Disable interrupts until we service the MIB
     1720                         * interrupt; otherwise it will continue to fire.
     1721                         */
     1722                        ath_hal_intrset(ah, 0);
     1723                        /*
     1724                         * Let the HAL handle the event.  We assume it will
     1725                         * clear whatever condition caused the interrupt.
     1726                         */
     1727                        ath_hal_mibevent(ah, &sc->sc_halstats);
     1728                        ath_hal_intrset(ah, sc->sc_imask);
     1729                }
     1730        }
     1731        if (needmark)
     1732                mark_bh(IMMEDIATE_BH);
     1733        return IRQ_HANDLED;
     1734}
     1735
     1736static void
     1737ath_radar_task(struct work_struct *thr)
     1738{
     1739        struct ath_softc *sc = container_of(thr, struct ath_softc, sc_radartask);
     1740        struct ath_hal *ah = sc->sc_ah;
     1741        struct ieee80211com *ic = &sc->sc_ic;
     1742        struct ieee80211_channel ichan;
     1743        HAL_CHANNEL hchan;
     1744
     1745        sc->sc_rtasksched = 0;
     1746        if (ath_hal_procdfs(ah, &hchan)) {
     1747                /*
     1748                 * DFS was found, initiate channel change
     1749                 */
     1750                ichan.ic_ieee = ath_hal_mhz2ieee(ah, hchan.channel, hchan.channelFlags);
     1751                ichan.ic_freq = hchan.channel;
     1752                ichan.ic_flags = hchan.channelFlags;
     1753
     1754                if ((sc->sc_curchan.channel == hchan.channel) &&
     1755                    (sc->sc_curchan.channelFlags == hchan.channel)) {
     1756                        if (hchan.privFlags & CHANNEL_INTERFERENCE)
     1757                                sc->sc_curchan.privFlags |= CHANNEL_INTERFERENCE;
     1758                }
     1759                ieee80211_mark_dfs(ic, &ichan);
     1760                if (((ic->ic_flags_ext & IEEE80211_FEXT_MARKDFS) == 0) &&
     1761                    (ic->ic_opmode == IEEE80211_M_HOSTAP)) {
     1762                        sc->sc_dfstest_ieeechan = ic->ic_curchan->ic_ieee;
     1763                        sc->sc_dfstesttimer.function = ath_dfs_test_return;
     1764                        sc->sc_dfstesttimer.expires = jiffies + (sc->sc_dfstesttime * HZ);
     1765                        sc->sc_dfstesttimer.data = (unsigned long)sc;
     1766                        if (sc->sc_dfstest == 0) {
     1767                                sc->sc_dfstest = 1;
     1768                                add_timer(&sc->sc_dfstesttimer);
     1769                        }
     1770                }
     1771        }
     1772}
     1773
     1774static void
     1775ath_dfs_test_return(unsigned long data)
     1776{
     1777        struct ath_softc *sc = (struct ath_softc *)data;
     1778        struct ieee80211com *ic = &sc->sc_ic;
     1779
     1780        sc->sc_dfstest = 0;
     1781        ieee80211_dfs_test_return(ic, sc->sc_dfstest_ieeechan);
     1782}
     1783
     1784static void
     1785ath_fatal_tasklet(TQUEUE_ARG data)
     1786{
     1787        struct net_device *dev = (struct net_device *)data;
     1788
     1789        printk("%s: hardware error; resetting\n", dev->name);
     1790        ath_reset(dev);
     1791}
     1792
     1793static void
     1794ath_rxorn_tasklet(TQUEUE_ARG data)
     1795{
     1796        struct net_device *dev = (struct net_device *)data;
     1797
     1798        printk("%s: rx FIFO overrun; resetting\n", dev->name);
     1799        ath_reset(dev);
     1800}
     1801
     1802static void
     1803ath_bmiss_tasklet(TQUEUE_ARG data)
     1804{
     1805        struct net_device *dev = (struct net_device *)data;
     1806        struct ath_softc *sc = dev->priv;
     1807
     1808        if (time_before(jiffies, sc->sc_ic.ic_bmiss_guard)) {
     1809                /* Beacon miss interrupt occured too short after last beacon
     1810                 * timer configuration. Ignore it as it could be spurious. */
     1811                DPRINTF(sc, ATH_DEBUG_ANY, "%s: ignored\n", __func__);
     1812        } else {
     1813                DPRINTF(sc, ATH_DEBUG_ANY, "%s\n", __func__);
     1814                ieee80211_beacon_miss(&sc->sc_ic);
     1815        }
     1816}
     1817
     1818static u_int
     1819ath_chan2flags(struct ieee80211_channel *chan)
     1820{
     1821        u_int flags;
     1822        static const u_int modeflags[] = {
     1823                0,              /* IEEE80211_MODE_AUTO    */
     1824                CHANNEL_A,      /* IEEE80211_MODE_11A     */
     1825                CHANNEL_B,      /* IEEE80211_MODE_11B     */
     1826                CHANNEL_PUREG,  /* IEEE80211_MODE_11G     */
     1827                0,              /* IEEE80211_MODE_FH      */
     1828                CHANNEL_108A,   /* IEEE80211_MODE_TURBO_A */
     1829                CHANNEL_108G,   /* IEEE80211_MODE_TURBO_G */
     1830        };
     1831
     1832        flags = modeflags[ieee80211_chan2mode(chan)];
     1833
     1834        if (IEEE80211_IS_CHAN_HALF(chan))
     1835                flags |= CHANNEL_HALF;
     1836        else if (IEEE80211_IS_CHAN_QUARTER(chan))
     1837                flags |= CHANNEL_QUARTER;
     1838
     1839        return flags;
     1840}
     1841
     1842/*
     1843 * Context: process context
     1844 */
     1845
     1846static int
     1847ath_init(struct net_device *dev)
     1848{
     1849        struct ath_softc *sc = dev->priv;
     1850        struct ieee80211com *ic = &sc->sc_ic;
     1851        struct ath_hal *ah = sc->sc_ah;
     1852        HAL_STATUS status;
     1853        int error = 0;
     1854
     1855        ATH_LOCK(sc);
     1856
     1857        DPRINTF(sc, ATH_DEBUG_RESET, "%s: mode %d\n", __func__, ic->ic_opmode);
     1858
     1859        /*
     1860         * Stop anything previously setup.  This is safe
     1861         * whether this is the first time through or not.
     1862         */
     1863        ath_stop_locked(dev);
     1864
     1865#ifdef ATH_CAP_TPC
     1866        ath_hal_setcapability(sc->sc_ah, HAL_CAP_TPC, 0, 1, NULL);
     1867#endif
     1868
     1869        /* Whether we should enable h/w TKIP MIC */
     1870        if ((ic->ic_caps & IEEE80211_C_WME) == 0)
     1871                ath_hal_setcapability(sc->sc_ah, HAL_CAP_TKIP_MIC, 0, 0, NULL);
     1872        else {
     1873                if (((ic->ic_caps & IEEE80211_C_WME_TKIPMIC) == 0) &&
     1874                    (ic->ic_flags & IEEE80211_F_WME))
     1875                        ath_hal_setcapability(sc->sc_ah, HAL_CAP_TKIP_MIC, 0, 0, NULL);
     1876                else
     1877                        ath_hal_setcapability(sc->sc_ah, HAL_CAP_TKIP_MIC, 0, 1, NULL);
     1878        }
     1879               
     1880        /*
     1881         * Flush the skb's allocated for receive in case the rx
     1882         * buffer size changes.  This could be optimized but for
     1883         * now we do it each time under the assumption it does
     1884         * not happen often.
     1885         */
     1886        ath_flushrecv(sc);
     1887
     1888        /*
     1889         * The basic interface to setting the hardware in a good
     1890         * state is ``reset''.  On return the hardware is known to
     1891         * be powered up and with interrupts disabled.  This must
     1892         * be followed by initialization of the appropriate bits
     1893         * and then setup of the interrupt mask.
     1894         */
     1895        sc->sc_curchan.channel = ic->ic_curchan->ic_freq;
     1896        sc->sc_curchan.channelFlags = ath_chan2flags(ic->ic_curchan);
     1897        if (!ath_hal_reset(ah, sc->sc_opmode, &sc->sc_curchan, AH_FALSE, &status)) {
     1898                printk("%s: unable to reset hardware: '%s' (HAL status %u) "
     1899                        "(freq %u flags 0x%x)\n", dev->name,
     1900                        ath_get_hal_status_desc(status), status,
     1901                        sc->sc_curchan.channel, sc->sc_curchan.channelFlags);
     1902                error = -EIO;
     1903                goto done;
     1904        }
     1905
     1906        if (sc->sc_softled)
     1907                ath_hal_gpioCfgOutput(ah, sc->sc_ledpin);
     1908        /*
     1909         * This is needed only to setup initial state
     1910         * but it's best done after a reset.
     1911         */
     1912        ath_update_txpow(sc);
     1913
     1914        /* Set the default RX antenna; it may get lost on reset. */
     1915        ath_setdefantenna(sc, sc->sc_defant);
     1916
     1917        /*
     1918         * Setup the hardware after reset: the key cache
     1919         * is filled as needed and the receive engine is
     1920         * set going.  Frame transmit is handled entirely
     1921         * in the frame output path; there's nothing to do
     1922         * here except setup the interrupt mask.
     1923         */
     1924#if 0
     1925        ath_initkeytable(sc);           /* XXX still needed? */
     1926#endif
     1927        if (ath_startrecv(sc) != 0) {
     1928                printk("%s: unable to start recv logic\n", dev->name);
     1929                error = -EIO;
     1930                goto done;
     1931        }
     1932        /* Enable interrupts. */
     1933        sc->sc_imask = HAL_INT_RX | HAL_INT_TX
     1934                  | HAL_INT_RXEOL | HAL_INT_RXORN
     1935                  | HAL_INT_FATAL | HAL_INT_GLOBAL;
     1936        /*
     1937         * Enable MIB interrupts when there are hardware phy counters.
     1938         * Note we only do this (at the moment) for station mode.
     1939         */
     1940        if (sc->sc_needmib && ic->ic_opmode == IEEE80211_M_STA)
     1941                sc->sc_imask |= HAL_INT_MIB;
     1942        ath_hal_intrset(ah, sc->sc_imask);
     1943
     1944        /*
     1945         * The hardware should be ready to go now so it's safe
     1946         * to kick the 802.11 state machine as it's likely to
     1947         * immediately call back to us to send mgmt frames.
     1948         */
     1949        ath_chan_change(sc, ic->ic_curchan);
     1950        ath_set_ack_bitrate(sc, sc->sc_ackrate);
     1951        dev->flags |= IFF_RUNNING;              /* we are ready to go */
     1952        ieee80211_start_running(ic);            /* start all VAPs */
     1953#ifdef ATH_TX99_DIAG
     1954        if (sc->sc_tx99 != NULL)
     1955                sc->sc_tx99->start(sc->sc_tx99);
     1956#endif
     1957done:
     1958        ATH_UNLOCK(sc);
     1959        return error;
     1960}
     1961
     1962/* Caller must lock ATH_LOCK
     1963 *
     1964 * Context: softIRQ
     1965 */
     1966static int
     1967ath_stop_locked(struct net_device *dev)
     1968{
     1969        struct ath_softc *sc = dev->priv;
     1970        struct ieee80211com *ic = &sc->sc_ic;
     1971        struct ath_hal *ah = sc->sc_ah;
     1972
     1973        DPRINTF(sc, ATH_DEBUG_RESET, "%s: invalid %u flags 0x%x\n",
     1974                __func__, sc->sc_invalid, dev->flags);
     1975
     1976        if (dev->flags & IFF_RUNNING) {
     1977                /*
     1978                 * Shutdown the hardware and driver:
     1979                 *    stop output from above
     1980                 *    reset 802.11 state machine
     1981                 *      (sends station deassoc/deauth frames)
     1982                 *    turn off timers
     1983                 *    disable interrupts
     1984                 *    clear transmit machinery
     1985                 *    clear receive machinery
     1986                 *    turn off the radio
     1987                 *    reclaim beacon resources
     1988                 *
     1989                 * Note that some of this work is not possible if the
     1990                 * hardware is gone (invalid).
     1991                 */
     1992#ifdef ATH_TX99_DIAG
     1993                if (sc->sc_tx99 != NULL)
     1994                        sc->sc_tx99->stop(sc->sc_tx99);
     1995#endif
     1996                netif_stop_queue(dev);          /* XXX re-enabled by ath_newstate */
     1997                dev->flags &= ~IFF_RUNNING;     /* NB: avoid recursion */
     1998                ieee80211_stop_running(ic);     /* stop all VAPs */
     1999                if (!sc->sc_invalid) {
     2000                        ath_hal_intrset(ah, 0);
     2001                        if (sc->sc_softled) {
     2002                                del_timer(&sc->sc_ledtimer);
     2003                                ath_hal_gpioset(ah, sc->sc_ledpin, !sc->sc_ledon);
     2004                                sc->sc_blinking = 0;
     2005                                sc->sc_ledstate = 1;
     2006                        }
     2007                }
     2008                ath_draintxq(sc);
     2009                if (!sc->sc_invalid) {
     2010                        ath_stoprecv(sc);
     2011                        ath_hal_phydisable(ah);
     2012                } else
     2013                        sc->sc_rxlink = NULL;
     2014                ath_beacon_free(sc);            /* XXX needed? */
     2015        } else
     2016                ieee80211_stop_running(ic);     /* stop other VAPs */
     2017
     2018        if (sc->sc_softled)
     2019                ath_hal_gpioset(ah, sc->sc_ledpin, !sc->sc_ledon);
     2020       
     2021        return 0;
     2022}
     2023
     2024/*
     2025 * Stop the device, grabbing the top-level lock to protect
     2026 * against concurrent entry through ath_init (which can happen
     2027 * if another thread does a system call and the thread doing the
     2028 * stop is preempted).
     2029 */
     2030static int
     2031ath_stop(struct net_device *dev)
     2032{
     2033        struct ath_softc *sc = dev->priv;
     2034        int error;
     2035
     2036        ATH_LOCK(sc);
     2037
     2038        if (!sc->sc_invalid)
     2039                ath_hal_setpower(sc->sc_ah, HAL_PM_AWAKE);
     2040
     2041        error = ath_stop_locked(dev);
     2042#if 0
     2043        if (error == 0 && !sc->sc_invalid) {
     2044                /*
     2045                 * Set the chip in full sleep mode.  Note that we are
     2046                 * careful to do this only when bringing the interface
     2047                 * completely to a stop.  When the chip is in this state
     2048                 * it must be carefully woken up or references to
     2049                 * registers in the PCI clock domain may freeze the bus
     2050                 * (and system).  This varies by chip and is mostly an
     2051                 * issue with newer parts that go to sleep more quickly.
     2052                 */
     2053                ath_hal_setpower(sc->sc_ah, HAL_PM_FULL_SLEEP);
     2054        }
     2055#endif
     2056        ATH_UNLOCK(sc);
     2057
     2058        return error;
     2059}
     2060
     2061static int
     2062ar_device(int devid)
     2063{
     2064        switch (devid) {
     2065        case AR5210_DEFAULT:
     2066        case AR5210_PROD:
     2067        case AR5210_AP:
     2068                return 5210;
     2069        case AR5211_DEFAULT:
     2070        case AR5311_DEVID:
     2071        case AR5211_LEGACY:
     2072        case AR5211_FPGA11B:
     2073                return 5211;
     2074        case AR5212_DEFAULT:
     2075        case AR5212_DEVID:
     2076        case AR5212_FPGA:
     2077        case AR5212_DEVID_IBM:
     2078        case AR5212_AR5312_REV2:
     2079        case AR5212_AR5312_REV7:
     2080        case AR5212_AR2313_REV8:
     2081        case AR5212_AR2315_REV6:
     2082        case AR5212_AR2315_REV7:
     2083        case AR5212_AR2317_REV1:
     2084        case AR5212_DEVID_0014:
     2085        case AR5212_DEVID_0015:
     2086        case AR5212_DEVID_0016:
     2087        case AR5212_DEVID_0017:
     2088        case AR5212_DEVID_0018:
     2089        case AR5212_DEVID_0019:
     2090        case AR5212_AR2413:
     2091        case AR5212_AR5413:
     2092        case AR5212_AR5424:
     2093        case AR5212_DEVID_FF19:
     2094                return 5212;
     2095        case AR5213_SREV_1_0:
     2096        case AR5213_SREV_REG:
     2097        case AR_SUBVENDOR_ID_NOG:
     2098        case AR_SUBVENDOR_ID_NEW_A:
     2099                return 5213;
     2100        default:
     2101                return 0; /* unknown */
     2102        }
     2103}
     2104
     2105
     2106static int
     2107ath_set_ack_bitrate(struct ath_softc *sc, int high)
     2108{
     2109        struct ath_hal *ah = sc->sc_ah;
     2110        if (ar_device(sc->devid) == 5212 || ar_device(sc->devid) == 5213) {
     2111                /* set ack to be sent at low bit-rate */
     2112                /* registers taken from the OpenBSD 5212 HAL */
     2113#define AR5K_AR5212_STA_ID1                     0x8004
     2114#define AR5K_AR5212_STA_ID1_ACKCTS_6MB          0x01000000
     2115#define AR5K_AR5212_STA_ID1_BASE_RATE_11B       0x02000000
     2116                u_int32_t v = AR5K_AR5212_STA_ID1_BASE_RATE_11B | AR5K_AR5212_STA_ID1_ACKCTS_6MB;
     2117                if (high) {
     2118                        OS_REG_WRITE(ah, AR5K_AR5212_STA_ID1, OS_REG_READ(ah, AR5K_AR5212_STA_ID1) & ~v);
     2119                } else {
     2120                        OS_REG_WRITE(ah, AR5K_AR5212_STA_ID1, OS_REG_READ(ah, AR5K_AR5212_STA_ID1) | v);
     2121                }
     2122                return 0;
     2123        }
     2124        return 1;
     2125}
     2126
     2127/*
     2128 * Reset the hardware w/o losing operational state.  This is
     2129 * basically a more efficient way of doing ath_stop, ath_init,
     2130 * followed by state transitions to the current 802.11
     2131 * operational state.  Used to recover from errors rx overrun
     2132 * and to reset the hardware when rf gain settings must be reset.
     2133 */
     2134static int
     2135ath_reset(struct net_device *dev)
     2136{
     2137        struct ath_softc *sc = dev->priv;
     2138        struct ieee80211com *ic = &sc->sc_ic;
     2139        struct ath_hal *ah = sc->sc_ah;
     2140        struct ieee80211_channel *c;
     2141        HAL_STATUS status;
     2142
     2143        /*
     2144         * Convert to a HAL channel description with the flags
     2145         * constrained to reflect the current operating mode.
     2146         */
     2147        c = ic->ic_curchan;
     2148        sc->sc_curchan.channel = c->ic_freq;
     2149        sc->sc_curchan.channelFlags = ath_chan2flags(c);
     2150
     2151        ath_hal_intrset(ah, 0);         /* disable interrupts */
     2152        ath_draintxq(sc);               /* stop xmit side */
     2153        ath_stoprecv(sc);               /* stop recv side */
     2154        /* NB: indicate channel change so we do a full reset */
     2155        if (!ath_hal_reset(ah, sc->sc_opmode, &sc->sc_curchan, AH_TRUE, &status))
     2156                printk("%s: %s: unable to reset hardware: '%s' (HAL status %u)\n",
     2157                        dev->name, __func__, ath_get_hal_status_desc(status), status);
     2158        ath_update_txpow(sc);           /* update tx power state */
     2159        if (ath_startrecv(sc) != 0)     /* restart recv */
     2160                printk("%s: %s: unable to start recv logic\n",
     2161                        dev->name, __func__);
     2162        if (sc->sc_softled)
     2163                ath_hal_gpioCfgOutput(ah, sc->sc_ledpin);
     2164
     2165        /*
     2166         * We may be doing a reset in response to an ioctl
     2167         * that changes the channel so update any state that
     2168         * might change as a result.
     2169         */
     2170        ath_chan_change(sc, c);
     2171        if (sc->sc_beacons)
     2172                ath_beacon_config(sc, NULL);    /* restart beacons */
     2173        ath_hal_intrset(ah, sc->sc_imask);
     2174        ath_set_ack_bitrate(sc, sc->sc_ackrate);
     2175        netif_wake_queue(dev);          /* restart xmit */
     2176#ifdef ATH_SUPERG_XR
     2177        /*
     2178         * restart the group polls.
     2179         */
     2180        if (sc->sc_xrgrppoll) {
     2181                struct ieee80211vap *vap;
     2182                TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
     2183                        if (vap && (vap->iv_flags & IEEE80211_F_XR))
     2184                                break;
     2185                ath_grppoll_stop(vap);
     2186                ath_grppoll_start(vap, sc->sc_xrpollcount);
     2187        }
     2188#endif
     2189        return 0;
     2190}
     2191
     2192
     2193/* Swap transmit descriptor.
     2194 * if AH_NEED_DESC_SWAP flag is not defined this becomes a "null"
     2195 * function.
     2196 */
     2197static __inline void
     2198ath_desc_swap(struct ath_desc *ds)
     2199{
     2200#ifdef AH_NEED_DESC_SWAP
     2201        ds->ds_link = cpu_to_le32(ds->ds_link);
     2202        ds->ds_data = cpu_to_le32(ds->ds_data);
     2203        ds->ds_ctl0 = cpu_to_le32(ds->ds_ctl0);
     2204        ds->ds_ctl1 = cpu_to_le32(ds->ds_ctl1);
     2205        ds->ds_hw[0] = cpu_to_le32(ds->ds_hw[0]);
     2206        ds->ds_hw[1] = cpu_to_le32(ds->ds_hw[1]);
     2207#endif
     2208}
     2209
     2210/*
     2211 * Insert a buffer on a txq
     2212 *
     2213 */
     2214static __inline void
     2215ath_tx_txqaddbuf(struct ath_softc *sc, struct ieee80211_node *ni,
     2216        struct ath_txq *txq, struct ath_buf *bf,
     2217        struct ath_desc *lastds, int framelen)
     2218{
     2219        struct ath_hal *ah = sc->sc_ah;
     2220
     2221        /*
     2222         * Insert the frame on the outbound list and
     2223         * pass it on to the hardware.
     2224         */
     2225        ATH_TXQ_LOCK(txq);
     2226        if (ni && ni->ni_vap && txq == &ATH_VAP(ni->ni_vap)->av_mcastq) {
     2227                /*
     2228                 * The CAB queue is started from the SWBA handler since
     2229                 * frames only go out on DTIM and to avoid possible races.
     2230                 */
     2231                ath_hal_intrset(ah, sc->sc_imask & ~HAL_INT_SWBA);
     2232                ATH_TXQ_INSERT_TAIL(txq, bf, bf_list);
     2233                DPRINTF(sc, ATH_DEBUG_TX_PROC, "%s: txq depth = %d\n", __func__, txq->axq_depth);
     2234                if (txq->axq_link != NULL) {
     2235#ifdef AH_NEED_DESC_SWAP
     2236                        *txq->axq_link = cpu_to_le32(bf->bf_daddr);
     2237#else
     2238                        *txq->axq_link = bf->bf_daddr;
     2239#endif
     2240                        DPRINTF(sc, ATH_DEBUG_XMIT, "%s: link[%u](%p)=%llx (%p)\n",
     2241                                __func__,
     2242                                txq->axq_qnum, txq->axq_link,
     2243                                ito64(bf->bf_daddr), bf->bf_desc);
     2244                }
     2245                txq->axq_link = &lastds->ds_link;
     2246                ath_hal_intrset(ah, sc->sc_imask);
     2247        } else {
     2248                ATH_TXQ_INSERT_TAIL(txq, bf, bf_list);
     2249                DPRINTF(sc, ATH_DEBUG_TX_PROC, "%s: txq depth = %d\n", __func__, txq->axq_depth);
     2250                if (txq->axq_link == NULL) {
     2251                        ath_hal_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr);
     2252                        DPRINTF(sc, ATH_DEBUG_XMIT, "%s: TXDP[%u] = %llx (%p)\n",
     2253                                __func__,
     2254                                txq->axq_qnum, ito64(bf->bf_daddr), bf->bf_desc);
     2255                } else {
     2256#ifdef AH_NEED_DESC_SWAP
     2257                        *txq->axq_link = cpu_to_le32(bf->bf_daddr);
     2258#else
     2259                        *txq->axq_link = bf->bf_daddr;
     2260#endif
     2261                        DPRINTF(sc, ATH_DEBUG_XMIT, "%s: link[%u] (%p)=%llx (%p)\n",
     2262                                __func__,
     2263                                txq->axq_qnum, txq->axq_link,
     2264                                ito64(bf->bf_daddr), bf->bf_desc);
     2265                }
     2266                txq->axq_link = &lastds->ds_link;
     2267                ath_hal_txstart(ah, txq->axq_qnum);
     2268                sc->sc_dev->trans_start = jiffies;
     2269        }
     2270        ATH_TXQ_UNLOCK(txq);
     2271
     2272        sc->sc_devstats.tx_packets++;
     2273        sc->sc_devstats.tx_bytes += framelen;
     2274}
     2275
     2276static int
     2277dot11_to_ratecode(struct ath_softc *sc, const HAL_RATE_TABLE *rt, int dot11)
     2278{
     2279        int index = sc->sc_rixmap[dot11 & IEEE80211_RATE_VAL];
     2280        if (index >= 0 && index < rt->rateCount)
     2281                return rt->info[index].rateCode;
     2282       
     2283        return rt->info[sc->sc_minrateix].rateCode;
     2284}
     2285
     2286
     2287static int
     2288ath_tx_startraw(struct net_device *dev, struct ath_buf *bf, struct sk_buff *skb)
     2289{
     2290        struct ath_softc *sc = dev->priv;
     2291        struct ath_hal *ah = sc->sc_ah;
     2292        struct ieee80211_phy_params *ph = (struct ieee80211_phy_params *) (skb->cb + sizeof(struct ieee80211_cb));
     2293        const HAL_RATE_TABLE *rt;
     2294        int pktlen;
     2295        int hdrlen;
     2296        HAL_PKT_TYPE atype;
     2297        u_int flags;
     2298        int keyix;
     2299        int try0;
     2300        int power;
     2301        u_int8_t antenna, txrate;
     2302        struct ath_txq *txq=NULL;
     2303        struct ath_desc *ds=NULL;
     2304        struct ieee80211_frame *wh;
     2305       
     2306        wh = (struct ieee80211_frame *) skb->data;
     2307        try0 = ph->try0;
     2308        rt = sc->sc_currates;
     2309        txrate = dot11_to_ratecode(sc, rt, ph->rate0);
     2310        power = ph->power > 60 ? 60 : ph->power;
     2311        hdrlen = ieee80211_anyhdrsize(wh);
     2312        pktlen = skb->len + IEEE80211_CRC_LEN;
     2313       
     2314        keyix = HAL_TXKEYIX_INVALID;
     2315        flags = HAL_TXDESC_INTREQ | HAL_TXDESC_CLRDMASK; /* XXX needed for crypto errs */
     2316       
     2317        bf->bf_skbaddr = bus_map_single(sc->sc_bdev,
     2318                                        skb->data, pktlen, BUS_DMA_TODEVICE);
     2319        DPRINTF(sc, ATH_DEBUG_XMIT, "%s: skb %p [data %p len %u] skbaddr %llx\n",
     2320                __func__, skb, skb->data, skb->len, ito64(bf->bf_skbaddr));
     2321       
     2322       
     2323        bf->bf_skb = skb;
     2324        bf->bf_node = NULL;
     2325       
     2326#ifdef ATH_SUPERG_FF
     2327        bf->bf_numdesc = 1;
     2328#endif
     2329       
     2330        /* setup descriptors */
     2331        ds = bf->bf_desc;
     2332        rt = sc->sc_currates;
     2333        KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode));
     2334       
     2335       
     2336        if (IEEE80211_IS_MULTICAST(wh->i_addr1)) {
     2337                flags |= HAL_TXDESC_NOACK;      /* no ack on broad/multicast */
     2338                sc->sc_stats.ast_tx_noack++;
     2339                try0 = 1;
     2340        }
     2341        atype = HAL_PKT_TYPE_NORMAL;            /* default */
     2342        txq = sc->sc_ac2q[skb->priority & 0x3];
     2343       
     2344       
     2345        flags |= HAL_TXDESC_INTREQ;
     2346        antenna = sc->sc_txantenna;
     2347       
     2348        /* XXX check return value? */
     2349        ath_hal_setuptxdesc(ah, ds
     2350                            , pktlen    /* packet length */
     2351                            , hdrlen    /* header length */
     2352                            , atype     /* Atheros packet type */
     2353                            , power     /* txpower */
     2354                            , txrate, try0 /* series 0 rate/tries */
     2355                            , keyix     /* key cache index */
     2356                            , antenna   /* antenna mode */
     2357                            , flags     /* flags */
     2358                            , 0         /* rts/cts rate */
     2359                            , 0         /* rts/cts duration */
     2360                            , 0         /* comp icv len */
     2361                            , 0         /* comp iv len */
     2362                            , ATH_COMP_PROC_NO_COMP_NO_CCS /* comp scheme */
     2363                           );
     2364
     2365        if (ph->try1) {
     2366                ath_hal_setupxtxdesc(sc->sc_ah, ds
     2367                        , dot11_to_ratecode(sc, rt, ph->rate1), ph->try1 /* series 1 */
     2368                        , dot11_to_ratecode(sc, rt, ph->rate2), ph->try2 /* series 2 */
     2369                        , dot11_to_ratecode(sc, rt, ph->rate3), ph->try3 /* series 3 */
     2370                        );     
     2371        }
     2372        bf->bf_flags = flags;                   /* record for post-processing */
     2373
     2374        ds->ds_link = 0;
     2375        ds->ds_data = bf->bf_skbaddr;
     2376       
     2377        ath_hal_filltxdesc(ah, ds
     2378                           , skb->len   /* segment length */
     2379                           , AH_TRUE    /* first segment */
     2380                           , AH_TRUE    /* last segment */
     2381                           , ds         /* first descriptor */
     2382                           );
     2383       
     2384        /* NB: The desc swap function becomes void,
     2385         * if descriptor swapping is not enabled
     2386         */
     2387        ath_desc_swap(ds);
     2388       
     2389        DPRINTF(sc, ATH_DEBUG_XMIT, "%s: Q%d: %08x %08x %08x %08x %08x %08x\n",
     2390                __func__, M_FLAG_GET(skb, M_UAPSD) ? 0 : txq->axq_qnum, ds->ds_link, ds->ds_data,
     2391                ds->ds_ctl0, ds->ds_ctl1, ds->ds_hw[0], ds->ds_hw[1]);
     2392               
     2393        ath_tx_txqaddbuf(sc, NULL, txq, bf, ds, pktlen);
     2394        return 0;
     2395}
     2396
     2397#ifdef ATH_SUPERG_FF
     2398/*
     2399 * Flush FF staging queue.
     2400 */
     2401static int
     2402ath_ff_neverflushtestdone(struct ath_txq *txq, struct ath_buf *bf)
     2403{
     2404        return 0;
     2405}
     2406
     2407static int
     2408ath_ff_ageflushtestdone(struct ath_txq *txq, struct ath_buf *bf)
     2409{
     2410        if ( (txq->axq_totalqueued - bf->bf_queueage) < ATH_FF_STAGEQAGEMAX )
     2411                return 1;
     2412
     2413        return 0;
     2414}
     2415
     2416/* Caller must not hold ATH_TXQ_LOCK and ATH_TXBUF_LOCK
     2417 *
     2418 * Context: softIRQ
     2419 */
     2420static void
     2421ath_ffstageq_flush(struct ath_softc *sc, struct ath_txq *txq,
     2422        int (*ath_ff_flushdonetest)(struct ath_txq *txq, struct ath_buf *bf))
     2423{
     2424        struct ath_buf *bf_ff = NULL;
     2425        struct ieee80211_node *ni = NULL;
     2426        int pktlen;
     2427        int framecnt;
     2428
     2429        for (;;) {
     2430                ATH_TXQ_LOCK(txq);
     2431
     2432                bf_ff = TAILQ_LAST(&txq->axq_stageq, axq_headtype);
     2433                if ((!bf_ff) || ath_ff_flushdonetest(txq, bf_ff))
     2434                {
     2435                        ATH_TXQ_UNLOCK(txq);
     2436                        break;
     2437                }
     2438
     2439                ni = bf_ff->bf_node;
     2440                KASSERT(ATH_NODE(ni)->an_tx_ffbuf[bf_ff->bf_skb->priority],
     2441                        ("no bf_ff on staging queue %p", bf_ff));
     2442                ATH_NODE(ni)->an_tx_ffbuf[bf_ff->bf_skb->priority] = NULL;
     2443                TAILQ_REMOVE(&txq->axq_stageq, bf_ff, bf_stagelist);
     2444
     2445                ATH_TXQ_UNLOCK(txq);
     2446
     2447                /* encap and xmit */
     2448                bf_ff->bf_skb = ieee80211_encap(ni, bf_ff->bf_skb, &framecnt);
     2449                if (bf_ff->bf_skb == NULL) {
     2450                        DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
     2451                                "%s: discard, encapsulation failure\n", __func__);
     2452                        sc->sc_stats.ast_tx_encap++;
     2453                        goto bad;
     2454                }
     2455                pktlen = bf_ff->bf_skb->len;    /* NB: don't reference skb below */
     2456                if (ath_tx_start(sc->sc_dev, ni, bf_ff, bf_ff->bf_skb, 0) == 0)
     2457                        continue;
     2458        bad:
     2459                ieee80211_free_node(ni);
     2460                if (bf_ff->bf_skb != NULL) {
     2461                        dev_kfree_skb(bf_ff->bf_skb);
     2462                        bf_ff->bf_skb = NULL;
     2463                }
     2464                bf_ff->bf_node = NULL;
     2465
     2466                ATH_TXBUF_LOCK_IRQ(sc);
     2467                STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf_ff, bf_list);
     2468                ATH_TXBUF_UNLOCK_IRQ(sc);
     2469        }
     2470}
     2471#endif
     2472
     2473#define ATH_HARDSTART_GET_TX_BUF_WITH_LOCK                              \
     2474        ATH_TXBUF_LOCK_IRQ(sc);                                         \
     2475        bf = STAILQ_FIRST(&sc->sc_txbuf);                               \
     2476        if (bf != NULL) {                                               \
     2477                STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);             \
     2478                STAILQ_INSERT_TAIL(&bf_head, bf, bf_list);              \
     2479        }                                                               \
     2480        /* XXX use a counter and leave at least one for mgmt frames */  \
     2481        if (STAILQ_EMPTY(&sc->sc_txbuf)) {                              \
     2482                DPRINTF(sc, ATH_DEBUG_XMIT,                             \
     2483                        "%s: stop queue\n", __func__);                  \
     2484                sc->sc_stats.ast_tx_qstop++;                            \
     2485                netif_stop_queue(dev);                                  \
     2486                sc->sc_devstopped = 1;                                  \
     2487                ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, NULL);                \
     2488        }                                                               \
     2489        ATH_TXBUF_UNLOCK_IRQ(sc);                                       \
     2490        if (bf == NULL) {               /* NB: should not happen */     \
     2491                DPRINTF(sc,ATH_DEBUG_XMIT,                              \
     2492                        "%s: discard, no xmit buf\n", __func__);        \
     2493                sc->sc_stats.ast_tx_nobuf++;                            \
     2494        }
     2495
     2496/*
     2497 * Transmit a data packet.  On failure caller is
     2498 * assumed to reclaim the resources.
     2499 *
     2500 * Context: process context with BH's disabled
     2501 */
     2502static int
     2503ath_hardstart(struct sk_buff *skb, struct net_device *dev)
     2504{
     2505        struct ath_softc *sc = dev->priv;
     2506        struct ieee80211_node *ni = NULL;
     2507        struct ath_buf *bf = NULL;
     2508        struct ieee80211_cb *cb = (struct ieee80211_cb *) skb->cb;
     2509        struct ether_header *eh;
     2510        STAILQ_HEAD(tmp_bf_head, ath_buf) bf_head;
     2511        struct ath_buf *tbf, *tempbf;
     2512        struct sk_buff *tskb;
     2513        int framecnt;
     2514        int requeue = 0;
     2515#ifdef ATH_SUPERG_FF
     2516        int pktlen;
     2517        struct ieee80211com *ic = &sc->sc_ic;
     2518        struct ath_node *an;
     2519        struct ath_txq *txq = NULL;
     2520        int ff_flush;
     2521        struct ieee80211vap *vap;
     2522#endif
     2523
     2524        if ((dev->flags & IFF_RUNNING) == 0 || sc->sc_invalid) {
     2525                DPRINTF(sc, ATH_DEBUG_XMIT,
     2526                        "%s: discard, invalid %d flags %x\n",
     2527                        __func__, sc->sc_invalid, dev->flags);
     2528                sc->sc_stats.ast_tx_invalid++;
     2529                return -ENETDOWN;
     2530        }
     2531
     2532        STAILQ_INIT(&bf_head);
     2533
     2534        if (cb->flags & M_RAW) {
     2535                ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
     2536                if (bf == NULL)
     2537                        goto hardstart_fail;
     2538                ath_tx_startraw(dev, bf,skb);
     2539                return NETDEV_TX_OK;
     2540        }
     2541
     2542        eh = (struct ether_header *) skb->data;
     2543        ni = cb->ni;            /* NB: always passed down by 802.11 layer */
     2544        if (ni == NULL) {
     2545                /* NB: this happens if someone marks the underlying device up */
     2546                DPRINTF(sc, ATH_DEBUG_XMIT,
     2547                        "%s: discard, no node in cb\n", __func__);
     2548                goto hardstart_fail;
     2549        }
     2550#ifdef ATH_SUPERG_FF
     2551        vap = ni->ni_vap;
     2552
     2553        if (M_FLAG_GET(skb, M_UAPSD)) {
     2554                /* bypass FF handling */
     2555                ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
     2556                if (bf == NULL)
     2557                        goto hardstart_fail;
     2558                goto ff_bypass;
     2559        }
     2560
     2561        /*
     2562         * Fast frames check.
     2563         */
     2564        ATH_FF_MAGIC_CLR(skb);
     2565        an = ATH_NODE(ni);
     2566
     2567        txq = sc->sc_ac2q[skb->priority];
     2568
     2569        if (txq->axq_depth > TAIL_DROP_COUNT) {
     2570                sc->sc_stats.ast_tx_discard++;
     2571                /* queue is full, let the kernel backlog the skb */
     2572                requeue = 1;
     2573                goto hardstart_fail;
     2574        }
     2575
     2576        /* NB: use this lock to protect an->an_ff_txbuf in athff_can_aggregate()
     2577         *     call too.
     2578         */
     2579        ATH_TXQ_LOCK(txq);
     2580        if (athff_can_aggregate(sc, eh, an, skb, vap->iv_fragthreshold, &ff_flush)) {
     2581
     2582                if (an->an_tx_ffbuf[skb->priority]) { /* i.e., frame on the staging queue */
     2583                        bf = an->an_tx_ffbuf[skb->priority];
     2584
     2585                        /* get (and remove) the frame from staging queue */
     2586                        TAILQ_REMOVE(&txq->axq_stageq, bf, bf_stagelist);
     2587                        an->an_tx_ffbuf[skb->priority] = NULL;
     2588
     2589                        ATH_TXQ_UNLOCK(txq);
     2590
     2591                        /*
     2592                         * chain skbs and add FF magic
     2593                         *
     2594                         * NB: the arriving skb should not be on a list (skb->list),
     2595                         *     so "re-using" the skb next field should be OK.
     2596                         */
     2597                        bf->bf_skb->next = skb;
     2598                        skb->next = NULL;
     2599                        skb = bf->bf_skb;
     2600                        ATH_FF_MAGIC_PUT(skb);
     2601
     2602                        /* decrement extra node reference made when an_tx_ffbuf[] was set */
     2603                        //ieee80211_free_node(ni); /* XXX where was it set ? */
     2604
     2605                        DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
     2606                                "%s: aggregating fast-frame\n", __func__);
     2607                } else {
     2608                        /* NB: careful grabbing the TX_BUF lock since still holding the txq lock.
     2609                         *     this could be avoided by always obtaining the txbuf earlier,
     2610                         *     but the "if" portion of this "if/else" clause would then need
     2611                         *     to give the buffer back.
     2612                         */
     2613                        ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
     2614                        if (bf == NULL) {
     2615                                ATH_TXQ_UNLOCK(txq);
     2616                                goto hardstart_fail;
     2617                        }
     2618                        DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
     2619                                "%s: adding to fast-frame stage Q\n", __func__);
     2620
     2621                        bf->bf_skb = skb;
     2622                        bf->bf_node = ni;
     2623                        bf->bf_queueage = txq->axq_totalqueued;
     2624                        an->an_tx_ffbuf[skb->priority] = bf;
     2625
     2626                        TAILQ_INSERT_HEAD(&txq->axq_stageq, bf, bf_stagelist);
     2627
     2628                        ATH_TXQ_UNLOCK(txq);
     2629
     2630                        return NETDEV_TX_OK;
     2631                }
     2632        } else {
     2633                if (ff_flush) {
     2634                        struct ath_buf *bf_ff = an->an_tx_ffbuf[skb->priority];
     2635
     2636                        TAILQ_REMOVE(&txq->axq_stageq, bf_ff, bf_stagelist);
     2637                        an->an_tx_ffbuf[skb->priority] = NULL;
     2638
     2639                        ATH_TXQ_UNLOCK(txq);
     2640
     2641                        /* encap and xmit */
     2642                        bf_ff->bf_skb = ieee80211_encap(ni, bf_ff->bf_skb, &framecnt);
     2643
     2644                        if (bf_ff->bf_skb == NULL) {
     2645                                DPRINTF(sc, ATH_DEBUG_XMIT,
     2646                                        "%s: discard, ff flush encap failure\n",
     2647                                        __func__);
     2648                                sc->sc_stats.ast_tx_encap++;
     2649                                goto ff_flushbad;
     2650                        }
     2651                        pktlen = bf_ff->bf_skb->len;    /* NB: don't reference skb below */
     2652                        /* NB: ath_tx_start() will use ATH_TXBUF_LOCK_BH(). The _BH
     2653                         *     portion is not needed here since we're running at
     2654                         *     interrupt time, but should be harmless.
     2655                         */
     2656                        if (ath_tx_start(dev, ni, bf_ff, bf_ff->bf_skb, 0))
     2657                                goto ff_flushbad;
     2658                        goto ff_flushdone;
     2659                ff_flushbad:
     2660                        DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
     2661                                "%s: ff stageq flush failure\n", __func__);
     2662                        ieee80211_free_node(ni);
     2663                        if (bf_ff->bf_skb) {
     2664                                dev_kfree_skb(bf_ff->bf_skb);
     2665                                bf_ff->bf_skb = NULL;
     2666                        }
     2667                        bf_ff->bf_node = NULL;
     2668
     2669                        ATH_TXBUF_LOCK(sc);
     2670                        STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf_ff, bf_list);
     2671                        ATH_TXBUF_UNLOCK(sc);
     2672                        goto ff_flushdone;
     2673                }
     2674                /*
     2675                 * XXX: out-of-order condition only occurs for AP mode and multicast.
     2676                 *      But, there may be no valid way to get this condition.
     2677                 */
     2678                else if (an->an_tx_ffbuf[skb->priority]) {
     2679                        DPRINTF(sc, ATH_DEBUG_XMIT | ATH_DEBUG_FF,
     2680                                "%s: Out-Of-Order fast-frame\n", __func__);
     2681                        ATH_TXQ_UNLOCK(txq);
     2682                } else
     2683                        ATH_TXQ_UNLOCK(txq);
     2684
     2685        ff_flushdone:
     2686                ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
     2687                if (bf == NULL)
     2688                        goto hardstart_fail;
     2689        }
     2690
     2691ff_bypass:
     2692
     2693#else /* ATH_SUPERG_FF */
     2694
     2695        ATH_HARDSTART_GET_TX_BUF_WITH_LOCK;
     2696
     2697#endif /* ATH_SUPERG_FF */
     2698
     2699        /*
     2700         * Encapsulate the packet for transmission.
     2701         */
     2702        skb = ieee80211_encap(ni, skb, &framecnt);
     2703        if (skb == NULL) {
     2704                DPRINTF(sc, ATH_DEBUG_XMIT,
     2705                        "%s: discard, encapsulation failure\n", __func__);
     2706                sc->sc_stats.ast_tx_encap++;
     2707                goto hardstart_fail;
     2708        }
     2709
     2710        if (framecnt > 1) {
     2711                int bfcnt;
     2712
     2713                /*
     2714                **  Allocate 1 ath_buf for each frame given 1 was
     2715                **  already alloc'd
     2716                */
     2717                ATH_TXBUF_LOCK(sc);
     2718                for (bfcnt = 1; bfcnt < framecnt; ++bfcnt) {
     2719                        if ((tbf = STAILQ_FIRST(&sc->sc_txbuf)) != NULL) {
     2720                                STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);
     2721                                STAILQ_INSERT_TAIL(&bf_head, tbf, bf_list);
     2722                        }
     2723                        else
     2724                                break;
     2725                       
     2726                        ieee80211_ref_node(ni);
     2727                }
     2728
     2729                if (bfcnt != framecnt) {
     2730                        if (!STAILQ_EMPTY(&bf_head)) {
     2731                                /*
     2732                                **  Failed to alloc enough ath_bufs;
     2733                                **  return to sc_txbuf list
     2734                                */
     2735                                STAILQ_FOREACH_SAFE(tbf, &bf_head, bf_list, tempbf) {
     2736                                        STAILQ_INSERT_TAIL(&sc->sc_txbuf, tbf, bf_list);
     2737                                }
     2738                        }
     2739                        ATH_TXBUF_UNLOCK(sc);
     2740                        STAILQ_INIT(&bf_head);
     2741                        goto hardstart_fail;
     2742                }
     2743                ATH_TXBUF_UNLOCK(sc);
     2744
     2745                while ((bf = STAILQ_FIRST(&bf_head)) != NULL && skb != NULL) {
     2746                        int nextfraglen = 0;
     2747
     2748                        STAILQ_REMOVE_HEAD(&bf_head, bf_list);
     2749                        tskb = skb->next;
     2750                        skb->next = NULL;
     2751                        if (tskb)
     2752                                nextfraglen = tskb->len;
     2753
     2754                        if (ath_tx_start(dev, ni, bf, skb, nextfraglen) != 0) {
     2755                                STAILQ_INSERT_TAIL(&bf_head, bf, bf_list);
     2756                                skb->next = tskb;
     2757                                goto hardstart_fail;
     2758                        }
     2759                        skb = tskb;
     2760                }
     2761        } else {
     2762                if (ath_tx_start(dev, ni, bf, skb, 0) != 0) {
     2763                        STAILQ_INSERT_TAIL(&bf_head, bf, bf_list);
     2764                        goto hardstart_fail;
     2765                }
     2766        }
     2767
     2768#ifdef ATH_SUPERG_FF
     2769        /*
     2770         * flush out stale FF from staging Q for applicable operational modes.
     2771         */
     2772        /* XXX: ADHOC mode too? */
     2773        if (txq && ic->ic_opmode == IEEE80211_M_HOSTAP)
     2774                ath_ffstageq_flush(sc, txq, ath_ff_ageflushtestdone);
     2775#endif
     2776
     2777        return NETDEV_TX_OK;
     2778
     2779hardstart_fail:
     2780        if (!STAILQ_EMPTY(&bf_head)) {
     2781                ATH_TXBUF_LOCK(sc);
     2782                STAILQ_FOREACH_SAFE(tbf, &bf_head, bf_list, tempbf) {
     2783                        tbf->bf_skb = NULL;
     2784                        tbf->bf_node = NULL;
     2785                       
     2786                        if (ni != NULL)
     2787                                ieee80211_free_node(ni);
     2788
     2789                        STAILQ_INSERT_TAIL(&sc->sc_txbuf, tbf, bf_list);
     2790                }
     2791                ATH_TXBUF_UNLOCK(sc);
     2792        }
     2793       
     2794        /* let the kernel requeue the skb (don't free it!) */
     2795        if (requeue)
     2796                return NETDEV_TX_BUSY;
     2797
     2798        /* free sk_buffs */
     2799        while (skb) {
     2800                tskb = skb->next;
     2801                skb->next = NULL;
     2802                dev_kfree_skb(skb);
     2803                skb = tskb;
     2804        }
     2805        return NETDEV_TX_OK;
     2806}
     2807#undef ATH_HARDSTART_GET_TX_BUF_WITH_LOCK
     2808
     2809/*
     2810 * Transmit a management frame.  On failure we reclaim the skbuff.
     2811 * Note that management frames come directly from the 802.11 layer
     2812 * and do not honor the send queue flow control.  Need to investigate
     2813 * using priority queuing so management frames can bypass data.
     2814 *
     2815 * Context: hwIRQ and softIRQ
     2816 */
     2817static int
     2818ath_mgtstart(struct ieee80211com *ic, struct sk_buff *skb)
     2819{
     2820        struct net_device *dev = ic->ic_dev;
     2821        struct ath_softc *sc = dev->priv;
     2822        struct ieee80211_node *ni = NULL;
     2823        struct ath_buf *bf = NULL;
     2824        struct ieee80211_cb *cb;
     2825        int error;
     2826
     2827        if ((dev->flags & IFF_RUNNING) == 0 || sc->sc_invalid) {
     2828                DPRINTF(sc, ATH_DEBUG_XMIT,
     2829                        "%s: discard, invalid %d flags %x\n",
     2830                        __func__, sc->sc_invalid, dev->flags);
     2831                sc->sc_stats.ast_tx_invalid++;
     2832                error = -ENETDOWN;
     2833                goto bad;
     2834        }
     2835        /*
     2836         * Grab a TX buffer and associated resources.
     2837         */
     2838        ATH_TXBUF_LOCK_IRQ(sc);
     2839        bf = STAILQ_FIRST(&sc->sc_txbuf);
     2840        if (bf != NULL)
     2841                STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);
     2842        if (STAILQ_EMPTY(&sc->sc_txbuf)) {
     2843                DPRINTF(sc, ATH_DEBUG_XMIT, "%s: stop queue\n", __func__);
     2844                sc->sc_stats.ast_tx_qstop++;
     2845                netif_stop_queue(dev);
     2846                sc->sc_devstopped=1;
     2847                ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, NULL);
     2848        }
     2849        ATH_TXBUF_UNLOCK_IRQ(sc);
     2850        if (bf == NULL) {
     2851                printk("ath_mgtstart: discard, no xmit buf\n");
     2852                sc->sc_stats.ast_tx_nobufmgt++;
     2853                error = -ENOBUFS;
     2854                goto bad;
     2855        }
     2856
     2857        /*
     2858         * NB: the referenced node pointer is in the
     2859         * control block of the sk_buff.  This is
     2860         * placed there by ieee80211_mgmt_output because
     2861         * we need to hold the reference with the frame.
     2862         */
     2863        cb = (struct ieee80211_cb *)skb->cb;
     2864        ni = cb->ni;
     2865        error = ath_tx_start(dev, ni, bf, skb, 0);
     2866        if (error == 0) {
     2867                sc->sc_stats.ast_tx_mgmt++;
     2868                return 0;
     2869        }
     2870        /* fall thru... */
     2871bad:
     2872        if (ni != NULL)
     2873                ieee80211_free_node(ni);
     2874        if (bf != NULL) {
     2875                bf->bf_skb = NULL;
     2876                bf->bf_node = NULL;
     2877
     2878                ATH_TXBUF_LOCK_IRQ(sc);
     2879                STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list);
     2880                ATH_TXBUF_UNLOCK_IRQ(sc);
     2881        }
     2882        dev_kfree_skb_any(skb);
     2883        skb = NULL;
     2884        return error;
     2885}
     2886
     2887#ifdef AR_DEBUG
     2888static void
     2889ath_keyprint(struct ath_softc *sc, const char *tag, u_int ix,
     2890        const HAL_KEYVAL *hk, const u_int8_t mac[IEEE80211_ADDR_LEN])
     2891{
     2892        static const char *ciphers[] = {
     2893                "WEP",
     2894                "AES-OCB",
     2895                "AES-CCM",
     2896                "CKIP",
     2897                "TKIP",
     2898                "CLR",
     2899        };
     2900        int i, n;
     2901
     2902        printk("%s: [%02u] %-7s ", tag, ix, ciphers[hk->kv_type]);
     2903        for (i = 0, n = hk->kv_len; i < n; i++)
     2904                printk("%02x", hk->kv_val[i]);
     2905        printk(" mac %s", ether_sprintf(mac));
     2906        if (hk->kv_type == HAL_CIPHER_TKIP) {
     2907                printk(" %s ", sc->sc_splitmic ? "mic" : "rxmic");
     2908                for (i = 0; i < sizeof(hk->kv_mic); i++)
     2909                        printk("%02x", hk->kv_mic[i]);
     2910#if HAL_ABI_VERSION > 0x06052200
     2911                if (!sc->sc_splitmic) {
     2912                        printk(" txmic ");
     2913                        for (i = 0; i < sizeof(hk->kv_txmic); i++)
     2914                                printk("%02x", hk->kv_txmic[i]);
     2915                }
     2916#endif
     2917        }
     2918        printk("\n");
     2919}
     2920#endif
     2921
     2922/*
     2923 * Set a TKIP key into the hardware.  This handles the
     2924 * potential distribution of key state to multiple key
     2925 * cache slots for TKIP.
     2926 */
     2927static int
     2928ath_keyset_tkip(struct ath_softc *sc, const struct ieee80211_key *k,
     2929        HAL_KEYVAL *hk, const u_int8_t mac[IEEE80211_ADDR_LEN])
     2930{
     2931#define IEEE80211_KEY_XR        (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV)
     2932        static const u_int8_t zerobssid[IEEE80211_ADDR_LEN];
     2933        struct ath_hal *ah = sc->sc_ah;
     2934
     2935        KASSERT(k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP,
     2936                ("got a non-TKIP key, cipher %u", k->wk_cipher->ic_cipher));
     2937        if ((k->wk_flags & IEEE80211_KEY_XR) == IEEE80211_KEY_XR) {
     2938                if (sc->sc_splitmic) {
     2939                        /*
     2940                         * TX key goes at first index, RX key at the rx index.
     2941                         * The HAL handles the MIC keys at index+64.
     2942                         */
     2943                        memcpy(hk->kv_mic, k->wk_txmic, sizeof(hk->kv_mic));
     2944                        KEYPRINTF(sc, k->wk_keyix, hk, zerobssid);
     2945                        if (!ath_hal_keyset(ah, k->wk_keyix, hk, zerobssid))
     2946                                return 0;
     2947
     2948                        memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
     2949                        KEYPRINTF(sc, k->wk_keyix+32, hk, mac);
     2950                        /* XXX delete tx key on failure? */
     2951                        return ath_hal_keyset(ah, k->wk_keyix+32, hk, mac);
     2952                } else {
     2953                        /*
     2954                         * Room for both TX+RX MIC keys in one key cache
     2955                         * slot, just set key at the first index; the HAL
     2956                         * will handle the reset.
     2957                         */
     2958                        memcpy(hk->kv_mic, k->wk_rxmic, sizeof(hk->kv_mic));
     2959#if HAL_ABI_VERSION > 0x06052200
     2960                        memcpy(hk->kv_txmic, k->wk_txmic, sizeof(hk->kv_txmic));
     2961#endif
     2962                        KEYPRINTF(sc, k->wk_keyix, hk, mac);
     2963                        return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
     2964                }
     2965        } else if (k->wk_flags & IEEE80211_KEY_XR) {
     2966                /*
     2967                 * TX/RX key goes at first index.
     2968                 * The HAL handles the MIC keys are index+64.
     2969                 */
     2970                memcpy(hk->kv_mic, k->wk_flags & IEEE80211_KEY_XMIT ?
     2971                        k->wk_txmic : k->wk_rxmic, sizeof(hk->kv_mic));
     2972                KEYPRINTF(sc, k->wk_keyix, hk, mac);
     2973                return ath_hal_keyset(ah, k->wk_keyix, hk, mac);
     2974        }
     2975        return 0;
     2976#undef IEEE80211_KEY_XR
     2977}
     2978
     2979/*
     2980 * Set a net80211 key into the hardware.  This handles the
     2981 * potential distribution of key state to multiple key
     2982 * cache slots for TKIP with hardware MIC support.
     2983 */
     2984static int
     2985ath_keyset(struct ath_softc *sc, const struct ieee80211_key *k,
     2986        const u_int8_t mac0[IEEE80211_ADDR_LEN],
     2987        struct ieee80211_node *bss)
     2988{
     2989#define N(a)    ((int)(sizeof(a)/sizeof(a[0])))
     2990        static const u_int8_t ciphermap[] = {
     2991                HAL_CIPHER_WEP,         /* IEEE80211_CIPHER_WEP */
     2992                HAL_CIPHER_TKIP,        /* IEEE80211_CIPHER_TKIP */
     2993                HAL_CIPHER_AES_OCB,     /* IEEE80211_CIPHER_AES_OCB */
     2994                HAL_CIPHER_AES_CCM,     /* IEEE80211_CIPHER_AES_CCM */
     2995                (u_int8_t) -1,          /* 4 is not allocated */
     2996                HAL_CIPHER_CKIP,        /* IEEE80211_CIPHER_CKIP */
     2997                HAL_CIPHER_CLR,         /* IEEE80211_CIPHER_NONE */
     2998        };
     2999        struct ath_hal *ah = sc->sc_ah;
     3000        const struct ieee80211_cipher *cip = k->wk_cipher;
     3001        u_int8_t gmac[IEEE80211_ADDR_LEN];
     3002        const u_int8_t *mac;
     3003        HAL_KEYVAL hk;
     3004
     3005        memset(&hk, 0, sizeof(hk));
     3006        /*
     3007         * Software crypto uses a "clear key" so non-crypto
     3008         * state kept in the key cache are maintained and
     3009         * so that rx frames have an entry to match.
     3010         */
     3011        if ((k->wk_flags & IEEE80211_KEY_SWCRYPT) == 0) {
     3012                KASSERT(cip->ic_cipher < N(ciphermap),
     3013                        ("invalid cipher type %u", cip->ic_cipher));
     3014                hk.kv_type = ciphermap[cip->ic_cipher];
     3015                hk.kv_len = k->wk_keylen;
     3016                memcpy(hk.kv_val, k->wk_key, k->wk_keylen);
     3017        } else
     3018                hk.kv_type = HAL_CIPHER_CLR;
     3019
     3020        if ((k->wk_flags & IEEE80211_KEY_GROUP) && sc->sc_mcastkey) {
     3021                /*
     3022                 * Group keys on hardware that supports multicast frame
     3023                 * key search use a mac that is the sender's address with
     3024                 * the high bit set instead of the app-specified address.
     3025                 */
     3026                IEEE80211_ADDR_COPY(gmac, bss->ni_macaddr);
     3027                gmac[0] |= 0x80;
     3028                mac = gmac;
     3029        } else
     3030                mac = mac0;
     3031
     3032        if (hk.kv_type == HAL_CIPHER_TKIP &&
     3033            (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
     3034                return ath_keyset_tkip(sc, k, &hk, mac);
     3035        } else {
     3036                KEYPRINTF(sc, k->wk_keyix, &hk, mac);
     3037                return ath_hal_keyset(ah, k->wk_keyix, &hk, mac);
     3038        }
     3039#undef N
     3040}
     3041
     3042/*
     3043 * Allocate tx/rx key slots for TKIP.  We allocate two slots for
     3044 * each key, one for decrypt/encrypt and the other for the MIC.
     3045 */
     3046static u_int16_t
     3047key_alloc_2pair(struct ath_softc *sc)
     3048{
     3049#define N(a)    ((int)(sizeof(a)/sizeof(a[0])))
     3050        u_int i, keyix;
     3051
     3052        KASSERT(sc->sc_splitmic, ("key cache !split"));
     3053        /* XXX could optimize */
     3054        for (i = 0; i < N(sc->sc_keymap) / 4; i++) {
     3055                u_int8_t b = sc->sc_keymap[i];
     3056                if (b != 0xff) {
     3057                        /*
     3058                         * One or more slots in this byte are free.
     3059                         */
     3060                        keyix = i * NBBY;
     3061                        while (b & 1) {
     3062                again:
     3063                                keyix++;
     3064                                b >>= 1;
     3065                        }
     3066                        /* XXX IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV */
     3067                        if (isset(sc->sc_keymap, keyix + 32) ||
     3068                            isset(sc->sc_keymap, keyix + 64) ||
     3069                            isset(sc->sc_keymap, keyix + 32 + 64)) {
     3070                                /* full pair unavailable */
     3071                                /* XXX statistic */
     3072                                if (keyix == (i + 1) * NBBY) {
     3073                                        /* no slots were appropriate, advance */
     3074                                        continue;
     3075                                }
     3076                                goto again;
     3077                        }
     3078                        setbit(sc->sc_keymap, keyix);
     3079                        setbit(sc->sc_keymap, keyix + 64);
     3080                        setbit(sc->sc_keymap, keyix + 32);
     3081                        setbit(sc->sc_keymap, keyix + 32 + 64);
     3082                        DPRINTF(sc, ATH_DEBUG_KEYCACHE,
     3083                                "%s: key pair %u,%u %u,%u\n",
     3084                                __func__, keyix, keyix + 64,
     3085                                keyix + 32, keyix + 32 + 64);
     3086                        return keyix;
     3087                }
     3088        }
     3089        DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of pair space\n", __func__);
     3090        return IEEE80211_KEYIX_NONE;
     3091#undef N
     3092}
     3093
     3094/*
     3095 * Allocate tx/rx key slots for TKIP.  We allocate two slots for
     3096 * each key, one for decrypt/encrypt and the other for the MIC.
     3097 */
     3098static u_int16_t
     3099key_alloc_pair(struct ath_softc *sc)
     3100{
     3101#define N(a)    (sizeof(a)/sizeof(a[0]))
     3102        u_int i, keyix;
     3103
     3104        KASSERT(!sc->sc_splitmic, ("key cache split"));
     3105        /* XXX could optimize */
     3106        for (i = 0; i < N(sc->sc_keymap)/4; i++) {
     3107                u_int8_t b = sc->sc_keymap[i];
     3108                if (b != 0xff) {
     3109                        /*
     3110                         * One or more slots in this byte are free.
     3111                         */
     3112                        keyix = i*NBBY;
     3113                        while (b & 1) {
     3114                again:
     3115                                keyix++;
     3116                                b >>= 1;
     3117                        }
     3118                        if (isset(sc->sc_keymap, keyix+64)) {
     3119                                /* full pair unavailable */
     3120                                /* XXX statistic */
     3121                                if (keyix == (i+1)*NBBY) {
     3122                                        /* no slots were appropriate, advance */
     3123                                        continue;
     3124                                }
     3125                                goto again;
     3126                        }
     3127                        setbit(sc->sc_keymap, keyix);
     3128                        setbit(sc->sc_keymap, keyix+64);
     3129                        DPRINTF(sc, ATH_DEBUG_KEYCACHE,
     3130                                "%s: key pair %u,%u\n",
     3131                                __func__, keyix, keyix+64);
     3132                        return keyix;
     3133                }
     3134        }
     3135        DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of pair space\n", __func__);
     3136        return IEEE80211_KEYIX_NONE;
     3137#undef N
     3138}
     3139
     3140/*
     3141 * Allocate a single key cache slot.
     3142 */
     3143static u_int16_t
     3144key_alloc_single(struct ath_softc *sc)
     3145{
     3146#define N(a)    ((int)(sizeof(a)/sizeof(a[0])))
     3147        u_int i, keyix;
     3148
     3149        /* XXX try i,i+32,i+64,i+32+64 to minimize key pair conflicts */
     3150        for (i = 0; i < N(sc->sc_keymap); i++) {
     3151                u_int8_t b = sc->sc_keymap[i];
     3152                if (b != 0xff) {
     3153                        /*
     3154                         * One or more slots are free.
     3155                         */
     3156                        keyix = i * NBBY;
     3157                        while (b & 1)
     3158                                keyix++, b >>= 1;
     3159                        setbit(sc->sc_keymap, keyix);
     3160                        DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: key %u\n",
     3161                                __func__, keyix);
     3162                        return keyix;
     3163                }
     3164        }
     3165        DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: out of space\n", __func__);
     3166        return IEEE80211_KEYIX_NONE;
     3167#undef N
     3168}
     3169
     3170/*
     3171 * Allocate one or more key cache slots for a unicast key.  The
     3172 * key itself is needed only to identify the cipher.  For hardware
     3173 * TKIP with split cipher+MIC keys we allocate two key cache slot
     3174 * pairs so that we can setup separate TX and RX MIC keys.  Note
     3175 * that the MIC key for a TKIP key at slot i is assumed by the
     3176 * hardware to be at slot i+64.  This limits TKIP keys to the first
     3177 * 64 entries.
     3178 */
     3179static int
     3180ath_key_alloc(struct ieee80211vap *vap, const struct ieee80211_key *k)
     3181{
     3182        struct net_device *dev = vap->iv_ic->ic_dev;
     3183        struct ath_softc *sc = dev->priv;
     3184
     3185        /*
     3186         * Group key allocation must be handled specially for
     3187         * parts that do not support multicast key cache search
     3188         * functionality.  For those parts the key id must match
     3189         * the h/w key index so lookups find the right key.  On
     3190         * parts w/ the key search facility we install the sender's
     3191         * mac address (with the high bit set) and let the hardware
     3192         * find the key w/o using the key id.  This is preferred as
     3193         * it permits us to support multiple users for adhoc and/or
     3194         * multi-station operation.
     3195         */
     3196        if ((k->wk_flags & IEEE80211_KEY_GROUP) && !sc->sc_mcastkey) {
     3197                u_int keyix;
     3198
     3199                if (!(&vap->iv_nw_keys[0] <= k &&
     3200                    k < &vap->iv_nw_keys[IEEE80211_WEP_NKID])) {
     3201                        /* should not happen */
     3202                        DPRINTF(sc, ATH_DEBUG_KEYCACHE,
     3203                                "%s: bogus group key\n", __func__);
     3204                        return IEEE80211_KEYIX_NONE;
     3205                }
     3206                keyix = k - vap->iv_nw_keys;
     3207                /*
     3208                 * XXX we pre-allocate the global keys so
     3209                 * have no way to check if they've already been allocated.
     3210                 */
     3211                return keyix;
     3212        }
     3213        /*
     3214         * We allocate two pair for TKIP when using the h/w to do
     3215         * the MIC.  For everything else, including software crypto,
     3216         * we allocate a single entry.  Note that s/w crypto requires
     3217         * a pass-through slot on the 5211 and 5212.  The 5210 does
     3218         * not support pass-through cache entries and we map all
     3219         * those requests to slot 0.
     3220         *
     3221         * Allocate 1 pair of keys for WEP case. Make sure the key
     3222         * is not a shared-key.
     3223         */
     3224        if (k->wk_flags & IEEE80211_KEY_SWCRYPT)
     3225                return key_alloc_single(sc);
     3226        else if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP &&
     3227                (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
     3228                if (sc->sc_splitmic)
     3229                        return key_alloc_2pair(sc);
     3230                else
     3231                        return key_alloc_pair(sc);
     3232        } else
     3233                return key_alloc_single(sc);
     3234}
     3235
     3236/*
     3237 * Delete an entry in the key cache allocated by ath_key_alloc.
     3238 */
     3239static int
     3240ath_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k,
     3241                                struct ieee80211_node *ninfo)
     3242{
     3243        struct net_device *dev = vap->iv_ic->ic_dev;
     3244        struct ath_softc *sc = dev->priv;
     3245        struct ath_hal *ah = sc->sc_ah;
     3246        const struct ieee80211_cipher *cip = k->wk_cipher;
     3247        struct ieee80211_node *ni;
     3248        u_int keyix = k->wk_keyix;
     3249        int rxkeyoff = 0;
     3250
     3251        DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s: delete key %u\n", __func__, keyix);
     3252
     3253        ath_hal_keyreset(ah, keyix);
     3254        /*
     3255         * Check the key->node map and flush any ref.
     3256         */
     3257        ni = sc->sc_keyixmap[keyix];
     3258        if (ni != NULL) {
     3259                ieee80211_free_node(ni);
     3260                sc->sc_keyixmap[keyix] = NULL;
     3261        }
     3262        /*
     3263         * Handle split tx/rx keying required for TKIP with h/w MIC.
     3264         */
     3265        if (cip->ic_cipher == IEEE80211_CIPHER_TKIP &&
     3266            (k->wk_flags & IEEE80211_KEY_SWMIC) == 0 && sc->sc_splitmic) {
     3267                ath_hal_keyreset(ah, keyix + 32);       /* RX key */
     3268                ni = sc->sc_keyixmap[keyix + 32];
     3269                if (ni != NULL) {                       /* as above... */
     3270                        ieee80211_free_node(ni);
     3271                        sc->sc_keyixmap[keyix + 32] = NULL;
     3272                }
     3273        }
     3274
     3275        /* Remove receive key entry if one exists for static WEP case */
     3276        if (ninfo != NULL) {
     3277                rxkeyoff = ninfo->ni_rxkeyoff;
     3278                if (rxkeyoff != 0) {
     3279                        ninfo->ni_rxkeyoff = 0;
     3280                        ath_hal_keyreset(ah, keyix + rxkeyoff);
     3281                        ni = sc->sc_keyixmap[keyix + rxkeyoff];
     3282                        if (ni != NULL) {       /* as above... */
     3283                                ieee80211_free_node(ni);
     3284                                sc->sc_keyixmap[keyix + rxkeyoff] = NULL;
     3285                        }
     3286                }
     3287        }
     3288
     3289        if (keyix >= IEEE80211_WEP_NKID) {
     3290                /*
     3291                 * Don't touch keymap entries for global keys so
     3292                 * they are never considered for dynamic allocation.
     3293                 */
     3294                clrbit(sc->sc_keymap, keyix);
     3295                if (cip->ic_cipher == IEEE80211_CIPHER_TKIP &&
     3296                    (k->wk_flags & IEEE80211_KEY_SWMIC) == 0) {
     3297                        clrbit(sc->sc_keymap, keyix + 64);      /* TX key MIC */
     3298                        if (sc->sc_splitmic) {
     3299                                /* +32 for RX key, +32+64 for RX key MIC */
     3300                                clrbit(sc->sc_keymap, keyix+32);
     3301                                clrbit(sc->sc_keymap, keyix+32+64);
     3302                        }
     3303                }
     3304
     3305                if (rxkeyoff != 0)
     3306                        clrbit(sc->sc_keymap, keyix + rxkeyoff);/*RX Key */
     3307        }
     3308        return 1;
     3309}
     3310
     3311/*
     3312 * Set the key cache contents for the specified key.  Key cache
     3313 * slot(s) must already have been allocated by ath_key_alloc.
     3314 */
     3315static int
     3316ath_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k,
     3317        const u_int8_t mac[IEEE80211_ADDR_LEN])
     3318{
     3319        struct net_device *dev = vap->iv_ic->ic_dev;
     3320        struct ath_softc *sc = dev->priv;
     3321
     3322        return ath_keyset(sc, k, mac, vap->iv_bss);
     3323}
     3324
     3325/*
     3326 * Block/unblock tx+rx processing while a key change is done.
     3327 * We assume the caller serializes key management operations
     3328 * so we only need to worry about synchronization with other
     3329 * uses that originate in the driver.
     3330 */
     3331static void
     3332ath_key_update_begin(struct ieee80211vap *vap)
     3333{
     3334        struct net_device *dev = vap->iv_ic->ic_dev;
     3335        struct ath_softc *sc = dev->priv;
     3336
     3337        DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s:\n", __func__);
     3338        /*
     3339         * When called from the rx tasklet we cannot use
     3340         * tasklet_disable because it will block waiting
     3341         * for us to complete execution.
     3342         *
     3343         * XXX Using in_softirq is not right since we might
     3344         * be called from other soft irq contexts than
     3345         * ath_rx_tasklet.
     3346         */
     3347        if (!in_softirq())
     3348                tasklet_disable(&sc->sc_rxtq);
     3349        netif_stop_queue(dev);
     3350}
     3351
     3352static void
     3353ath_key_update_end(struct ieee80211vap *vap)
     3354{
     3355        struct net_device *dev = vap->iv_ic->ic_dev;
     3356        struct ath_softc *sc = dev->priv;
     3357
     3358        DPRINTF(sc, ATH_DEBUG_KEYCACHE, "%s:\n", __func__);
     3359        netif_start_queue(dev);
     3360        if (!in_softirq())              /* NB: see above */
     3361                tasklet_enable(&sc->sc_rxtq);
     3362}
     3363
     3364/*
     3365 * Calculate the receive filter according to the
     3366 * operating mode and state:
     3367 *
     3368 * o always accept unicast, broadcast, and multicast traffic
     3369 * o maintain current state of phy error reception (the HAL
     3370 *   may enable phy error frames for noise immunity work)
     3371 * o probe request frames are accepted only when operating in
     3372 *   hostap, adhoc, or monitor modes
     3373 * o enable promiscuous mode according to the interface state
     3374 * o accept beacons:
     3375 *   - when operating in adhoc mode so the 802.11 layer creates
     3376 *     node table entries for peers,
     3377 *   - when operating in station mode for collecting rssi data when
     3378 *     the station is otherwise quiet, or
     3379 *   - when operating as a repeater so we see repeater-sta beacons
     3380 *   - when scanning
     3381 */
     3382static u_int32_t
     3383ath_calcrxfilter(struct ath_softc *sc)
     3384{
     3385#define RX_FILTER_PRESERVE      (HAL_RX_FILTER_PHYERR | HAL_RX_FILTER_PHYRADAR)
     3386        struct ieee80211com *ic = &sc->sc_ic;
     3387        struct net_device *dev = ic->ic_dev;
     3388        struct ath_hal *ah = sc->sc_ah;
     3389        u_int32_t rfilt;
     3390
     3391        rfilt = (ath_hal_getrxfilter(ah) & RX_FILTER_PRESERVE) |
     3392                 HAL_RX_FILTER_UCAST | HAL_RX_FILTER_BCAST |
     3393                 HAL_RX_FILTER_MCAST;
     3394        if (ic->ic_opmode != IEEE80211_M_STA)
     3395                rfilt |= HAL_RX_FILTER_PROBEREQ;
     3396        if (ic->ic_opmode != IEEE80211_M_HOSTAP && (dev->flags & IFF_PROMISC))
     3397                rfilt |= HAL_RX_FILTER_PROM;
     3398        if (ic->ic_opmode == IEEE80211_M_STA ||
     3399            sc->sc_opmode == HAL_M_IBSS ||      /* NB: AHDEMO too */
     3400            (sc->sc_nostabeacons) || sc->sc_scanning)
     3401                rfilt |= HAL_RX_FILTER_BEACON;
     3402        if (sc->sc_nmonvaps > 0)
     3403                rfilt |= (HAL_RX_FILTER_CONTROL | HAL_RX_FILTER_BEACON |
     3404                          HAL_RX_FILTER_PROBEREQ | HAL_RX_FILTER_PROM);
     3405        return rfilt;
     3406#undef RX_FILTER_PRESERVE
     3407}
     3408
     3409/*
     3410 * Merge multicast addresses from all VAPs to form the
     3411 * hardware filter.  Ideally we should only inspect our
     3412 * own list and the 802.11 layer would merge for us but
     3413 * that's a bit difficult so for now we put the onus on
     3414 * the driver.
     3415 */
     3416static void
     3417ath_merge_mcast(struct ath_softc *sc, u_int32_t mfilt[2])
     3418{
     3419        struct ieee80211com *ic = &sc->sc_ic;
     3420        struct ieee80211vap *vap;
     3421        struct dev_mc_list *mc;
     3422        u_int32_t val;
     3423        u_int8_t pos;
     3424
     3425        mfilt[0] = mfilt[1] = 0;
     3426        /* XXX locking */
     3427        TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
     3428                struct net_device *dev = vap->iv_dev;
     3429                for (mc = dev->mc_list; mc; mc = mc->next) {
     3430                        /* calculate XOR of eight 6-bit values */
     3431                        val = LE_READ_4(mc->dmi_addr + 0);
     3432                        pos = (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
     3433                        val = LE_READ_4(mc->dmi_addr + 3);
     3434                        pos ^= (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
     3435                        pos &= 0x3f;
     3436                        mfilt[pos / 32] |= (1 << (pos % 32));
     3437                }
     3438        }
     3439}
     3440
     3441static void
     3442ath_mode_init(struct net_device *dev)
     3443{
     3444        struct ath_softc *sc = dev->priv;
     3445        struct ath_hal *ah = sc->sc_ah;
     3446        u_int32_t rfilt, mfilt[2];
     3447
     3448        /* configure rx filter */
     3449        rfilt = ath_calcrxfilter(sc);
     3450        ath_hal_setrxfilter(ah, rfilt);
     3451
     3452        /* configure bssid mask */
     3453        if (sc->sc_hasbmask)
     3454                ath_hal_setbssidmask(ah, sc->sc_bssidmask);
     3455
     3456        /* configure operational mode */
     3457        ath_hal_setopmode(ah);
     3458
     3459        /* calculate and install multicast filter */
     3460        if ((dev->flags & IFF_ALLMULTI) == 0)
     3461                ath_merge_mcast(sc, mfilt);
     3462        else
     3463                mfilt[0] = mfilt[1] = ~0;
     3464        ath_hal_setmcastfilter(ah, mfilt[0], mfilt[1]);
     3465        DPRINTF(sc, ATH_DEBUG_STATE,
     3466             "%s: RX filter 0x%x, MC filter %08x:%08x\n",
     3467             __func__, rfilt, mfilt[0], mfilt[1]);
     3468}
     3469
     3470/*
     3471 * Set the slot time based on the current setting.
     3472 */
     3473static void
     3474ath_setslottime(struct ath_softc *sc)
     3475{
     3476        struct ieee80211com *ic = &sc->sc_ic;
     3477        struct ath_hal *ah = sc->sc_ah;
     3478
     3479        if (sc->sc_slottimeconf > 0) /* manual override */
     3480                ath_hal_setslottime(ah, sc->sc_slottimeconf);
     3481        else if (ic->ic_flags & IEEE80211_F_SHSLOT)
     3482                ath_hal_setslottime(ah, HAL_SLOT_TIME_9);
     3483        else
     3484                ath_hal_setslottime(ah, HAL_SLOT_TIME_20);
     3485        sc->sc_updateslot = OK;
     3486}
     3487
     3488/*
     3489 * Callback from the 802.11 layer to update the
     3490 * slot time based on the current setting.
     3491 */
     3492static void
     3493ath_updateslot(struct net_device *dev)
     3494{
     3495        struct ath_softc *sc = dev->priv;
     3496        struct ieee80211com *ic = &sc->sc_ic;
     3497
     3498        /*
     3499         * When not coordinating the BSS, change the hardware
     3500         * immediately.  For other operation we defer the change
     3501         * until beacon updates have propagated to the stations.
     3502         */
     3503        if (ic->ic_opmode == IEEE80211_M_HOSTAP)
     3504                sc->sc_updateslot = UPDATE;
     3505        else if (dev->flags & IFF_RUNNING)
     3506                ath_setslottime(sc);
     3507}
     3508
     3509#ifdef ATH_SUPERG_DYNTURBO
     3510/*
     3511 * Dynamic turbo support.
     3512 * XXX much of this could be moved up to the net80211 layer.
     3513 */
     3514
     3515/*
     3516 * Configure dynamic turbo state on beacon setup.
     3517 */
     3518static void
     3519ath_beacon_dturbo_config(struct ieee80211vap *vap, u_int32_t intval)
     3520{
     3521#define IS_CAPABLE(vap) \
     3522        (vap->iv_bss && (vap->iv_bss->ni_ath_flags & (IEEE80211_ATHC_TURBOP )) == \
     3523                (IEEE80211_ATHC_TURBOP))
     3524        struct ieee80211com *ic = vap->iv_ic;
     3525        struct ath_softc *sc = ic->ic_dev->priv;
     3526
     3527        if (ic->ic_opmode == IEEE80211_M_HOSTAP && IS_CAPABLE(vap)) {
     3528
     3529                /* Dynamic Turbo is supported on this channel. */
     3530                sc->sc_dturbo = 1;
     3531                sc->sc_dturbo_tcount = 0;
     3532                sc->sc_dturbo_switch = 0;
     3533                sc->sc_ignore_ar = 0;
     3534
     3535                /* Set the initial ATHC_BOOST capability. */
     3536                if (ic->ic_bsschan->ic_flags & CHANNEL_TURBO)
     3537                        ic->ic_ath_cap |=  IEEE80211_ATHC_BOOST;
     3538                else
     3539                        ic->ic_ath_cap &= ~IEEE80211_ATHC_BOOST;
     3540
     3541                /*
     3542                 * Calculate time & bandwidth thresholds
     3543                 *
     3544                 * sc_dturbo_base_tmin  :  ~70 seconds
     3545                 * sc_dturbo_turbo_tmax : ~120 seconds
     3546                 *
     3547                 * NB: scale calculated values to account for staggered
     3548                 *     beacon handling
     3549                 */
     3550                sc->sc_dturbo_base_tmin  = 70  * 1024 / ic->ic_lintval;
     3551                sc->sc_dturbo_turbo_tmax = 120 * 1024 / ic->ic_lintval;
     3552                sc->sc_dturbo_turbo_tmin = 5 * 1024 / ic->ic_lintval;
     3553                /* convert the thresholds from BW/sec to BW/beacon period */
     3554                sc->sc_dturbo_bw_base    = ATH_TURBO_DN_THRESH/(1024/ic->ic_lintval); 
     3555                sc->sc_dturbo_bw_turbo   = ATH_TURBO_UP_THRESH/(1024/ic->ic_lintval);
     3556                /* time in hold state in number of beacon */
     3557                sc->sc_dturbo_hold_max   = (ATH_TURBO_PERIOD_HOLD * 1024)/ic->ic_lintval;
     3558        } else {
     3559                sc->sc_dturbo = 0;
     3560                ic->ic_ath_cap &= ~IEEE80211_ATHC_BOOST;
     3561        }
     3562#undef IS_CAPABLE
     3563}
     3564
     3565/*
     3566 * Update dynamic turbo state at SWBA.  We assume we care
     3567 * called only if dynamic turbo has been enabled (sc_turbo).
     3568 */
     3569static void
     3570ath_beacon_dturbo_update(struct ieee80211vap *vap, int *needmark,u_int8_t dtim)
     3571{
     3572        struct ieee80211com *ic = vap->iv_ic;
     3573        struct ath_softc *sc = ic->ic_dev->priv;
     3574        u_int32_t bss_traffic;
     3575
     3576        /* TBD: Age out CHANNEL_INTERFERENCE */
     3577        if (sc->sc_ignore_ar) {
     3578                /*
     3579                 * Ignore AR for this beacon; a dynamic turbo
     3580                 * switch just happened and the information
     3581                 * is invalid.  Notify AR support of the channel
     3582                 * change.
     3583                 */
     3584                sc->sc_ignore_ar = 0;
     3585                ath_hal_ar_enable(sc->sc_ah);
     3586        }
     3587        sc->sc_dturbo_tcount++;
     3588        /*
     3589         * Calculate BSS traffic over the previous interval.
     3590         */
     3591        bss_traffic = (sc->sc_devstats.tx_bytes + sc->sc_devstats.rx_bytes)
     3592                    - sc->sc_dturbo_bytes;
     3593        sc->sc_dturbo_bytes = sc->sc_devstats.tx_bytes
     3594                            + sc->sc_devstats.rx_bytes;
     3595        if (ic->ic_ath_cap & IEEE80211_ATHC_BOOST) {
     3596                /*
     3597                * before switching to base mode,
     3598                * make sure that the conditions( low rssi, low bw) to switch mode
     3599                * hold for some time and time in turbo exceeds minimum turbo time.
     3600                */
     3601 
     3602                if (sc->sc_dturbo_tcount >= sc->sc_dturbo_turbo_tmin &&
     3603                   sc->sc_dturbo_hold ==0 &&
     3604                   (bss_traffic < sc->sc_dturbo_bw_base || !sc->sc_rate_recn_state)) {
     3605                        sc->sc_dturbo_hold = 1;
     3606                } else {
     3607                        if (sc->sc_dturbo_hold &&
     3608                           bss_traffic >= sc->sc_dturbo_bw_turbo && sc->sc_rate_recn_state) {
     3609                                /* out of hold state */
     3610                                sc->sc_dturbo_hold = 0;
     3611                                sc->sc_dturbo_hold_count = sc->sc_dturbo_hold_max;
     3612                        }
     3613                }
     3614                if (sc->sc_dturbo_hold && sc->sc_dturbo_hold_count)
     3615                        sc->sc_dturbo_hold_count--;
     3616                /*
     3617                 * Current Mode: Turbo (i.e. BOOST)
     3618                 *
     3619                 * Transition to base occurs when one of the following
     3620                 * is true:
     3621                 *    1. its a DTIM beacon.
     3622                 *    2. Maximum time in BOOST has elapsed (120 secs).
     3623                 *    3. Channel is marked with interference
     3624                 *    4. Average BSS traffic falls below 4Mbps
     3625                 *    5. RSSI cannot support at least 18 Mbps rate
     3626                 * XXX do bw checks at true beacon interval?
     3627                 */
     3628                if (dtim &&
     3629                        (sc->sc_dturbo_tcount >= sc->sc_dturbo_turbo_tmax ||
     3630                         ((vap->iv_bss->ni_ath_flags & IEEE80211_ATHC_AR) &&
     3631                          (sc->sc_curchan.privFlags & CHANNEL_INTERFERENCE) &&
     3632                          IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan)) ||
     3633                         !sc->sc_dturbo_hold_count)) {
     3634                        DPRINTF(sc, ATH_DEBUG_TURBO, "%s: Leaving turbo\n",
     3635                                        sc->sc_dev->name);
     3636                        ic->ic_ath_cap &= ~IEEE80211_ATHC_BOOST;
     3637                        vap->iv_bss->ni_ath_flags &= ~IEEE80211_ATHC_BOOST;
     3638                        sc->sc_dturbo_tcount = 0;
     3639                        sc->sc_dturbo_switch = 1;
     3640                }
     3641        } else {
     3642                /*
     3643                 * Current Mode: BASE
     3644                 *
     3645                 * Transition to Turbo (i.e. BOOST) when all of the
     3646                 * following are true:
     3647                 *
     3648                 * 1. its a DTIM beacon.
     3649                 * 2. Dwell time at base has exceeded minimum (70 secs)
     3650                 * 3. Only DT-capable stations are associated
     3651                 * 4. Channel is marked interference-free.
     3652                 * 5. BSS data traffic averages at least 6Mbps
     3653                 * 6. RSSI is good enough to support 36Mbps
     3654                 * XXX do bw+rssi checks at true beacon interval?
     3655                 */
     3656                if (dtim &&
     3657                        (sc->sc_dturbo_tcount >= sc->sc_dturbo_base_tmin &&
     3658                         (ic->ic_dt_sta_assoc != 0 &&
     3659                          ic->ic_sta_assoc == ic->ic_dt_sta_assoc) &&
     3660                         ((vap->iv_bss->ni_ath_flags & IEEE80211_ATHC_AR) == 0 ||
     3661                          (sc->sc_curchan.privFlags & CHANNEL_INTERFERENCE) == 0) &&
     3662                         bss_traffic >= sc->sc_dturbo_bw_turbo &&
     3663                         sc->sc_rate_recn_state)) {
     3664                        DPRINTF(sc, ATH_DEBUG_TURBO, "%s: Entering turbo\n",
     3665                                        sc->sc_dev->name);
     3666                        ic->ic_ath_cap |= IEEE80211_ATHC_BOOST;
     3667                        vap->iv_bss->ni_ath_flags |= IEEE80211_ATHC_BOOST;
     3668                        sc->sc_dturbo_tcount = 0;
     3669                        sc->sc_dturbo_switch = 1;
     3670                        sc->sc_dturbo_hold = 0;
     3671                        sc->sc_dturbo_hold_count = sc->sc_dturbo_hold_max;
     3672                }
     3673        }
     3674}
     3675
     3676
     3677static int
     3678ath_check_beacon_done(struct ath_softc *sc)
     3679{
     3680        struct ieee80211vap *vap=NULL;
     3681        struct ath_vap *avp;
     3682        struct ath_buf *bf;
     3683        struct sk_buff *skb;
     3684        struct ath_desc *ds;
     3685        struct ath_hal *ah = sc->sc_ah;
     3686        int slot;
     3687
     3688        /*
     3689         * check if the last beacon went out with the mode change flag set.
     3690         */
     3691        for (slot = 0; slot < ATH_BCBUF; slot++) {
     3692                if(sc->sc_bslot[slot]) {
     3693                        vap = sc->sc_bslot[slot];
     3694                        break;
     3695                }
     3696        }
     3697        if (!vap)
     3698                 return 0;
     3699        avp = ATH_VAP(vap);
     3700        bf = avp->av_bcbuf;
     3701        skb = bf->bf_skb;
     3702        ds = bf->bf_desc;
     3703
     3704        return (ath_hal_txprocdesc(ah, ds) != HAL_EINPROGRESS);
     3705
     3706}
     3707
     3708/*
     3709 * Effect a turbo mode switch when operating in dynamic
     3710 * turbo mode. wait for beacon to go out before switching.
     3711 */
     3712static void
     3713ath_turbo_switch_mode(unsigned long data)
     3714{
     3715        struct net_device *dev = (struct net_device *)data;
     3716        struct ath_softc *sc = dev->priv;
     3717        struct ieee80211com *ic = &sc->sc_ic;
     3718        int newflags;
     3719
     3720        KASSERT(ic->ic_opmode == IEEE80211_M_HOSTAP,
     3721                ("unexpected operating mode %d", ic->ic_opmode));
     3722
     3723        DPRINTF(sc, ATH_DEBUG_STATE, "%s: dynamic turbo switch to %s mode\n",
     3724                dev->name,
     3725                ic->ic_ath_cap & IEEE80211_ATHC_BOOST ? "turbo" : "base");
     3726
     3727        if (!ath_check_beacon_done(sc)) {
     3728                /*
     3729                 * beacon did not go out. reschedule tasklet.
     3730                 */
     3731                mod_timer(&sc->sc_dturbo_switch_mode, jiffies + msecs_to_jiffies(2));
     3732                return;
     3733        }
     3734
     3735        /* TBD: DTIM adjustments, delay CAB queue tx until after transmit */
     3736        newflags = ic->ic_bsschan->ic_flags;
     3737        if (ic->ic_ath_cap & IEEE80211_ATHC_BOOST) {
     3738                if (IEEE80211_IS_CHAN_2GHZ(ic->ic_bsschan)) {
     3739                        /*
     3740                         * Ignore AR next beacon. the AR detection
     3741                         * code detects the traffic in normal channel
     3742                         * from stations during transition delays
     3743                         * between AP and station.
     3744                         */
     3745                        sc->sc_ignore_ar = 1;
     3746                        ath_hal_ar_disable(sc->sc_ah);
     3747                }
     3748                newflags |= IEEE80211_CHAN_TURBO;
     3749        } else
     3750                newflags &= ~IEEE80211_CHAN_TURBO;
     3751        ieee80211_dturbo_switch(ic, newflags);
     3752        /* XXX ieee80211_reset_erp? */
     3753}
     3754#endif /* ATH_SUPERG_DYNTURBO */
     3755
     3756/*
     3757 * Setup a h/w transmit queue for beacons.
     3758 */
     3759static int
     3760ath_beaconq_setup(struct ath_hal *ah)
     3761{
     3762        HAL_TXQ_INFO qi;
     3763
     3764        memset(&qi, 0, sizeof(qi));
     3765        qi.tqi_aifs = 1;
     3766        qi.tqi_cwmin = 0;
     3767        qi.tqi_cwmax = 0;
     3768#ifdef ATH_SUPERG_DYNTURBO
     3769        qi.tqi_qflags = HAL_TXQ_TXDESCINT_ENABLE;
     3770#endif
     3771        /* NB: don't enable any interrupts */
     3772        return ath_hal_setuptxqueue(ah, HAL_TX_QUEUE_BEACON, &qi);
     3773}
     3774
     3775/*
     3776 * Configure IFS parameter for the beacon queue.
     3777 */
     3778static int
     3779ath_beaconq_config(struct ath_softc *sc)
     3780{
     3781#define ATH_EXPONENT_TO_VALUE(v)        ((1<<v)-1)
     3782        struct ieee80211com *ic = &sc->sc_ic;
     3783        struct ath_hal *ah = sc->sc_ah;
     3784        HAL_TXQ_INFO qi;
     3785
     3786        ath_hal_gettxqueueprops(ah, sc->sc_bhalq, &qi);
     3787        if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
     3788                /*
     3789                 * Always burst out beacon and CAB traffic.
     3790                 */
     3791                qi.tqi_aifs = 1;
     3792                qi.tqi_cwmin = 0;
     3793                qi.tqi_cwmax = 0;
     3794        } else {
     3795                struct wmeParams *wmep =
     3796                        &ic->ic_wme.wme_chanParams.cap_wmeParams[WME_AC_BE];
     3797                /*
     3798                 * Adhoc mode; important thing is to use 2x cwmin.
     3799                 */
     3800                qi.tqi_aifs = wmep->wmep_aifsn;
     3801                qi.tqi_cwmin = 2 * ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmin);
     3802                qi.tqi_cwmax = ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmax);
     3803        }
     3804
     3805        if (!ath_hal_settxqueueprops(ah, sc->sc_bhalq, &qi)) {
     3806                printk("%s: unable to update h/w beacon queue parameters\n",
     3807                        sc->sc_dev->name);
     3808                return 0;
     3809        } else {
     3810                ath_hal_resettxqueue(ah, sc->sc_bhalq); /* push to h/w */
     3811                return 1;
     3812        }
     3813#undef ATH_EXPONENT_TO_VALUE
     3814}
     3815
     3816/*
     3817 * Allocate and setup an initial beacon frame.
     3818 *
     3819 * Context: softIRQ
     3820 */
     3821static int
     3822ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_node *ni)
     3823{
     3824        struct ath_vap *avp = ATH_VAP(ni->ni_vap);
     3825        struct ieee80211_frame *wh;
     3826        struct ath_buf *bf;
     3827        struct sk_buff *skb;
     3828
     3829        /*
     3830         * release the previous beacon's skb if it already exists.
     3831         */
     3832        bf = avp->av_bcbuf;
     3833        if (bf->bf_skb != NULL) {
     3834                bus_unmap_single(sc->sc_bdev,
     3835                    bf->bf_skbaddr, bf->bf_skb->len, BUS_DMA_TODEVICE);
     3836                dev_kfree_skb(bf->bf_skb);
     3837                bf->bf_skb = NULL;
     3838        }
     3839        if (bf->bf_node != NULL) {
     3840                ieee80211_free_node(bf->bf_node);
     3841                bf->bf_node = NULL;
     3842        }
     3843
     3844        /*
     3845         * NB: the beacon data buffer must be 32-bit aligned;
     3846         * we assume the mbuf routines will return us something
     3847         * with this alignment (perhaps should assert).
     3848         */
     3849        skb = ieee80211_beacon_alloc(ni, &avp->av_boff);
     3850        if (skb == NULL) {
     3851                DPRINTF(sc, ATH_DEBUG_BEACON, "%s: cannot get sk_buff\n",
     3852                        __func__);
     3853                sc->sc_stats.ast_be_nobuf++;
     3854                return -ENOMEM;
     3855        }
     3856
     3857        /*
     3858         * Calculate a TSF adjustment factor required for
     3859         * staggered beacons.  Note that we assume the format
     3860         * of the beacon frame leaves the tstamp field immediately
     3861         * following the header.
     3862         */
     3863        if (sc->sc_stagbeacons && avp->av_bslot > 0) {
     3864                uint64_t tuadjust;
     3865                __le64 tsfadjust;
     3866                /*
     3867                 * The beacon interval is in TU's; the TSF in usecs.
     3868                 * We figure out how many TU's to add to align the
     3869                 * timestamp then convert to TSF units and handle
     3870                 * byte swapping before writing it in the frame.
     3871                 * The hardware will then add this each time a beacon
     3872                 * frame is sent.  Note that we align VAPs 1..N
     3873                 * and leave VAP 0 untouched.  This means VAP 0
     3874                 * has a timestamp in one beacon interval while the
     3875                 * others get a timestamp aligned to the next interval.
     3876                 */
     3877                tuadjust = (ni->ni_intval * (ATH_BCBUF - avp->av_bslot)) / ATH_BCBUF;
     3878                tsfadjust = cpu_to_le64(tuadjust << 10);        /* TU->TSF */
     3879
     3880                DPRINTF(sc, ATH_DEBUG_BEACON,
     3881                        "%s: %s beacons, bslot %d intval %u tsfadjust(Kus) %llu\n",
     3882                        __func__, sc->sc_stagbeacons ? "stagger" : "burst",
     3883                        avp->av_bslot, ni->ni_intval, (long long) tuadjust);
     3884
     3885                wh = (struct ieee80211_frame *) skb->data;
     3886                memcpy(&wh[1], &tsfadjust, sizeof(tsfadjust));
     3887        }
     3888
     3889        bf->bf_node = ieee80211_ref_node(ni);
     3890        bf->bf_skbaddr = bus_map_single(sc->sc_bdev,
     3891                skb->data, skb->len, BUS_DMA_TODEVICE);
     3892        bf->bf_skb = skb;
     3893
     3894        return 0;
     3895}
     3896
     3897/*
     3898 * Setup the beacon frame for transmit.
     3899 */
     3900static void
     3901ath_beacon_setup(struct ath_softc *sc, struct ath_buf *bf)
     3902{
     3903#define USE_SHPREAMBLE(_ic) \
     3904        (((_ic)->ic_flags & (IEEE80211_F_SHPREAMBLE | IEEE80211_F_USEBARKER))\
     3905                == IEEE80211_F_SHPREAMBLE)
     3906        struct ieee80211_node *ni = bf->bf_node;
     3907        struct ieee80211com *ic = ni->ni_ic;
     3908        struct sk_buff *skb = bf->bf_skb;
     3909        struct ath_hal *ah = sc->sc_ah;
     3910        struct ath_desc *ds;
     3911        int flags;
     3912        int antenna = sc->sc_txantenna;
     3913        const HAL_RATE_TABLE *rt;
     3914        u_int8_t rix, rate;
     3915        int ctsrate = 0;
     3916        int ctsduration = 0;
     3917
     3918        DPRINTF(sc, ATH_DEBUG_BEACON_PROC, "%s: m %p len %u\n",
     3919                __func__, skb, skb->len);
     3920
     3921        /* setup descriptors */
     3922        ds = bf->bf_desc;
     3923
     3924        flags = HAL_TXDESC_NOACK;
     3925#ifdef ATH_SUPERG_DYNTURBO
     3926        if (sc->sc_dturbo_switch)
     3927                flags |= HAL_TXDESC_INTREQ;
     3928#endif
     3929
     3930        if (ic->ic_opmode == IEEE80211_M_IBSS && sc->sc_hasveol) {
     3931                ds->ds_link = bf->bf_daddr;     /* self-linked */
     3932                flags |= HAL_TXDESC_VEOL;
     3933                /*
     3934                 * Let hardware handle antenna switching if txantenna is not set
     3935                 */
     3936        } else {
     3937                ds->ds_link = 0;
     3938                /*
     3939                 * Switch antenna every beacon if txantenna is not set
     3940                 * Should only switch every beacon period, not for every
     3941                 * SWBA's
     3942                 * XXX assumes two antenna
     3943                 */
     3944                if (antenna == 0) {
     3945                        if (sc->sc_stagbeacons)
     3946                                antenna = ((sc->sc_stats.ast_be_xmit / sc->sc_nbcnvaps) & 1 ? 2 : 1);
     3947                        else
     3948                                antenna = (sc->sc_stats.ast_be_xmit & 1 ? 2 : 1);
     3949                }
     3950        }
     3951
     3952        ds->ds_data = bf->bf_skbaddr;
     3953        /*
     3954         * Calculate rate code.
     3955         * XXX everything at min xmit rate
     3956         */
     3957        rix = sc->sc_minrateix;
     3958        rt = sc->sc_currates;
     3959        rate = rt->info[rix].rateCode;
     3960        if (USE_SHPREAMBLE(ic))
     3961                rate |= rt->info[rix].shortPreamble;
     3962#ifdef ATH_SUPERG_XR
     3963        if (bf->bf_node->ni_vap->iv_flags & IEEE80211_F_XR) {
     3964                u_int8_t cix;
     3965                int pktlen;
     3966                pktlen = skb->len + IEEE80211_CRC_LEN;
     3967                cix = rt->info[sc->sc_protrix].controlRate;
     3968                /* for XR VAP use different RTSCTS rates and calculate duration */
     3969                ctsrate = rt->info[cix].rateCode;
     3970                if (USE_SHPREAMBLE(ic))
     3971                        ctsrate |= rt->info[cix].shortPreamble;
     3972                flags |= HAL_TXDESC_CTSENA;
     3973                rt = sc->sc_xr_rates;
     3974                ctsduration = ath_hal_computetxtime(ah,rt, pktlen,
     3975                        IEEE80211_XR_DEFAULT_RATE_INDEX, AH_FALSE);
     3976                rate = rt->info[IEEE80211_XR_DEFAULT_RATE_INDEX].rateCode;
     3977        }
     3978#endif
     3979        ath_hal_setuptxdesc(ah, ds
     3980                , skb->len + IEEE80211_CRC_LEN  /* frame length */
     3981                , sizeof(struct ieee80211_frame)        /* header length */
     3982                , HAL_PKT_TYPE_BEACON           /* Atheros packet type */
     3983                , ni->ni_txpower                /* txpower XXX */
     3984                , rate, 1                       /* series 0 rate/tries */
     3985                , HAL_TXKEYIX_INVALID           /* no encryption */
     3986                , antenna                       /* antenna mode */
     3987                , flags                         /* no ack, veol for beacons */
     3988                , ctsrate                       /* rts/cts rate */
     3989                , ctsduration                   /* rts/cts duration */
     3990                , 0                             /* comp icv len */
     3991                , 0                             /* comp iv len */
     3992                , ATH_COMP_PROC_NO_COMP_NO_CCS  /* comp scheme */
     3993        );
     3994
     3995        /* NB: beacon's BufLen must be a multiple of 4 bytes */
     3996        ath_hal_filltxdesc(ah, ds
     3997                , roundup(skb->len, 4)  /* buffer length */
     3998                , AH_TRUE               /* first segment */
     3999                , AH_TRUE               /* last segment */
     4000                , ds                    /* first descriptor */
     4001        );
     4002
     4003        /* NB: The desc swap function becomes void,
     4004         * if descriptor swapping is not enabled
     4005         */
     4006        ath_desc_swap(ds);
     4007#undef USE_SHPREAMBLE
     4008}
     4009
     4010/*
     4011 * Generate beacon frame and queue cab data for a VAP.
     4012 */
     4013static struct ath_buf *
     4014ath_beacon_generate(struct ath_softc *sc, struct ieee80211vap *vap, int *needmark)
     4015{
     4016        struct ath_hal *ah = sc->sc_ah;
     4017        struct ath_buf *bf;
     4018        struct ieee80211_node *ni;
     4019        struct ath_vap *avp;
     4020        struct sk_buff *skb;
     4021        int ncabq;
     4022        unsigned int curlen;
     4023
     4024        if (vap->iv_state != IEEE80211_S_RUN) {
     4025                DPRINTF(sc, ATH_DEBUG_BEACON_PROC, "%s: skip VAP in %s state\n",
     4026                        __func__, ieee80211_state_name[vap->iv_state]);
     4027                return NULL;
     4028        }
     4029#ifdef ATH_SUPERG_XR
     4030        if (vap->iv_flags & IEEE80211_F_XR) {
     4031                vap->iv_xrbcnwait++;
     4032                /* wait for XR_BEACON_FACTOR times before sending the beacon */
     4033                if (vap->iv_xrbcnwait < IEEE80211_XR_BEACON_FACTOR)
     4034                        return NULL;
     4035                vap->iv_xrbcnwait = 0;
     4036        }
     4037#endif
     4038        avp = ATH_VAP(vap);
     4039        if (avp->av_bcbuf == NULL) {
     4040                DPRINTF(sc, ATH_DEBUG_ANY, "%s: avp=%p av_bcbuf=%p\n",
     4041                         __func__, avp, avp->av_bcbuf);
     4042                return NULL;
     4043        }
     4044        bf = avp->av_bcbuf;
     4045        ni = bf->bf_node;
     4046
     4047#ifdef ATH_SUPERG_DYNTURBO
     4048        /*
     4049         * If we are using dynamic turbo, update the
     4050         * capability info and arrange for a mode change
     4051         * if needed.
     4052         */
     4053        if (sc->sc_dturbo) {
     4054                u_int8_t dtim;
     4055                dtim = ((avp->av_boff.bo_tim[2] == 1) ||
     4056                        (avp->av_boff.bo_tim[3] == 1));
     4057                ath_beacon_dturbo_update(vap, needmark, dtim);
     4058        }
     4059#endif
     4060        /*
     4061         * Update dynamic beacon contents.  If this returns
     4062         * non-zero then we need to remap the memory because
     4063         * the beacon frame changed size (probably because
     4064         * of the TIM bitmap).
     4065         */
     4066        skb = bf->bf_skb;
     4067        curlen = skb->len;
     4068        ncabq = avp->av_mcastq.axq_depth;
     4069        if (ieee80211_beacon_update(ni, &avp->av_boff, skb, ncabq)) {
     4070                bus_unmap_single(sc->sc_bdev,
     4071                        bf->bf_skbaddr, curlen, BUS_DMA_TODEVICE);
     4072                bf->bf_skbaddr = bus_map_single(sc->sc_bdev,
     4073                        skb->data, skb->len, BUS_DMA_TODEVICE);
     4074        }
     4075
     4076        /*
     4077         * if the CABQ traffic from previous DTIM is pending and the current
     4078         * beacon is also a DTIM.
     4079         *  1) if there is only one VAP let the cab traffic continue.
     4080         *  2) if there are more than one VAP and we are using staggered
     4081         *     beacons, then drain the cabq by dropping all the frames in
     4082         *     the cabq so that the current VAP's cab traffic can be scheduled.
     4083         * XXX: Need to handle the last MORE_DATA bit here.
     4084         */
     4085        if (ncabq && (avp->av_boff.bo_tim[4] & 1) && sc->sc_cabq->axq_depth) {
     4086                if (sc->sc_nvaps > 1 && sc->sc_stagbeacons) {
     4087                        ath_tx_draintxq(sc, sc->sc_cabq);
     4088                        DPRINTF(sc, ATH_DEBUG_BEACON,
     4089                                "%s: flush previous cabq traffic\n", __func__);
     4090                }
     4091        }
     4092
     4093        /*
     4094         * Construct tx descriptor.
     4095         */
     4096        ath_beacon_setup(sc, bf);
     4097
     4098        bus_dma_sync_single(sc->sc_bdev,
     4099                bf->bf_skbaddr, bf->bf_skb->len, BUS_DMA_TODEVICE);
     4100
     4101        /*
     4102         * Enable the CAB queue before the beacon queue to
     4103         * ensure cab frames are triggered by this beacon.
     4104         */
     4105        if (avp->av_boff.bo_tim[4] & 1) {       /* NB: only at DTIM */
     4106                struct ath_txq *cabq = sc->sc_cabq;
     4107                struct ath_buf *bfmcast;
     4108                /*
     4109                 * Move everything from the VAP's mcast queue
     4110                 * to the hardware cab queue.
     4111                 */
     4112                ATH_TXQ_LOCK(&avp->av_mcastq);
     4113                ATH_TXQ_LOCK(cabq);
     4114                bfmcast = STAILQ_FIRST(&avp->av_mcastq.axq_q);
     4115                /* link the descriptors */
     4116                if (cabq->axq_link == NULL)
     4117                        ath_hal_puttxbuf(ah, cabq->axq_qnum, bfmcast->bf_daddr);
     4118                else {
     4119#ifdef AH_NEED_DESC_SWAP
     4120                        *cabq->axq_link = cpu_to_le32(bfmcast->bf_daddr);
     4121#else
     4122                        *cabq->axq_link = bfmcast->bf_daddr;
     4123#endif
     4124                }
     4125
     4126                /* Set the MORE_DATA bit for each packet except the last one */
     4127                STAILQ_FOREACH(bfmcast, &avp->av_mcastq.axq_q, bf_list) {
     4128                        if (bfmcast != STAILQ_LAST(&avp->av_mcastq.axq_q, ath_buf, bf_list))
     4129                                ((struct ieee80211_frame *)bfmcast->bf_skb->data)->i_fc[1] |= IEEE80211_FC1_MORE_DATA;
     4130                }
     4131
     4132                /* append the private VAP mcast list to the cabq */
     4133                ATH_TXQ_MOVE_MCASTQ(&avp->av_mcastq, cabq);
     4134                /* NB: gated by beacon so safe to start here */
     4135                ath_hal_txstart(ah, cabq->axq_qnum);
     4136                ATH_TXQ_UNLOCK(cabq);
     4137                ATH_TXQ_UNLOCK(&avp->av_mcastq);
     4138        }
     4139
     4140        return bf;
     4141}
     4142
     4143/*
     4144 * Transmit one or more beacon frames at SWBA.  Dynamic
     4145 * updates to the frame contents are done as needed and
     4146 * the slot time is also adjusted based on current state.
     4147 */
     4148static void
     4149ath_beacon_send(struct ath_softc *sc, int *needmark)
     4150{
     4151#define TSF_TO_TU(_h,_l) \
     4152        ((((u_int32_t)(_h)) << 22) | (((u_int32_t)(_l)) >> 10))
     4153        struct ath_hal *ah = sc->sc_ah;
     4154        struct ieee80211vap *vap;
     4155        struct ath_buf *bf;
     4156        int slot;
     4157        u_int32_t bfaddr;
     4158
     4159        /*
     4160         * Check if the previous beacon has gone out.  If
     4161         * not don't try to post another, skip this period
     4162         * and wait for the next.  Missed beacons indicate
     4163         * a problem and should not occur.  If we miss too
     4164         * many consecutive beacons reset the device.
     4165         */
     4166        if (ath_hal_numtxpending(ah, sc->sc_bhalq) != 0) {
     4167                sc->sc_bmisscount++;
     4168                /* XXX: 802.11h needs the chanchange IE countdown decremented.
     4169                 *      We should consider adding a net80211 call to indicate
     4170                 *      a beacon miss so appropriate action could be taken
     4171                 *      (in that layer).
     4172                 */
     4173                DPRINTF(sc, ATH_DEBUG_BEACON_PROC,
     4174                        "%s: missed %u consecutive beacons\n",
     4175                        __func__, sc->sc_bmisscount);
     4176                if (sc->sc_bmisscount > BSTUCK_THRESH)
     4177                        ATH_SCHEDULE_TQUEUE(&sc->sc_bstucktq, needmark);
     4178                return;
     4179        }
     4180        if (sc->sc_bmisscount != 0) {
     4181                DPRINTF(sc, ATH_DEBUG_BEACON_PROC,
     4182                        "%s: resume beacon xmit after %u misses\n",
     4183                        __func__, sc->sc_bmisscount);
     4184                sc->sc_bmisscount = 0;
     4185        }
     4186
     4187        /*
     4188         * Generate beacon frames.  If we are sending frames
     4189         * staggered then calculate the slot for this frame based
     4190         * on the tsf to safeguard against missing an swba.
     4191         * Otherwise we are bursting all frames together and need
     4192         * to generate a frame for each VAP that is up and running.
     4193         */
     4194        if (sc->sc_stagbeacons) {               /* staggered beacons */
     4195                struct ieee80211com *ic = &sc->sc_ic;
     4196                u_int64_t tsf;
     4197                u_int32_t tsftu;
     4198
     4199                tsf = ath_hal_gettsf64(ah);
     4200                tsftu = TSF_TO_TU(tsf >> 32, tsf);
     4201                slot = ((tsftu % ic->ic_lintval) * ATH_BCBUF) / ic->ic_lintval;
     4202                vap = sc->sc_bslot[(slot + 1) % ATH_BCBUF];
     4203                DPRINTF(sc, ATH_DEBUG_BEACON_PROC,
     4204                        "%s: slot %d [tsf %llu tsftu %u intval %u] vap %p\n",
     4205                        __func__, slot, (long long) tsf, tsftu, ic->ic_lintval, vap);
     4206                bfaddr = 0;
     4207                if (vap != NULL) {
     4208                        bf = ath_beacon_generate(sc, vap, needmark);
     4209                        if (bf != NULL)
     4210                                bfaddr = bf->bf_daddr;
     4211                }
     4212        } else {                                /* burst'd beacons */
     4213                u_int32_t *bflink;
     4214
     4215                bflink = &bfaddr;
     4216                /* XXX rotate/randomize order? */
     4217                for (slot = 0; slot < ATH_BCBUF; slot++) {
     4218                        vap = sc->sc_bslot[slot];
     4219                        if (vap != NULL) {
     4220                                bf = ath_beacon_generate(sc, vap, needmark);
     4221                                if (bf != NULL) {
     4222#ifdef AH_NEED_DESC_SWAP
     4223                                        if (bflink != &bfaddr)
     4224                                                *bflink = cpu_to_le32(bf->bf_daddr);
     4225                                        else
     4226                                                *bflink = bf->bf_daddr;
     4227#else
     4228                                        *bflink = bf->bf_daddr;
     4229#endif
     4230                                        bflink = &bf->bf_desc->ds_link;
     4231                                }
     4232                        }
     4233                }
     4234                *bflink = 0;                    /* link of last frame */
     4235        }
     4236
     4237        /*
     4238         * Handle slot time change when a non-ERP station joins/leaves
     4239         * an 11g network.  The 802.11 layer notifies us via callback,
     4240         * we mark updateslot, then wait one beacon before effecting
     4241         * the change.  This gives associated stations at least one
     4242         * beacon interval to note the state change.
     4243         *
     4244         * NB: The slot time change state machine is clocked according
     4245         *     to whether we are bursting or staggering beacons.  We
     4246         *     recognize the request to update and record the current
     4247         *     slot then don't transition until that slot is reached
     4248         *     again.  If we miss a beacon for that slot then we'll be
     4249         *     slow to transition but we'll be sure at least one beacon
     4250         *     interval has passed.  When bursting slot is always left
     4251         *     set to ATH_BCBUF so this check is a no-op.
     4252         */
     4253        /* XXX locking */
     4254        if (sc->sc_updateslot == UPDATE) {
     4255                sc->sc_updateslot = COMMIT;     /* commit next beacon */
     4256                sc->sc_slotupdate = slot;
     4257        } else if (sc->sc_updateslot == COMMIT && sc->sc_slotupdate == slot)
     4258                ath_setslottime(sc);            /* commit change to hardware */
     4259
     4260        if ((!sc->sc_stagbeacons || slot == 0) && (!sc->sc_diversity)) {
     4261                int otherant;
     4262                /*
     4263                 * Check recent per-antenna transmit statistics and flip
     4264                 * the default rx antenna if noticeably more frames went out
     4265                 * on the non-default antenna.  Only do this if rx diversity
     4266                 * is off.
     4267                 * XXX assumes 2 antennae
     4268                 */
     4269                otherant = sc->sc_defant & 1 ? 2 : 1;
     4270                if (sc->sc_ant_tx[otherant] > sc->sc_ant_tx[sc->sc_defant] + ATH_ANTENNA_DIFF) {
     4271                        DPRINTF(sc, ATH_DEBUG_BEACON,
     4272                                "%s: flip defant to %u, %u > %u\n",
     4273                                __func__, otherant, sc->sc_ant_tx[otherant],
     4274                                sc->sc_ant_tx[sc->sc_defant]);
     4275                        ath_setdefantenna(sc, otherant);
     4276                }
     4277                sc->sc_ant_tx[1] = sc->sc_ant_tx[2] = 0;
     4278        }
     4279
     4280        if (bfaddr != 0) {
     4281                /*
     4282                 * Stop any current DMA and put the new frame(s) on the queue.
     4283                 * This should never fail since we check above that no frames
     4284                 * are still pending on the queue.
     4285                 */
     4286                if (!ath_hal_stoptxdma(ah, sc->sc_bhalq)) {
     4287                        DPRINTF(sc, ATH_DEBUG_ANY,
     4288                                "%s: beacon queue %u did not stop?\n",
     4289                                __func__, sc->sc_bhalq);
     4290                        /* NB: the HAL still stops DMA, so proceed */
     4291                }
     4292                /* NB: cabq traffic should already be queued and primed */
     4293                ath_hal_puttxbuf(ah, sc->sc_bhalq, bfaddr);
     4294                ath_hal_txstart(ah, sc->sc_bhalq);
     4295
     4296                sc->sc_stats.ast_be_xmit++;             /* XXX per-VAP? */
     4297        }
     4298#undef TSF_TO_TU
     4299}
     4300
     4301/*
     4302 * Reset the hardware after detecting beacons have stopped.
     4303 */
     4304static void
     4305ath_bstuck_tasklet(TQUEUE_ARG data)
     4306{
     4307        struct net_device *dev = (struct net_device *)data;
     4308        struct ath_softc *sc = dev->priv;
     4309        /*
     4310         * XXX:if the bmisscount is cleared while the
     4311         *     tasklet execution is pending, the following
     4312         *     check will be true, in which case return
     4313         *     without resetting the driver.
     4314         */
     4315        if (sc->sc_bmisscount <= BSTUCK_THRESH)
     4316                return;
     4317        printk("%s: stuck beacon; resetting (bmiss count %u)\n",
     4318                dev->name, sc->sc_bmisscount);
     4319        ath_reset(dev);
     4320}
     4321
     4322/*
     4323 * Startup beacon transmission for adhoc mode when
     4324 * they are sent entirely by the hardware using the
     4325 * self-linked descriptor + veol trick.
     4326 */
     4327static void
     4328ath_beacon_start_adhoc(struct ath_softc *sc, struct ieee80211vap *vap)
     4329{
     4330        struct ath_hal *ah = sc->sc_ah;
     4331        struct ath_buf *bf;
     4332        struct ieee80211_node *ni;
     4333        struct ath_vap *avp;
     4334        struct sk_buff *skb;
     4335
     4336        avp = ATH_VAP(vap);
     4337        if (avp->av_bcbuf == NULL) {
     4338                DPRINTF(sc, ATH_DEBUG_ANY, "%s: avp=%p av_bcbuf=%p\n",
     4339                         __func__, avp, avp != NULL ? avp->av_bcbuf : NULL);
     4340                return;
     4341        }
     4342        bf = avp->av_bcbuf;
     4343        ni = bf->bf_node;
     4344
     4345        /*
     4346         * Update dynamic beacon contents.  If this returns
     4347         * non-zero then we need to remap the memory because
     4348         * the beacon frame changed size (probably because
     4349         * of the TIM bitmap).
     4350         */
     4351        skb = bf->bf_skb;
     4352        if (ieee80211_beacon_update(ni, &avp->av_boff, skb, 0)) {
     4353                bus_unmap_single(sc->sc_bdev,
     4354                        bf->bf_skbaddr, bf->bf_skb->len, BUS_DMA_TODEVICE);
     4355                bf->bf_skbaddr = bus_map_single(sc->sc_bdev,
     4356                        skb->data, skb->len, BUS_DMA_TODEVICE);
     4357        }
     4358
     4359        /*
     4360         * Construct tx descriptor.
     4361         */
     4362        ath_beacon_setup(sc, bf);
     4363
     4364        bus_dma_sync_single(sc->sc_bdev,
     4365                bf->bf_skbaddr, bf->bf_skb->len, BUS_DMA_TODEVICE);
     4366
     4367        /* NB: caller is known to have already stopped tx DMA */
     4368        ath_hal_puttxbuf(ah, sc->sc_bhalq, bf->bf_daddr);
     4369        ath_hal_txstart(ah, sc->sc_bhalq);
     4370        DPRINTF(sc, ATH_DEBUG_BEACON_PROC, "%s: TXDP%u = %llx (%p)\n", __func__,
     4371                sc->sc_bhalq, ito64(bf->bf_daddr), bf->bf_desc);
     4372}
     4373
     4374/*
     4375 * Reclaim beacon resources and return buffer to the pool.
     4376 */
     4377static void
     4378ath_beacon_return(struct ath_softc *sc, struct ath_buf *bf)
     4379{
     4380        if (bf->bf_skb != NULL) {
     4381                bus_unmap_single(sc->sc_bdev,
     4382                    bf->bf_skbaddr, bf->bf_skb->len, BUS_DMA_TODEVICE);
     4383                dev_kfree_skb(bf->bf_skb);
     4384                bf->bf_skb = NULL;
     4385        }
     4386        if (bf->bf_node != NULL) {
     4387                ieee80211_free_node(bf->bf_node);
     4388                bf->bf_node = NULL;
     4389        }
     4390        STAILQ_INSERT_TAIL(&sc->sc_bbuf, bf, bf_list);
     4391}
     4392
     4393/*
     4394 * Reclaim all beacon resources.
     4395 */
     4396static void
     4397ath_beacon_free(struct ath_softc *sc)
     4398{
     4399        struct ath_buf *bf;
     4400
     4401        STAILQ_FOREACH(bf, &sc->sc_bbuf, bf_list) {
     4402                if (bf->bf_skb != NULL) {
     4403                        bus_unmap_single(sc->sc_bdev,
     4404                                bf->bf_skbaddr, bf->bf_skb->len, BUS_DMA_TODEVICE);
     4405                        dev_kfree_skb(bf->bf_skb);
     4406                        bf->bf_skb = NULL;
     4407                }
     4408                if (bf->bf_node != NULL) {
     4409                        ieee80211_free_node(bf->bf_node);
     4410                        bf->bf_node = NULL;
     4411                }
     4412        }
     4413}
     4414
     4415/*
     4416 * Configure the beacon and sleep timers.
     4417 *
     4418 * When operating as an AP this resets the TSF and sets
     4419 * up the hardware to notify us when we need to issue beacons.
     4420 *
     4421 * When operating in station mode this sets up the beacon
     4422 * timers according to the timestamp of the last received
     4423 * beacon and the current TSF, configures PCF and DTIM
     4424 * handling, programs the sleep registers so the hardware
     4425 * will wake up in time to receive beacons, and configures
     4426 * the beacon miss handling so we'll receive a BMISS
     4427 * interrupt when we stop seeing beacons from the AP
     4428 * we've associated with.
     4429 *
     4430 * Note : TBTT is Target Beacon Transmission Time (see IEEE
     4431 * 802.11-1999: 4 & 11.2.1.3).
     4432 */
     4433static void
     4434ath_beacon_config(struct ath_softc *sc, struct ieee80211vap *vap)
     4435{
     4436#define TSF_TO_TU(_h,_l) \
     4437        ((((u_int32_t)(_h)) << 22) | (((u_int32_t)(_l)) >> 10))
     4438        struct ieee80211com *ic = &sc->sc_ic;
     4439        struct ath_hal *ah = sc->sc_ah;
     4440        struct ieee80211_node *ni;
     4441        u_int32_t nexttbtt = 0;
     4442        u_int32_t intval;
     4443        u_int64_t tsf, hw_tsf;
     4444        u_int32_t tsftu, hw_tsftu;
     4445        int reset_tsf = 0;
     4446
     4447        if (vap == NULL)
     4448                vap = TAILQ_FIRST(&ic->ic_vaps);   /* XXX */
     4449
     4450        ni = vap->iv_bss;
     4451
     4452        hw_tsf = ath_hal_gettsf64(ah);
     4453        tsf = le64_to_cpu(ni->ni_tstamp.tsf);
     4454        hw_tsftu = hw_tsf >> 10;
     4455        tsftu = tsf >> 10;
     4456
     4457        /* We should reset hw TSF only once, so we increment
     4458         * ni_tstamp.tsf to avoid resetting the hw TSF multiple
     4459         * times */
     4460
     4461        if (tsf == 0) {
     4462                reset_tsf = 1;
     4463                ni->ni_tstamp.tsf = cpu_to_le64(1);
     4464        }
     4465
     4466        /* XXX: Conditionalize multi-bss support? */
     4467        if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
     4468                /* For multi-bss ap support beacons are either staggered
     4469                 * evenly over N slots or burst together.  For the former
     4470                 * arrange for the SWBA to be delivered for each slot.
     4471                 * Slots that are not occupied will generate nothing. */
     4472                /* NB: the beacon interval is kept internally in TU's */
     4473                intval = ic->ic_lintval & HAL_BEACON_PERIOD;
     4474                if (sc->sc_stagbeacons)
     4475                        intval /= ATH_BCBUF;    /* for staggered beacons */
     4476                if ((sc->sc_nostabeacons) &&
     4477                        (vap->iv_opmode == IEEE80211_M_HOSTAP))
     4478                        reset_tsf = 1;
     4479        } else
     4480                intval = ni->ni_intval & HAL_BEACON_PERIOD;
     4481
     4482#define        FUDGE   2
     4483        sc->sc_syncbeacon = 0;
     4484
     4485        if (reset_tsf) {
     4486                /* We just created the interface and TSF will be reset to
     4487                * zero, so next beacon will be sent at the next intval
     4488                * time */
     4489                nexttbtt = intval;
     4490        } else if (intval) {    /* NB: can be 0 for monitor mode */
     4491                if (tsf == 1) {
     4492                        /* We have not received any beacons or probe responses.
     4493                        * The next TBTT must be at least FUDGE ms ahead of the
     4494                        * hw_tsftu. Also, TSF == 0 is a TBTT - IEEE802.11-1999
     4495                        * 11.1.2.2, although I'm not sure it applies here... */
     4496                        nexttbtt = roundup(hw_tsftu + FUDGE, intval);
     4497                } else {
     4498                        if (tsf > hw_tsf) {
     4499                                /* We received a beacon, but the HW TSF has
     4500                                * not been updated (otherwise hw_tsf > tsf).
     4501                                * We cannot use the hardware TSF, so we wait
     4502                                * to synchronise beacons again. */
     4503                                sc->sc_syncbeacon = 1;
     4504                                goto ath_beacon_config_debug;
     4505                        } else {
     4506                                /* Normal case: we received a beacon to which
     4507                                * we have synchornised. Make sure that
     4508                                * nexttbtt is at least FUDGE ms ahead of
     4509                                * hw_tsf. */
     4510                                nexttbtt = tsftu + roundup(hw_tsftu +
     4511                                FUDGE - tsftu, intval);
     4512                        }
     4513                }
     4514        }
     4515
     4516        if (ic->ic_opmode == IEEE80211_M_STA && !(sc->sc_nostabeacons)) {
     4517                HAL_BEACON_STATE bs;
     4518                int dtimperiod, dtimcount;
     4519                int cfpperiod, cfpcount;
     4520
     4521                /* Setup DTIM and CFP parameters according to the last beacon
     4522                 * we have received (which may not have happened). */
     4523                dtimperiod = vap->iv_dtim_period;
     4524                if (dtimperiod <= 0)            /* NB: 0 if not known */
     4525                        dtimperiod = 1;
     4526                dtimcount = vap->iv_dtim_count;
     4527                if (dtimcount >= dtimperiod)    /* NB: sanity check */
     4528                        dtimcount = 0;          /* XXX? */
     4529                cfpperiod = 1;                  /* NB: no PCF support yet */
     4530                cfpcount = 0;
     4531                /*
     4532                 * Pull nexttbtt forward to reflect the current
     4533                 * TSF and calculate dtim+cfp state for the result.
     4534                 */
     4535                nexttbtt = tsftu;
     4536                if (nexttbtt == 0)              /* e.g. for ap mode */
     4537                        nexttbtt = intval;
     4538                do {
     4539                        nexttbtt += intval;
     4540                        if (--dtimcount < 0) {
     4541                                dtimcount = dtimperiod - 1;
     4542                                if (--cfpcount < 0)
     4543                                        cfpcount = cfpperiod - 1;
     4544                        }
     4545                } while (nexttbtt < hw_tsftu + FUDGE);
     4546#undef FUDGE
     4547                memset(&bs, 0, sizeof(bs));
     4548                bs.bs_intval = intval;
     4549                bs.bs_nexttbtt = nexttbtt;
     4550                bs.bs_dtimperiod = dtimperiod * intval;
     4551                bs.bs_nextdtim = bs.bs_nexttbtt + dtimcount * intval;
     4552                bs.bs_cfpperiod = cfpperiod * bs.bs_dtimperiod;
     4553                bs.bs_cfpnext = bs.bs_nextdtim + cfpcount * bs.bs_dtimperiod;
     4554                bs.bs_cfpmaxduration = 0;
     4555#if 0
     4556                /*
     4557                 * The 802.11 layer records the offset to the DTIM
     4558                 * bitmap while receiving beacons; use it here to
     4559                 * enable h/w detection of our AID being marked in
     4560                 * the bitmap vector (to indicate frames for us are
     4561                 * pending at the AP).
     4562                 * XXX do DTIM handling in s/w to WAR old h/w bugs
     4563                 * XXX enable based on h/w rev for newer chips
     4564                 */
     4565                bs.bs_timoffset = ni->ni_timoff;
     4566#endif
     4567                /*
     4568                 * Calculate the number of consecutive beacons to miss
     4569                 * before taking a BMISS interrupt.  The configuration
     4570                 * is specified in TU so we only need calculate based
     4571                 * on the beacon interval.  Note that we clamp the
     4572                 * result to at most 10 beacons.
     4573                 */
     4574                bs.bs_bmissthreshold = howmany(ic->ic_bmisstimeout, intval);
     4575                if (bs.bs_bmissthreshold > 10)
     4576                        bs.bs_bmissthreshold = 10;
     4577                else if (bs.bs_bmissthreshold < 2)
     4578                        bs.bs_bmissthreshold = 2;
     4579
     4580                /*
     4581                 * Calculate sleep duration.  The configuration is
     4582                 * given in ms.  We ensure a multiple of the beacon
     4583                 * period is used.  Also, if the sleep duration is
     4584                 * greater than the DTIM period then it makes senses
     4585                 * to make it a multiple of that.
     4586                 *
     4587                 * XXX fixed at 100ms
     4588                 */
     4589                bs.bs_sleepduration =
     4590                        roundup(IEEE80211_MS_TO_TU(100), bs.bs_intval);
     4591                if (bs.bs_sleepduration > bs.bs_dtimperiod)
     4592                        bs.bs_sleepduration = roundup(bs.bs_sleepduration, bs.bs_dtimperiod);
     4593
     4594                DPRINTF(sc, ATH_DEBUG_BEACON,
     4595                        "%s: tsf %llu tsf:tu %u intval %u nexttbtt %u dtim %u nextdtim %u bmiss %u sleep %u cfp:period %u maxdur %u next %u timoffset %u\n"
     4596                        , __func__
     4597                        , (long long) tsf, tsftu
     4598                        , bs.bs_intval
     4599                        , bs.bs_nexttbtt
     4600                        , bs.bs_dtimperiod
     4601                        , bs.bs_nextdtim
     4602                        , bs.bs_bmissthreshold
     4603                        , bs.bs_sleepduration
     4604                        , bs.bs_cfpperiod
     4605                        , bs.bs_cfpmaxduration
     4606                        , bs.bs_cfpnext
     4607                        , bs.bs_timoffset
     4608                );
     4609
     4610                ic->ic_bmiss_guard = jiffies +
     4611                        IEEE80211_TU_TO_JIFFIES(bs.bs_intval * bs.bs_bmissthreshold);
     4612
     4613                ath_hal_intrset(ah, 0);
     4614                ath_hal_beacontimers(ah, &bs);
     4615                sc->sc_imask |= HAL_INT_BMISS;
     4616                ath_hal_intrset(ah, sc->sc_imask);
     4617        } else {
     4618                ath_hal_intrset(ah, 0);
     4619                if (reset_tsf)
     4620                        intval |= HAL_BEACON_RESET_TSF;
     4621                if (ic->ic_opmode == IEEE80211_M_IBSS) {
     4622                        /*
     4623                         * In IBSS mode enable the beacon timers but only
     4624                         * enable SWBA interrupts if we need to manually
     4625                         * prepare beacon frames.  Otherwise we use a
     4626                         * self-linked tx descriptor and let the hardware
     4627                         * deal with things.
     4628                         */
     4629                        intval |= HAL_BEACON_ENA;
     4630                        if (!sc->sc_hasveol)
     4631                                sc->sc_imask |= HAL_INT_SWBA;
     4632                        ath_beaconq_config(sc);
     4633                } else if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
     4634                        /*
     4635                         * In AP mode we enable the beacon timers and
     4636                         * SWBA interrupts to prepare beacon frames.
     4637                         */
     4638                        intval |= HAL_BEACON_ENA;
     4639                        sc->sc_imask |= HAL_INT_SWBA;   /* beacon prepare */
     4640                        ath_beaconq_config(sc);
     4641                }
     4642#ifdef ATH_SUPERG_DYNTURBO
     4643                ath_beacon_dturbo_config(vap, intval &
     4644                                ~(HAL_BEACON_RESET_TSF | HAL_BEACON_ENA));
     4645#endif
     4646                ath_hal_beaconinit(ah, nexttbtt, intval);
     4647                sc->sc_bmisscount = 0;
     4648                ath_hal_intrset(ah, sc->sc_imask);
     4649                /*
     4650                 * When using a self-linked beacon descriptor in
     4651                 * ibss mode load it once here.
     4652                 */
     4653                if (ic->ic_opmode == IEEE80211_M_IBSS && sc->sc_hasveol)
     4654                        ath_beacon_start_adhoc(sc, vap);
     4655        }
     4656#undef TSF_TO_TU
     4657
     4658        ath_beacon_config_debug:
     4659        /* We print all debug messages here, in order to preserve the
     4660         * time critical aspect of this function */
     4661        DPRINTF(sc, ATH_DEBUG_BEACON,
     4662                "%s: ni=%p tsf=%llu hw_tsf=%llu tsftu=%u hw_tsftu=%u\n",
     4663                __func__, ni, tsf, hw_tsf, tsftu, hw_tsftu);
     4664
     4665        if (reset_tsf)
     4666                /* We just created the interface */
     4667                DPRINTF(sc, ATH_DEBUG_BEACON, "%s: first beacon\n", __func__);
     4668        else if (tsf == 1)
     4669                /* We do not receive any beacons or probe response */
     4670                DPRINTF(sc, ATH_DEBUG_BEACON,
     4671                                "%s: no beacon received...\n",__func__);
     4672        else if (tsf > hw_tsf)
     4673                /* We do receive a beacon and the hw TSF has not been updated */
     4674                DPRINTF(sc, ATH_DEBUG_BEACON,
     4675                                "%s: beacon received, but TSF is incorrect\n",
     4676                                __func__);
     4677        else
     4678                /* We do receive a beacon in the past, normal case */
     4679                DPRINTF(sc, ATH_DEBUG_BEACON,
     4680                                "%s: beacon received, TSF is correct\n",
     4681                                __func__);
     4682
     4683        DPRINTF(sc, ATH_DEBUG_BEACON, "%s: nexttbtt=%u intval=%u\n",
     4684                __func__, nexttbtt, intval & HAL_BEACON_PERIOD);
     4685}
     4686
     4687static int
     4688ath_descdma_setup(struct ath_softc *sc,
     4689        struct ath_descdma *dd, ath_bufhead *head,
     4690        const char *name, int nbuf, int ndesc)
     4691{
     4692#define DS2PHYS(_dd, _ds) \
     4693        ((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc))
     4694        struct ath_desc *ds;
     4695        struct ath_buf *bf;
     4696        int i, bsize, error;
     4697
     4698        DPRINTF(sc, ATH_DEBUG_RESET, "%s: %s DMA: %u buffers %u desc/buf\n",
     4699                __func__, name, nbuf, ndesc);
     4700
     4701        dd->dd_name = name;
     4702        dd->dd_desc_len = sizeof(struct ath_desc) * nbuf * ndesc;
     4703
     4704        /* allocate descriptors */
     4705        dd->dd_desc = bus_alloc_consistent(sc->sc_bdev,
     4706                dd->dd_desc_len, &dd->dd_desc_paddr);
     4707        if (dd->dd_desc == NULL) {
     4708                error = -ENOMEM;
     4709                goto fail;
     4710        }
     4711        ds = dd->dd_desc;
     4712        DPRINTF(sc, ATH_DEBUG_RESET, "%s: %s DMA map: %p (%lu) -> %llx (%lu)\n",
     4713                __func__, dd->dd_name, ds, (u_long) dd->dd_desc_len,
     4714                ito64(dd->dd_desc_paddr), /*XXX*/ (u_long) dd->dd_desc_len);
     4715
     4716        /* allocate buffers */
     4717        bsize = sizeof(struct ath_buf) * nbuf;
     4718        bf = kmalloc(bsize, GFP_KERNEL);
     4719        if (bf == NULL) {
     4720                error = -ENOMEM;                /* XXX different code */
     4721                goto fail2;
     4722        }
     4723        memset(bf, 0, bsize);
     4724        dd->dd_bufptr = bf;
     4725
     4726        STAILQ_INIT(head);
     4727        for (i = 0; i < nbuf; i++, bf++, ds += ndesc) {
     4728                bf->bf_desc = ds;
     4729                bf->bf_daddr = DS2PHYS(dd, ds);
     4730                STAILQ_INSERT_TAIL(head, bf, bf_list);
     4731        }
     4732        return 0;
     4733fail2:
     4734        bus_free_consistent(sc->sc_bdev, dd->dd_desc_len,
     4735                dd->dd_desc, dd->dd_desc_paddr);
     4736fail:
     4737        memset(dd, 0, sizeof(*dd));
     4738        return error;
     4739#undef DS2PHYS
     4740}
     4741
     4742static void
     4743ath_descdma_cleanup(struct ath_softc *sc,
     4744        struct ath_descdma *dd, ath_bufhead *head, int dir)
     4745{
     4746        struct ath_buf *bf;
     4747        struct ieee80211_node *ni;
     4748
     4749        STAILQ_FOREACH(bf, head, bf_list) {
     4750                if (bf->bf_skb != NULL) {
     4751                        /* XXX skb->len is not good enough for rxbuf */
     4752                        if (dd == &sc->sc_rxdma)
     4753                                bus_unmap_single(sc->sc_bdev,
     4754                                        bf->bf_skbaddr, sc->sc_rxbufsize, dir);
     4755                        else
     4756                                bus_unmap_single(sc->sc_bdev,
     4757                                        bf->bf_skbaddr, bf->bf_skb->len, dir);
     4758                        dev_kfree_skb(bf->bf_skb);
     4759                        bf->bf_skb = NULL;
     4760                }
     4761                ni = bf->bf_node;
     4762                bf->bf_node = NULL;
     4763                if (ni != NULL) {
     4764                        /*
     4765                         * Reclaim node reference.
     4766                         */
     4767                        ieee80211_free_node(ni);
     4768                }
     4769        }
     4770
     4771        /* Free memory associated with descriptors */
     4772        bus_free_consistent(sc->sc_bdev, dd->dd_desc_len,
     4773                dd->dd_desc, dd->dd_desc_paddr);
     4774
     4775        STAILQ_INIT(head);
     4776        kfree(dd->dd_bufptr);
     4777        memset(dd, 0, sizeof(*dd));
     4778}
     4779
     4780static int
     4781ath_desc_alloc(struct ath_softc *sc)
     4782{
     4783        int error;
     4784
     4785        error = ath_descdma_setup(sc, &sc->sc_rxdma, &sc->sc_rxbuf,
     4786                        "rx", ATH_RXBUF, 1);
     4787        if (error != 0)
     4788                return error;
     4789
     4790        error = ath_descdma_setup(sc, &sc->sc_txdma, &sc->sc_txbuf,
     4791                        "tx", ATH_TXBUF, ATH_TXDESC);
     4792        if (error != 0) {
     4793                ath_descdma_cleanup(sc, &sc->sc_rxdma, &sc->sc_rxbuf,
     4794                        BUS_DMA_FROMDEVICE);
     4795                return error;
     4796        }
     4797
     4798        /* XXX allocate beacon state together with VAP */
     4799        error = ath_descdma_setup(sc, &sc->sc_bdma, &sc->sc_bbuf,
     4800                        "beacon", ATH_BCBUF, 1);
     4801        if (error != 0) {
     4802                ath_descdma_cleanup(sc, &sc->sc_txdma, &sc->sc_txbuf,
     4803                        BUS_DMA_TODEVICE);
     4804                ath_descdma_cleanup(sc, &sc->sc_rxdma, &sc->sc_rxbuf,
     4805                        BUS_DMA_FROMDEVICE);
     4806                return error;
     4807        }
     4808        return 0;
     4809}
     4810
     4811static void
     4812ath_desc_free(struct ath_softc *sc)
     4813{
     4814        if (sc->sc_bdma.dd_desc_len != 0)
     4815                ath_descdma_cleanup(sc, &sc->sc_bdma, &sc->sc_bbuf,
     4816                        BUS_DMA_TODEVICE);
     4817        if (sc->sc_txdma.dd_desc_len != 0)
     4818                ath_descdma_cleanup(sc, &sc->sc_txdma, &sc->sc_txbuf,
     4819                        BUS_DMA_TODEVICE);
     4820        if (sc->sc_rxdma.dd_desc_len != 0)
     4821                ath_descdma_cleanup(sc, &sc->sc_rxdma, &sc->sc_rxbuf,
     4822                        BUS_DMA_FROMDEVICE);
     4823}
     4824
     4825static struct ieee80211_node *
     4826ath_node_alloc(struct ieee80211_node_table *nt,struct ieee80211vap *vap)
     4827{
     4828        struct ath_softc *sc = nt->nt_ic->ic_dev->priv;
     4829        const size_t space = sizeof(struct ath_node) + sc->sc_rc->arc_space;
     4830        struct ath_node *an;
     4831
     4832        an = kmalloc(space, GFP_ATOMIC);
     4833        if (an == NULL)
     4834                return NULL;
     4835        memset(an, 0, space);
     4836        an->an_decomp_index = INVALID_DECOMP_INDEX;
     4837        an->an_avgrssi = ATH_RSSI_DUMMY_MARKER;
     4838        an->an_halstats.ns_avgbrssi = ATH_RSSI_DUMMY_MARKER;
     4839        an->an_halstats.ns_avgrssi = ATH_RSSI_DUMMY_MARKER;
     4840        an->an_halstats.ns_avgtxrssi = ATH_RSSI_DUMMY_MARKER;
     4841        /*
     4842         * ath_rate_node_init needs a VAP pointer in node
     4843         * to decide which mgt rate to use
     4844         */
     4845        an->an_node.ni_vap = vap;
     4846        sc->sc_rc->ops->node_init(sc, an);
     4847
     4848        /* U-APSD init */
     4849        STAILQ_INIT(&an->an_uapsd_q);
     4850        an->an_uapsd_qdepth = 0;
     4851        STAILQ_INIT(&an->an_uapsd_overflowq);
     4852        an->an_uapsd_overflowqdepth = 0;
     4853        ATH_NODE_UAPSD_LOCK_INIT(an);
     4854
     4855        DPRINTF(sc, ATH_DEBUG_NODE, "%s: an %p\n", __func__, an);
     4856        return &an->an_node;
     4857}
     4858
     4859static void
     4860ath_node_cleanup(struct ieee80211_node *ni)
     4861{
     4862        struct ieee80211com *ic = ni->ni_ic;
     4863        struct ath_softc *sc = ni->ni_ic->ic_dev->priv;
     4864        struct ath_node *an = ATH_NODE(ni);
     4865        struct ath_buf *bf;
     4866       
     4867        /*
     4868         * U-APSD cleanup
     4869         */
     4870        ATH_NODE_UAPSD_LOCK_IRQ(an);
     4871        if (ni->ni_flags & IEEE80211_NODE_UAPSD_TRIG) {
     4872                ni->ni_flags &= ~IEEE80211_NODE_UAPSD_TRIG;
     4873                ic->ic_uapsdmaxtriggers--;
     4874                ni->ni_flags &= ~IEEE80211_NODE_UAPSD_SP;
     4875        }
     4876        ATH_NODE_UAPSD_UNLOCK_IRQ(an);
     4877        while (an->an_uapsd_qdepth) {
     4878                bf = STAILQ_FIRST(&an->an_uapsd_q);
     4879                STAILQ_REMOVE_HEAD(&an->an_uapsd_q, bf_list);
     4880                bf->bf_desc->ds_link = 0;
     4881
     4882                dev_kfree_skb_any(bf->bf_skb);
     4883                bf->bf_skb = NULL;
     4884                bf->bf_node = NULL;
     4885                ATH_TXBUF_LOCK_IRQ(sc);
     4886                STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list);
     4887                ATH_TXBUF_UNLOCK_IRQ(sc);
     4888                ieee80211_free_node(ni);
     4889
     4890                an->an_uapsd_qdepth--;
     4891        }
     4892
     4893        while (an->an_uapsd_overflowqdepth) {
     4894                bf = STAILQ_FIRST(&an->an_uapsd_overflowq);
     4895                STAILQ_REMOVE_HEAD(&an->an_uapsd_overflowq, bf_list);
     4896                bf->bf_desc->ds_link = 0;
     4897
     4898                dev_kfree_skb_any(bf->bf_skb);
     4899                bf->bf_skb = NULL;
     4900                bf->bf_node = NULL;
     4901                ATH_TXBUF_LOCK_IRQ(sc);
     4902                STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list);
     4903                ATH_TXBUF_UNLOCK_IRQ(sc);
     4904                ieee80211_free_node(ni);
     4905
     4906                an->an_uapsd_overflowqdepth--;
     4907        }
     4908
     4909        ATH_NODE_UAPSD_LOCK_IRQ(an);
     4910        sc->sc_node_cleanup(ni);
     4911        ATH_NODE_UAPSD_UNLOCK_IRQ(an);
     4912}
     4913
     4914static void
     4915ath_node_free(struct ieee80211_node *ni)
     4916{
     4917        struct ath_softc *sc = ni->ni_ic->ic_dev->priv;
     4918
     4919        sc->sc_rc->ops->node_cleanup(sc, ATH_NODE(ni));
     4920        sc->sc_node_free(ni);
     4921#ifdef ATH_SUPERG_XR
     4922        ath_grppoll_period_update(sc);
     4923#endif
     4924}
     4925
     4926static u_int8_t
     4927ath_node_getrssi(const struct ieee80211_node *ni)
     4928{
     4929#define HAL_EP_RND(x, mul) \
     4930        ((((x)%(mul)) >= ((mul)/2)) ? ((x) + ((mul) - 1)) / (mul) : (x)/(mul))
     4931        u_int32_t avgrssi = ATH_NODE_CONST(ni)->an_avgrssi;
     4932        int32_t rssi;
     4933
     4934        /*
     4935         * When only one frame is received there will be no state in
     4936         * avgrssi so fallback on the value recorded by the 802.11 layer.
     4937         */
     4938        if (avgrssi != ATH_RSSI_DUMMY_MARKER)
     4939                rssi = HAL_EP_RND(avgrssi, HAL_RSSI_EP_MULTIPLIER);
     4940        else
     4941                rssi = ni->ni_rssi;
     4942        /* NB: theoretically we shouldn't need this, but be paranoid */
     4943        return rssi < 0 ? 0 : rssi > 127 ? 127 : rssi;
     4944#undef HAL_EP_RND
     4945}
     4946
     4947
     4948#ifdef ATH_SUPERG_XR
     4949/*
     4950 * Stops the txqs and moves data between XR and Normal queues.
     4951 * Also adjusts the rate info in the descriptors.
     4952 */
     4953
     4954static u_int8_t
     4955ath_node_move_data(const struct ieee80211_node *ni)
     4956{
     4957#ifdef NOT_YET
     4958        struct ath_txq *txq = NULL;
     4959        struct ieee80211com *ic = ni->ni_ic;
     4960        struct ath_softc *sc = ic->ic_dev->priv;
     4961        struct ath_buf *bf, *prev, *bf_tmp, *bf_tmp1;
     4962        struct ath_hal *ah = sc->sc_ah;
     4963        struct sk_buff *skb = NULL;
     4964        struct ath_desc *ds;
     4965        HAL_STATUS status;
     4966        int index;
     4967
     4968        if (ni->ni_vap->iv_flags & IEEE80211_F_XR) {
     4969                struct ath_txq tmp_q;
     4970                memset(&tmp_q, 0, sizeof(tmp_q));
     4971                STAILQ_INIT(&tmp_q.axq_q);
     4972                /*
     4973                 * move data from Normal txqs to XR queue.
     4974                 */
     4975                printk("move data from NORMAL to XR\n");
     4976                /*
     4977                 * collect all the data towards the node
     4978                 * in to the tmp_q.
     4979                 */
     4980                index = WME_AC_VO;
     4981                while (index >= WME_AC_BE && txq != sc->sc_ac2q[index]) {
     4982                        txq = sc->sc_ac2q[index];
     4983                        ATH_TXQ_LOCK(txq);
     4984                        ath_hal_stoptxdma(ah, txq->axq_qnum);
     4985                        bf = prev = STAILQ_FIRST(&txq->axq_q);
     4986                        /*
     4987                         * skip all the buffers that are done
     4988                         * until the first one that is in progress
     4989                         */
     4990                        while (bf) {
     4991#ifdef ATH_SUPERG_FF
     4992                                ds = &bf->bf_desc[bf->bf_numdesc - 1];
     4993#else
     4994                                ds = bf->bf_desc;               /* NB: last descriptor */
     4995#endif
     4996                                status = ath_hal_txprocdesc(ah, ds);
     4997                                if (status == HAL_EINPROGRESS)
     4998                                        break;
     4999                                prev = bf;
     5000                                bf = STAILQ_NEXT(bf,bf_list);
     5001                        }
     5002                        /*
     5003                         * save the pointer to the last buf that's
     5004                         * done
     5005                         */
     5006                        if (prev == bf)
     5007                                bf_tmp = NULL; 
     5008                        else
     5009                                bf_tmp=prev;
     5010                        while (bf) {
     5011                                if (ni == bf->bf_node) {
     5012                                        if (prev == bf) {
     5013                                                ATH_TXQ_REMOVE_HEAD(txq, bf_list);
     5014                                                STAILQ_INSERT_TAIL(&tmp_q.axq_q, bf, bf_list);
     5015                                                bf = STAILQ_FIRST(&txq->axq_q);
     5016                                                prev = bf;
     5017                                        } else {
     5018                                                STAILQ_REMOVE_AFTER(&(txq->axq_q), prev, bf_list);
     5019                                                txq->axq_depth--;
     5020                                                STAILQ_INSERT_TAIL(&tmp_q.axq_q, bf, bf_list);
     5021                                                bf = STAILQ_NEXT(prev, bf_list);
     5022                                                /*
     5023                                                 * after deleting the node
     5024                                                 * link the descriptors
     5025                                                 */
     5026#ifdef ATH_SUPERG_FF
     5027                                                ds = &prev->bf_desc[prev->bf_numdesc - 1];
     5028#else
     5029                                                ds = prev->bf_desc;     /* NB: last descriptor */
     5030#endif
     5031#ifdef AH_NEED_DESC_SWAP
     5032                                                ds->ds_link = cpu_to_le32(bf->bf_daddr);
     5033#else
     5034                                                ds->ds_link = bf->bf_daddr;
     5035#endif
     5036                                        }
     5037                                } else {
     5038                                        prev = bf;
     5039                                        bf = STAILQ_NEXT(bf, bf_list);
     5040                                }
     5041                        }
     5042                        /*
     5043                         * if the last buf was deleted.
     5044                         * set the pointer to the last descriptor.
     5045                         */
     5046                        bf = STAILQ_FIRST(&txq->axq_q);
     5047                        if (bf) {
     5048                                if (prev) {
     5049                                        bf = STAILQ_NEXT(prev, bf_list);
     5050                                        if (!bf) { /* prev is the last one on the list */
     5051#ifdef ATH_SUPERG_FF
     5052                                                ds = &prev->bf_desc[prev->bf_numdesc - 1];
     5053#else
     5054                                                ds = prev->bf_desc;     /* NB: last descriptor */
     5055#endif
     5056                                                status = ath_hal_txprocdesc(ah, ds);
     5057                                                if (status == HAL_EINPROGRESS)
     5058                                                        txq->axq_link = &ds->ds_link;
     5059                                                else
     5060                                                        txq->axq_link = NULL;   
     5061                                        }
     5062                                }
     5063                        } else
     5064                                txq->axq_link = NULL;
     5065
     5066                        ATH_TXQ_UNLOCK(txq);
     5067                        /*
     5068                         * restart the DMA from the first
     5069                         * buffer that was not DMA'd.
     5070                         */
     5071                        if (bf_tmp)
     5072                                bf = STAILQ_NEXT(bf_tmp, bf_list);
     5073                        else
     5074                                bf = STAILQ_FIRST(&txq->axq_q);
     5075                        if (bf) {       
     5076                                ath_hal_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr);
     5077                                ath_hal_txstart(ah, txq->axq_qnum);
     5078                        }
     5079                }
     5080                /*
     5081                 * queue them on to the XR txqueue.
     5082                 * can not directly put them on to the XR txq. since the
     5083                 * skb data size may be greater than the XR fragmentation
     5084                 * threshold size.
     5085                 */
     5086                bf  = STAILQ_FIRST(&tmp_q.axq_q);
     5087                index = 0;
     5088                while (bf) {
     5089                        skb = bf->bf_skb;
     5090                        bf->bf_skb = NULL;
     5091                        bf->bf_node = NULL;
     5092                        ATH_TXBUF_LOCK(sc);
     5093                        STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list);
     5094                        ATH_TXBUF_UNLOCK(sc);
     5095                        ath_hardstart(skb,sc->sc_dev);
     5096                        ATH_TXQ_REMOVE_HEAD(&tmp_q, bf_list);
     5097                        bf = STAILQ_FIRST(&tmp_q.axq_q);
     5098                        index++;
     5099                }
     5100                printk("moved %d buffers from NORMAL to XR\n", index);
     5101        } else {
     5102                struct ath_txq wme_tmp_qs[WME_AC_VO+1];
     5103                struct ath_txq *wmeq = NULL, *prevq;
     5104                struct ieee80211_frame *wh;
     5105                struct ath_desc *ds = NULL;
     5106                int count = 0;
     5107
     5108                /*
     5109                 * move data from XR txq to Normal txqs.
     5110                 */
     5111                printk("move buffers from XR to NORMAL\n");
     5112                memset(&wme_tmp_qs, 0, sizeof(wme_tmp_qs));
     5113                for (index = 0; index <= WME_AC_VO; index++)
     5114                        STAILQ_INIT(&wme_tmp_qs[index].axq_q);
     5115                txq = sc->sc_xrtxq;
     5116                ATH_TXQ_LOCK(txq);
     5117                ath_hal_stoptxdma(ah, txq->axq_qnum);
     5118                bf = prev = STAILQ_FIRST(&txq->axq_q);
     5119                /*
     5120                 * skip all the buffers that are done
     5121                 * until the first one that is in progress
     5122                 */
     5123                while (bf) {
     5124#ifdef ATH_SUPERG_FF
     5125                        ds = &bf->bf_desc[bf->bf_numdesc - 1];
     5126#else
     5127                        ds = bf->bf_desc;               /* NB: last descriptor */
     5128#endif
     5129                        status = ath_hal_txprocdesc(ah, ds);
     5130                        if (status == HAL_EINPROGRESS)
     5131                                break;
     5132                        prev= bf;
     5133                        bf = STAILQ_NEXT(bf,bf_list);
     5134                }
     5135                /*
     5136                 * save the pointer to the last buf that's
     5137                 * done
     5138                 */
     5139                if (prev == bf)
     5140                        bf_tmp1 = NULL; 
     5141                else
     5142                        bf_tmp1 = prev;
     5143                /*
     5144                 * collect all the data in to four temp SW queues.
     5145                 */
     5146                while (bf) {
     5147                        if (ni == bf->bf_node) {
     5148                                if (prev == bf) {
     5149                                        STAILQ_REMOVE_HEAD(&txq->axq_q,bf_list);
     5150                                        bf_tmp=bf;
     5151                                        bf = STAILQ_FIRST(&txq->axq_q);
     5152                                        prev = bf;
     5153                                } else {
     5154                                        STAILQ_REMOVE_AFTER(&(txq->axq_q),prev,bf_list);
     5155                                        bf_tmp=bf;
     5156                                        bf = STAILQ_NEXT(prev,bf_list);
     5157                                }
     5158                                count++;
     5159                                skb = bf_tmp->bf_skb;
     5160                                wh = (struct ieee80211_frame *) skb->data;
     5161                                if (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_QOS) {
     5162                                        /* XXX validate skb->priority, remove mask */
     5163                                        wmeq = &wme_tmp_qs[skb->priority & 0x3];
     5164                                } else
     5165                                        wmeq = &wme_tmp_qs[WME_AC_BE];
     5166                                STAILQ_INSERT_TAIL(&wmeq->axq_q, bf_tmp, bf_list);
     5167                                ds = bf_tmp->bf_desc;
     5168                                /*
     5169                                 * link the descriptors
     5170                                 */
     5171                                if (wmeq->axq_link != NULL) {
     5172#ifdef AH_NEED_DESC_SWAP
     5173                                        *wmeq->axq_link = cpu_to_le32(bf_tmp->bf_daddr);
     5174#else
     5175                                        *wmeq->axq_link = bf_tmp->bf_daddr;
     5176#endif
     5177                                        DPRINTF(sc, ATH_DEBUG_XMIT, "%s: link[%u](%p)=%p (%p)\n",
     5178                                                        __func__,
     5179                                                        wmeq->axq_qnum, wmeq->axq_link,
     5180                                                        (caddr_t)bf_tmp->bf_daddr, bf_tmp->bf_desc);
     5181                                }
     5182                                wmeq->axq_link = &ds->ds_link;
     5183                                /*
     5184                                 * update the rate information 
     5185                                 */
     5186                        } else {
     5187                                prev = bf;
     5188                                bf = STAILQ_NEXT(bf, bf_list);
     5189                        }
     5190                }
     5191                /*
     5192                 * reset the axq_link pointer to the last descriptor.
     5193                 */
     5194                bf = STAILQ_FIRST(&txq->axq_q);
     5195                if (bf) {
     5196                        if (prev) {
     5197                                bf = STAILQ_NEXT(prev, bf_list);
     5198                                if (!bf) { /* prev is the last one on the list */
     5199#ifdef ATH_SUPERG_FF
     5200                                        ds = &prev->bf_desc[prev->bf_numdesc - 1];
     5201#else
     5202                                        ds = prev->bf_desc;     /* NB: last descriptor */
     5203#endif
     5204                                        status = ath_hal_txprocdesc(ah, ds);
     5205                                        if (status == HAL_EINPROGRESS)
     5206                                                txq->axq_link = &ds->ds_link;
     5207                                        else
     5208                                                txq->axq_link = NULL;
     5209                                }
     5210                        }
     5211                } else {
     5212                        /*
     5213                         * if the list is empty reset the pointer.
     5214                         */
     5215                        txq->axq_link = NULL;
     5216                }
     5217                ATH_TXQ_UNLOCK(txq);
     5218                /*
     5219                 * restart the DMA from the first
     5220                 * buffer that was not DMA'd.
     5221                 */
     5222                if (bf_tmp1)
     5223                        bf = STAILQ_NEXT(bf_tmp1,bf_list);
     5224                else
     5225                        bf = STAILQ_FIRST(&txq->axq_q);
     5226                if (bf) {       
     5227                        ath_hal_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr);
     5228                        ath_hal_txstart(ah, txq->axq_qnum);
     5229                }
     5230
     5231                /*
     5232                 * move (concant) the lists from the temp sw queues in to
     5233                 * WME queues.
     5234                 */
     5235                index = WME_AC_VO;
     5236                txq = NULL;
     5237                while (index >= WME_AC_BE ) {
     5238                        prevq = txq;
     5239                        txq = sc->sc_ac2q[index];
     5240                        if (txq != prevq) {
     5241                                ATH_TXQ_LOCK(txq);
     5242                                ath_hal_stoptxdma(ah, txq->axq_qnum);
     5243                        }
     5244                       
     5245                        wmeq = &wme_tmp_qs[index];
     5246                        bf = STAILQ_FIRST(&wmeq->axq_q);
     5247                        if (bf) {
     5248                                ATH_TXQ_MOVE_Q(wmeq,txq);
     5249                                if (txq->axq_link != NULL) {
     5250#ifdef AH_NEED_DESC_SWAP
     5251                                        *(txq->axq_link) = cpu_to_le32(bf->bf_daddr);
     5252#else
     5253                                        *(txq->axq_link) = bf->bf_daddr;
     5254#endif
     5255                                }
     5256                        }
     5257                        if (index == WME_AC_BE || txq != prevq) {
     5258                                /*
     5259                                 * find the first buffer to be DMA'd.
     5260                                 */
     5261                                bf = STAILQ_FIRST(&txq->axq_q);
     5262                                while (bf) {
     5263#ifdef ATH_SUPERG_FF
     5264                                        ds = &bf->bf_desc[bf->bf_numdesc - 1];
     5265#else
     5266                                        ds = bf->bf_desc;       /* NB: last descriptor */
     5267#endif
     5268                                        status = ath_hal_txprocdesc(ah, ds);
     5269                                        if (status == HAL_EINPROGRESS)
     5270                                                break;
     5271                                        bf = STAILQ_NEXT(bf,bf_list);
     5272                                }
     5273                                if (bf) {
     5274                                        ath_hal_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr);
     5275                                        ath_hal_txstart(ah, txq->axq_qnum);
     5276                                }
     5277                                ATH_TXQ_UNLOCK(txq);
     5278                        }
     5279                        index--;
     5280                }
     5281                printk("moved %d buffers from XR to NORMAL\n", count);
     5282        }
     5283#endif
     5284        return 0;
     5285}
     5286#endif
     5287
     5288static struct sk_buff *
     5289ath_alloc_skb(u_int size, u_int align)
     5290{
     5291        struct sk_buff *skb;
     5292        u_int off;
     5293
     5294        skb = dev_alloc_skb(size + align - 1);
     5295        if (skb != NULL) {
     5296                off = ((unsigned long) skb->data) % align;
     5297                if (off != 0)
     5298                        skb_reserve(skb, align - off);
     5299        }
     5300        return skb;
     5301}
     5302
     5303static int
     5304ath_rxbuf_init(struct ath_softc *sc, struct ath_buf *bf)
     5305{
     5306        struct ath_hal *ah = sc->sc_ah;
     5307        struct sk_buff *skb;
     5308        struct ath_desc *ds;
     5309
     5310        skb = bf->bf_skb;
     5311        if (skb == NULL) {
     5312                if (sc->sc_nmonvaps > 0) {
     5313                        u_int off;
     5314                        int extra = A_MAX(sizeof(struct ath_rx_radiotap_header),
     5315                                          A_MAX(sizeof(wlan_ng_prism2_header), ATHDESC_HEADER_SIZE));
     5316                                               
     5317                        /*
     5318                         * Allocate buffer for monitor mode with space for the
     5319                         * wlan-ng style physical layer header at the start.
     5320                         */
     5321                        skb = dev_alloc_skb(sc->sc_rxbufsize + extra + sc->sc_cachelsz - 1);
     5322                        if (skb == NULL) {
     5323                                DPRINTF(sc, ATH_DEBUG_ANY,
     5324                                        "%s: skbuff alloc of size %u failed\n",
     5325                                        __func__,
     5326                                        sc->sc_rxbufsize + extra + sc->sc_cachelsz - 1);
     5327                                sc->sc_stats.ast_rx_nobuf++;
     5328                                return -ENOMEM;
     5329                        }
     5330                        /*
     5331                         * Reserve space for the Prism header.
     5332                         */
     5333                        skb_reserve(skb, sizeof(wlan_ng_prism2_header));
     5334                        /*
     5335                         * Align to cache line.
     5336                         */
     5337                        off = ((unsigned long) skb->data) % sc->sc_cachelsz;
     5338                        if (off != 0)
     5339                                skb_reserve(skb, sc->sc_cachelsz - off);
     5340                } else {
     5341                        /*
     5342                         * Cache-line-align.  This is important (for the
     5343                         * 5210 at least) as not doing so causes bogus data
     5344                         * in rx'd frames.
     5345                         */
     5346                        skb = ath_alloc_skb(sc->sc_rxbufsize, sc->sc_cachelsz);
     5347                        if (skb == NULL) {
     5348                                DPRINTF(sc, ATH_DEBUG_ANY,
     5349                                        "%s: skbuff alloc of size %u failed\n",
     5350                                        __func__, sc->sc_rxbufsize);
     5351                                sc->sc_stats.ast_rx_nobuf++;
     5352                                return -ENOMEM;
     5353                        }
     5354                }
     5355                skb->dev = sc->sc_dev;
     5356                bf->bf_skb = skb;
     5357                bf->bf_skbaddr = bus_map_single(sc->sc_bdev,
     5358                        skb->data, sc->sc_rxbufsize, BUS_DMA_FROMDEVICE);
     5359        }
     5360
     5361        /*
     5362         * Setup descriptors.  For receive we always terminate
     5363         * the descriptor list with a self-linked entry so we'll
     5364         * not get overrun under high load (as can happen with a
     5365         * 5212 when ANI processing enables PHY error frames).
     5366         *
     5367         * To ensure the last descriptor is self-linked we create
     5368         * each descriptor as self-linked and add it to the end.  As
     5369         * each additional descriptor is added the previous self-linked
     5370         * entry is ``fixed'' naturally.  This should be safe even
     5371         * if DMA is happening.  When processing RX interrupts we
     5372         * never remove/process the last, self-linked, entry on the
     5373         * descriptor list.  This ensures the hardware always has
     5374         * someplace to write a new frame.
     5375         */
     5376        ds = bf->bf_desc;
     5377        ds->ds_link = bf->bf_daddr;             /* link to self */
     5378        ds->ds_data = bf->bf_skbaddr;
     5379        ds->ds_vdata = (void *) skb->data;      /* virt addr of buffer */
     5380        ath_hal_setuprxdesc(ah, ds
     5381                , skb_tailroom(skb)             /* buffer size */
     5382                , 0
     5383        );
     5384        if (sc->sc_rxlink != NULL)
     5385                *sc->sc_rxlink = bf->bf_daddr;
     5386        sc->sc_rxlink = &ds->ds_link;
     5387        return 0;
     5388}
     5389
     5390/*
     5391 * Extend 15-bit time stamp from rx descriptor to
     5392 * a full 64-bit TSF using the current h/w TSF.
     5393 */
     5394static __inline u_int64_t
     5395ath_extend_tsf(struct ath_hal *ah, u_int32_t rstamp)
     5396{
     5397        u_int