if_ath.c

Go to the documentation of this file.

/*
 * Copyright (c) 2004 Massachusetts Institute of Technology
 * John Bicket
 */

/*
 * Originally derived from the following.
 */
/*-
 * Copyright (c) 2002-2004 Sam Leffler, Errno Consulting
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
 *    redistribution must be conditioned upon including a substantially
 *    similar Disclaimer requirement for further binary redistribution.
 * 3. Neither the names of the above-listed copyright holders nor the names
 *    of any contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGES.
 *
 * $Id: if_ath.c,v 1.59 2005/04/19 14:38:23 biswas Exp $
 */

/*
 * Driver for the Atheros Wireless LAN controller.
 *
 * This software is derived from work of Atsushi Onoe; his contribution
 * is greatly appreciated.
 */
#include <linux/config.h>
#include <linux/version.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/random.h>

#include <linux/delay.h>
#include <linux/cache.h>
#include <linux/sysctl.h>
#include <linux/proc_fs.h>
#include <linux/if_arp.h>
#include <linux/wait.h>
#include <linux/timer.h>


#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/if_ether.h>
#include <asm/uaccess.h>
#include "../../click_wifi/packet_anno.h"

#define AR_DEBUG
#include "if_athvar.h"
#include "ah_desc.h"
#include "ah_devid.h"                   /* XXX to identify IBM cards */
#include "if_llc.h"
//#include "ah_osdep.h"
#include "if_ath_bus.h"
#include "if_ethersubr.h"


#ifndef timeradd
# define timeradd(a, b, result)                                               \
  do {                                                                        \
    (result)->tv_sec = (a)->tv_sec + (b)->tv_sec;                             \
    (result)->tv_usec = (a)->tv_usec + (b)->tv_usec;                          \
    if ((result)->tv_usec >= 1000000)                                         \
      {                                                                       \
        ++(result)->tv_sec;                                                   \
        (result)->tv_usec -= 1000000;                                         \
      }                                                                       \
  } while (0)
#endif

#ifndef timersub
# define timersub(a, b, result)                                               \
  do {                                                                        \
    (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;                             \
    (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;                          \
    if ((result)->tv_usec < 0) {                                              \
      --(result)->tv_sec;                                                     \
      (result)->tv_usec += 1000000;                                           \
    }                                                                         \
  } while (0)
#endif
/* unalligned little endian access */     
#define LE_READ_2(p)                                                    \
        ((u_int16_t)                                                    \
         ((((u_int8_t *)(p))[0]      ) | (((u_int8_t *)(p))[1] <<  8)))
#define LE_READ_4(p)                                                    \
        ((u_int32_t)                                                    \
         ((((u_int8_t *)(p))[0]      ) | (((u_int8_t *)(p))[1] <<  8) | \
          (((u_int8_t *)(p))[2] << 16) | (((u_int8_t *)(p))[3] << 24)))

static int      ath_init(struct net_device *);
static int      ath_reset(struct net_device *);
static void     ath_fatal_tasklet(TQUEUE_ARG);
static void     ath_rxorn_tasklet(TQUEUE_ARG);
static int      ath_stop(struct net_device *);
static void     ath_initkeytable(struct net_device *);
static void     ath_mode_init(struct net_device *);
static int      ath_desc_alloc(struct ath_softc *);
static void     ath_desc_free(struct ath_softc *);
static int      ath_rxbuf_init(struct ath_softc *, struct ath_buf *);
static void     ath_rx_tasklet(TQUEUE_ARG data);
static int      ath_tx_setup(struct ath_softc *, int ac, int txq);
static int      ath_hardstart(struct sk_buff *, struct net_device *);
static int      ath_tx_start(struct net_device *, 
                             struct ath_buf *, struct sk_buff *);
static void     ath_tx_tasklet(TQUEUE_ARG data);
static void     ath_tx_timeout(struct net_device *);
static void     ath_draintxq(struct ath_softc *);
static void     ath_stoprecv(struct ath_softc *);
static int      ath_startrecv(struct net_device *);
static void     ath_calibrate(unsigned long);
static struct net_device_stats *ath_getstats(struct net_device *);
static int      ath_getchannels(struct net_device *, u_int cc,
                        HAL_BOOL outdoor, HAL_BOOL xchanmode);
static void ath_update_led(struct ath_softc *, u_int16_t);

static int      ath_set_mac_address(struct net_device *, void *);
static int      ath_change_mtu(struct net_device *, int);
static int      ath_ioctl(struct net_device *, struct ifreq *, int);

static int      ath_setchannel(struct ath_softc *, struct ieee80211channel *channel);

#ifdef CONFIG_SYSCTL
static void     ath_dynamic_sysctl_register(struct ath_softc *);
static void     ath_dynamic_sysctl_unregister(struct ath_softc *);
#endif /* CONFIG_SYSCTL */
static void ath_announce(struct net_device *);

static int ath_rate_setup(struct net_device *dev, u_int mode);
static  int     ath_dwelltime = 200;            /* 5 channels/second */
static  int     ath_calinterval = 30;           /* calibrate every 30 secs */
static  int     ath_countrycode = CTRY_DEFAULT; /* country code */
static  int     ath_regdomain = 0;              /* regulatory domain */
static  int     ath_outdoor = AH_TRUE;         /* enable outdoor use */
static  int     ath_xchanmode = AH_TRUE;        /* enable extended channels */
static  int     ath_phyerr = AH_FALSE;

#ifdef AR_DEBUG
int     ath_debug = 0;
#define IFF_DUMPPKTS(_ic)       (ath_debug)
static  void ath_printrxbuf(struct ath_buf *bf, int);
static  void ath_printtxbuf(struct ath_buf *bf, int);
enum {
  ATH_DEBUG_ANY = 0xffffffff
};

#else
#define IFF_DUMPPKTS(_ic)       (0)
#endif


/*
 * Format an Ethernet MAC for printing.
 */
const char*
ether_sprintf(const u_int8_t *mac)
{
        static char etherbuf[18];
        snprintf(etherbuf, sizeof(etherbuf), "%02x:%02x:%02x:%02x:%02x:%02x",
                mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
        return etherbuf;
}


/*
 * Convert channel to IEEE channel number.
 */
u_int
chan2ieee(struct ath_softc *sc, struct ieee80211channel *c)
{
        if (sc->ic_channels <= c && c <= &sc->ic_channels[IEEE80211_CHAN_MAX])
                return c - sc->ic_channels;
        else if (c == IEEE80211_CHAN_ANYC)
                return IEEE80211_CHAN_ANY;
        else {
                printk(KERN_ERR "wlan: invalid channel freq %u flags %x\n",
                        c->ic_freq, c->ic_flags);
                return 0;               /* XXX */
        }
}


void dump_pkt(struct sk_buff *skb)
{
  u_int8_t *buf = skb->data;
  int i = 0;

  if (!skb) {
    printk("NULL dump_pkt\n");
  }
  printk("len %d ", skb->len);
  
  if (skb->len > 0) {
    for (i = 0; i < skb->len; i++) {
      if ((i & 1) == 0)
        printk(" ");
      printk("%02x", buf[i]);
    }
    printk("\n");
  }

}
void
ieee80211_dump_pkt(u_int8_t *buf, int len, int rate, int rssi)
{
        struct ieee80211_frame *wh;
        int i;

        wh = (struct ieee80211_frame *)buf;
        switch (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
        case IEEE80211_FC1_DIR_NODS:
                printk("NODS %s", ether_sprintf(wh->i_addr2));
                printk("->%s", ether_sprintf(wh->i_addr1));
                printk("(%s)", ether_sprintf(wh->i_addr3));
                break;
        case IEEE80211_FC1_DIR_TODS:
                printk("TODS %s", ether_sprintf(wh->i_addr2));
                printk("->%s", ether_sprintf(wh->i_addr3));
                printk("(%s)", ether_sprintf(wh->i_addr1));
                break;
        case IEEE80211_FC1_DIR_FROMDS:
                printk("FRDS %s", ether_sprintf(wh->i_addr3));
                printk("->%s", ether_sprintf(wh->i_addr1));
                printk("(%s)", ether_sprintf(wh->i_addr2));
                break;
        case IEEE80211_FC1_DIR_DSTODS:
                printk("DSDS %s", ether_sprintf((u_int8_t *)&wh[1]));
                printk("->%s", ether_sprintf(wh->i_addr3));
                printk("(%s", ether_sprintf(wh->i_addr2));
                printk("->%s)", ether_sprintf(wh->i_addr1));
                break;
        }
        switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) {
        case IEEE80211_FC0_TYPE_DATA:
                printk(" data");
                break;
        case IEEE80211_FC0_TYPE_MGT:
          printk(" mgt");
                break;
        default:
                printk(" type#%d", wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK);
                break;
        }
        if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
                int i;
                printk(" WEP [IV");
                for (i = 0; i < IEEE80211_WEP_IVLEN; i++)
                        printk(" %.02x", buf[sizeof(*wh)+i]);
                printk(" KID %u]", buf[sizeof(*wh)+i] >> 6);
        }
        if (rate >= 0)
                printk(" %dM", rate / 2);
        if (rssi >= 0)
                printk(" +%d", rssi);

        printk(" len %d", len);
        printk("\n");
        
        if (0 && len > 0) {
                for (i = 0; i < len; i++) {
                        if ((i & 1) == 0)
                                printk(" ");
                        printk("%02x", buf[i]);
                }
                printk("\n");
        }
}


struct sk_buff *
ieee80211_encap(struct net_device *dev, struct sk_buff *skb)
{
  struct ath_softc *sc = dev->priv;
        struct ether_header eh;
        struct ieee80211_frame *wh;
        struct llc *llc;
        u_int8_t fc0;
        u_int8_t qospri = 0;
        u_int8_t isqos = 0;
        u_int8_t acc = 0;
        u_int16_t headersize = 0;
        u_int16_t  padbytes = 0;

        memcpy(&eh, skb->data, sizeof(struct ether_header));
        skb_pull(skb, sizeof(struct ether_header));

        qospri = 0; acc = WME_AC_BE;

        llc = (struct llc *) skb_push(skb, sizeof(struct llc));
        llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
        llc->llc_control = LLC_UI;
        llc->llc_snap.org_code[0] = 0;
        llc->llc_snap.org_code[1] = 0;
        llc->llc_snap.org_code[2] = 0;
        llc->llc_snap.ether_type = eh.ether_type;

        /* compute headersize and any padbytes */
        headersize += sizeof(struct ieee80211_frame) + isqos;
        if (sc->ic_flags & IEEE80211_F_DATAPAD) {
                padbytes = roundup(headersize, 4) - headersize;
        }

        /*
         * XXX If we're loaded as a module the system may not be
         * configured to leave enough headroom for us to push the
         * 802.11 frame.  In that case fallback on reallocating
         * the frame with enough space.  Alternatively we can carry
         * the frame separately and use s/g support in the hardware.
         */
        if ((skb_headroom(skb) < (headersize+padbytes)) &&
            pskb_expand_head(skb, sizeof(*wh), 0, GFP_ATOMIC)) {
                dev_kfree_skb_any(skb);
                return NULL;
        }
        /* add padding if needed */
        if (padbytes) {
                unsigned char *p;

                p = skb_push(skb, padbytes);
        }

        fc0 = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA;

        /* add qos cntl field, setting only the priority field for now */
        if (isqos) {
                u_int8_t *q;

                q = (u_int8_t *) skb_push(skb, sizeof(struct ieee80211_qoscntl));
                q[0] = qospri;
                q[1] = 0;
                skb->priority = acc;
                fc0 |= IEEE80211_FC0_SUBTYPE_QOS;
        }

        wh = (struct ieee80211_frame *) skb_push(skb, sizeof(struct ieee80211_frame));
        wh->i_fc[0] = fc0;
        *(u_int16_t *)wh->i_dur = 0;
        *(u_int16_t *)wh->i_seq =
          cpu_to_le16(sc->txseq << IEEE80211_SEQ_SEQ_SHIFT);
        sc->txseq++;
        switch (sc->ic_opmode) {
        case IEEE80211_M_STA:
                wh->i_fc[1] = IEEE80211_FC1_DIR_TODS;
                IEEE80211_ADDR_COPY(wh->i_addr1, sc->bssid);
                IEEE80211_ADDR_COPY(wh->i_addr2, eh.ether_shost);
                IEEE80211_ADDR_COPY(wh->i_addr3, eh.ether_dhost);
                break;
        case IEEE80211_M_IBSS:
        case IEEE80211_M_AHDEMO:
                wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
                IEEE80211_ADDR_COPY(wh->i_addr1, eh.ether_dhost);
                IEEE80211_ADDR_COPY(wh->i_addr2, eh.ether_shost);
                IEEE80211_ADDR_COPY(wh->i_addr3, sc->bssid);
                break;
        case IEEE80211_M_HOSTAP:
                wh->i_fc[1] = IEEE80211_FC1_DIR_FROMDS;
                IEEE80211_ADDR_COPY(wh->i_addr1, eh.ether_dhost);
                IEEE80211_ADDR_COPY(wh->i_addr2, sc->bssid);
                IEEE80211_ADDR_COPY(wh->i_addr3, eh.ether_shost);
                break;
        case IEEE80211_M_MONITOR:
                printk("%s: invalid mode\n", __func__);
                break;
        }
        /* NB: PAE frames have their own encryption policy */
        if (sc->ic_flags & IEEE80211_F_WEPON && 
            eh.ether_type != __constant_htons(ETHERTYPE_PAE))
                wh->i_fc[1] |= IEEE80211_FC1_WEP;

        return skb;
}

/*
 * Return the phy mode for with the specified channel so the
 * caller can select a rate set.  This is problematic and the
 * work here assumes how things work elsewhere in this code.
 */
enum ieee80211_phymode
chan2mode(struct ath_softc *sc, struct ieee80211channel *chan)
{
        /*
         * In autoselect mode; deduce a mode based on the channel
         * characteristics.  We assume that turbo-only channels
         * are not considered when the channel set is constructed.
         */
        if (IEEE80211_IS_CHAN_5GHZ(chan))
                return IEEE80211_MODE_11A;
        else if (chan->ic_flags & (IEEE80211_CHAN_OFDM|IEEE80211_CHAN_DYN))
                return IEEE80211_MODE_11G;
        else
                return IEEE80211_MODE_11B;
}


extern        struct iw_statistics *ath_iw_getstats(struct net_device *);
extern  const struct iw_handler_def ath_iw_handler_def;

#define DPRINTF(sc, _m, _fmt, ...) do {                         \
        if (sc->sc_debug & _m)                                  \
                printk(_fmt, __VA_ARGS__);                      \
} while (0)



static  int countrycode = -1;
MODULE_PARM(countrycode, "i");
MODULE_PARM_DESC(countrycode, "Override default country code");
static  int outdoor = -1;
MODULE_PARM(outdoor, "i");
MODULE_PARM_DESC(outdoor, "Enable/disable outdoor use");
static  int xchanmode = -1;
MODULE_PARM(xchanmode, "i");
MODULE_PARM_DESC(xchanmode, "Enable/disable extended channel mode");

static const char *acnames[] = {
        "WME_AC_BE",
        "WME_AC_BK",
        "WME_AC_VI",
        "WME_AC_VO",
        "WME_UPSD",
};


int
ath_attach(u_int16_t devid, struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah;
        int error = 0;
        u_int8_t csz;
        HAL_STATUS status;
        int i;
        u_int32_t result;
        int channels_printed;

        DPRINTF(sc, ATH_DEBUG_ANY, "ath_attach: devid 0x%x\n", devid);
        /*
         * Cache line size is used to size and align various
         * structures used to communicate with the hardware.
         */
        bus_read_cachesize(sc, &csz);
        /* XXX assert csz is non-zero */
        sc->sc_cachelsz = csz << 2;             /* convert to bytes */

        ATH_LOCK_INIT(sc);
        ATH_TXBUF_LOCK_INIT(sc);

        ATH_INIT_TQUEUE(&sc->sc_rxtq,   ath_rx_tasklet,         dev);
        ATH_INIT_TQUEUE(&sc->sc_txtq,   ath_tx_tasklet,         dev);

        ATH_INIT_TQUEUE(&sc->sc_rxorntq,ath_rxorn_tasklet,      dev);
        ATH_INIT_TQUEUE(&sc->sc_fataltq,ath_fatal_tasklet,      dev);

        ah = _ath_hal_attach(devid, sc, 0, (void *) dev->mem_start, &status);
        if (ah == NULL) {
                printk(KERN_ERR "%s: unable to attach hardware; HAL status %u\n",
                        dev->name, status);
                error = ENXIO;
                goto bad;
        }
        if (ah->ah_abi != HAL_ABI_VERSION) {
                printk(KERN_ERR "%s: HAL ABI msmatch; "
                        "driver expects 0x%x, HAL reports 0x%x\n",
                        dev->name, HAL_ABI_VERSION, ah->ah_abi);
                error = ENXIO;          /* XXX */
                goto bad;
        }
        sc->sc_ah = ah;


        /*
         * Check if the MAC has multi-rate retry support.
         * We do this by trying to setup a fake extended
         * descriptor.  MAC's that don't have support will
         * return false w/o doing anything.  MAC's that do
         * support it will return true w/o doing anything.
         */

        if (AH_TRUE !=  ath_hal_setupxtxdesc(ah, NULL, 0,0, 0,0, 0,0)) {
          printk(KERN_WARNING "%s: no multi-rate retry support\n",
                 dev->name);
          goto bad;
        }

        /*
         * Reset the key cache since some parts do not
         * reset the contents on initial power up.
         */
        sc->sc_keymax = ath_hal_keycachesize(ah);
        for (i = 0; i < sc->sc_keymax; i++)
                ath_hal_keyreset(ah, i);
        /*
         * Collect the channel list using the default country
         * code and including outdoor channels.  The 802.11 layer
         * is resposible for filtering this list based on settings
         * like the phy mode.
         */
        if (countrycode != -1)
                ath_countrycode = countrycode;
        if (outdoor != -1)
                ath_outdoor = outdoor;
        if (xchanmode != -1)
                ath_xchanmode = xchanmode;
        error = ath_getchannels(dev, ath_countrycode,
                        ath_outdoor, ath_xchanmode);
        if (error != 0)
                goto bad;

        /*
         * Setup rate tables for all potential media types.
         */
        ath_rate_setup(dev, IEEE80211_MODE_11A);
        ath_rate_setup(dev, IEEE80211_MODE_11B);
        ath_rate_setup(dev, IEEE80211_MODE_11G);
        ath_rate_setup(dev, IEEE80211_MODE_TURBO);


        /*
         * Copy these back; they are set as a side effect
         * of constructing the channel list.
         */
        ath_hal_getregdomain(ah, &ath_regdomain);
        ath_hal_getcountrycode(ah, &ath_countrycode);

        error = ath_desc_alloc(sc);
        if (error != 0) {
                printk("%s: failed to allocate descriptors: %d\n",
                        dev->name, error);
                goto bad;
        }


        /*
         * Allocate hardware transmit queues: one queue for
         * beacon frames and one data queue for each QoS
         * priority.  Note that the hal handles reseting
         * these queues at the needed time.
         *
         * XXX PS-Poll
         */

        /* NB: insure BK queue is h/w queue 0 */
        if (!ath_tx_setup(sc, WME_AC_BE, HAL_WME_AC_BK) ||
            !ath_tx_setup(sc, WME_AC_BK, HAL_WME_AC_BE) ||
            !ath_tx_setup(sc, WME_AC_VI, HAL_WME_AC_VI) ||
            !ath_tx_setup(sc, WME_AC_VO, HAL_WME_AC_VO)) {
                error = EIO;
                goto bad2;
        }

        init_timer(&sc->sc_cal_ch);
        sc->sc_cal_ch.function = ath_calibrate;
        sc->sc_cal_ch.data = (unsigned long) dev;


        sc->sc_ledstate = 1;
        /*
         * Auto-enable soft led processing for IBM cards and for
         * 5211 minipci cards.  Users can also manually enable/disable
         * support with a sysctl.
         */
        sc->sc_softled = (devid == AR5212_DEVID_IBM || devid == AR5211_DEVID);
        if (sc->sc_softled) {
                ath_hal_gpioCfgOutput(ah, sc->sc_ledpin);
                ath_hal_gpioset(ah, sc->sc_ledpin, 0);
        }

        dev->open = ath_init;
        dev->stop = ath_stop;
        dev->hard_start_xmit = ath_hardstart;
        dev->tx_timeout = ath_tx_timeout;
        dev->watchdog_timeo = 5 * HZ;                   /* XXX */
        dev->set_multicast_list = ath_mode_init;
        dev->do_ioctl = ath_ioctl;
        dev->get_stats = ath_getstats;

#ifdef CONFIG_NET_WIRELESS
        dev->get_wireless_stats = ath_iw_getstats;
        dev->wireless_handlers = (struct iw_handler_def *) &ath_iw_handler_def;
#endif

        sc->dev_type = ARPHRD_ETHER;
        ether_setup(dev);
        dev->set_mac_address = ath_set_mac_address;
        dev->change_mtu = &ath_change_mtu;
        dev->mtu = 2000;
        dev->tx_queue_len = ATH_TXBUF;          /* 1 for mgmt frame */

        if (register_netdev(&sc->dev)) {
          printk(KERN_WARNING "%s: unable to register device\n",
                 sc->dev.name);
          goto bad3;
        }
        


        /* XXX not right but it's not used anywhere important */
        sc->ic_phytype = IEEE80211_T_OFDM;
        sc->ic_opmode = IEEE80211_M_STA;
        sc->ic_caps = IEEE80211_C_WEP           /* wep supported */
                | IEEE80211_C_IBSS              /* ibss, nee adhoc, mode */
                | IEEE80211_C_HOSTAP            /* hostap mode */
                | IEEE80211_C_MONITOR           /* monitor mode */
                | IEEE80211_C_TXPMGT            /* transmit power control */
                | IEEE80211_C_SHPREAMBLE;       /* short preamble supported */
        sc->ic_flags |= IEEE80211_F_DATAPAD;
        sc->ic_rts_threshold = IEEE80211_RTS_MAX;


        /*
         * Query the hal about antenna support.
         */
        if (ath_hal_hasdiversity(ah)) {
                sc->sc_hasdiversity = 1;
                sc->sc_diversity = ath_hal_getdiversity(ah);
        }
        sc->sc_defant = ath_hal_getdefantenna(ah);
        sc->sc_txantenna = 0;
        sc->sc_debug = ath_debug;
        sc->sc_rxotherant = 0;

        /* get mac address from hardware */
        ath_hal_getmac(ah, dev->dev_addr);

        if (1) {
          u_int modes = ath_hal_getwirelessmodes(ah, ath_countrycode);
          printk(KERN_WARNING "%s: modes: 0x%02x\n",
                 sc->dev.name,
                 modes);
        }

        result = 0;
        if (HAL_OK != ath_hal_getcapability(ah, HAL_CAP_TXPOW, 0, &result)) {
          printk(KERN_WARNING "%s: couldn't get capability\n",
                 sc->dev.name);
        } else {
          printk(KERN_WARNING "%s: TXPOW %d\n", 
                 sc->dev.name, result);
        }
        result = 0;
        if (HAL_OK != ath_hal_getcapability(ah, HAL_CAP_TPC, 0, &result)) {
          printk(KERN_WARNING "%s: couldn't get capability\n",
                 sc->dev.name);
        } else {
          printk(KERN_WARNING "%s: TXPC %d\n", 
                 sc->dev.name, result);
        }
        /* call MI attach routine. */
        //ieee80211_ifattach(dev);
        {
        /*
         * Fill in 802.11 available channel set, mark
         * all available channels as active, and pick
         * a default channel if not already specified.
         */
          memset(sc->ic_chan_avail, 0, sizeof(sc->ic_chan_avail));
          sc->ic_modecaps |= 1<<IEEE80211_MODE_AUTO;
          sc->current_channel = NULL;
          channels_printed = 0;
          for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
            struct ieee80211channel *c = &sc->ic_channels[i];
            if (c->ic_flags) {
              /*
               * Verify driver passed us valid data.
               */
              if (i != chan2ieee(sc, c)) {
                printk(KERN_WARNING "%s: bad channel ignored; "
                       "freq %u flags %x number %u\n",
                       dev->name, c->ic_freq, c->ic_flags, i);
                c->ic_flags = 0;        /* NB: remove */
                continue;
              }
              if (sc->current_channel == NULL) {
                sc->current_channel = c;
              }
              setbit(sc->ic_chan_avail, i);

              if (channels_printed % 3 == 0) {
                if (channels_printed) {
                  printk("\n");
                }
                printk("%s: available channels:", dev->name);
              }
              channels_printed++;

              printk(" %d (%1d.%3dGHz/", i, 
                     c->ic_freq / 1000, 
                     c->ic_freq % 1000);

              /*
               * Identify mode capabilities.
               */
              if (IEEE80211_IS_CHAN_A(c)) {
                sc->ic_modecaps |= 1<<IEEE80211_MODE_11A;
                printk("a");
              }
              if (IEEE80211_IS_CHAN_B(c)) {
                sc->ic_modecaps |= 1<<IEEE80211_MODE_11B;
                printk("b");
              }
              if (IEEE80211_IS_CHAN_PUREG(c)) {
                sc->ic_modecaps |= 1<<IEEE80211_MODE_11G;
                printk("g");
              }
              if (IEEE80211_IS_CHAN_T(c)) {
                sc->ic_modecaps |= 1<<IEEE80211_MODE_TURBO;
                printk("t");
              }

              if (IEEE80211_IS_CHAN_X(c)) {
                printk("x");
              }
              //printk(" 0x%x", c->ic_flags);
              printk(")");
            }
          }
          if (channels_printed) {
            printk("\n");
          }
        }
        if (!sc->current_channel) {
          printk("no channels?\n");
          return 0;
          //goto bad;
        }

        /*
         * Attach dynamic MIB vars and announce support
         * now that we have a device name with unit number.
         */
#ifdef CONFIG_SYSCTL
        ath_dynamic_sysctl_register(sc);
#endif /* CONFIG_SYSCTL */
        ath_announce(dev);

        printk("%s: 802.11 address: %s\n",
                dev->name, ether_sprintf(dev->dev_addr));

        return ath_init(dev);

bad3:
bad2:
        if (sc->sc_txq[WME_AC_BK].axq_qnum != (u_int) -1)
                ATH_TXQ_LOCK_DESTROY(&sc->sc_txq[WME_AC_BK]);
        if (sc->sc_txq[WME_AC_BE].axq_qnum != (u_int) -1)
                ATH_TXQ_LOCK_DESTROY(&sc->sc_txq[WME_AC_BE]);
        if (sc->sc_txq[WME_AC_VI].axq_qnum != (u_int) -1)
                ATH_TXQ_LOCK_DESTROY(&sc->sc_txq[WME_AC_VI]);
        if (sc->sc_txq[WME_AC_VO].axq_qnum != (u_int) -1)
                ATH_TXQ_LOCK_DESTROY(&sc->sc_txq[WME_AC_VO]);
        ath_desc_free(sc);
bad:
        if (ah)
                ath_hal_detach(ah);
        ATH_TXBUF_LOCK_DESTROY(sc);
        ATH_LOCK_DESTROY(sc);
        sc->sc_invalid = 1;
        return error;
}

int
ath_detach(struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        int i = 0;

        DPRINTF(sc, ATH_DEBUG_ANY, "ath_detach flags %x\n", dev->flags);

        ath_stop(dev);
        sc->sc_invalid = 1;
        ath_desc_free(sc);
        ath_hal_detach(sc->sc_ah);

        ATH_TXBUF_LOCK_DESTROY(sc);
        for (i = 0; i < HAL_NUM_TX_QUEUES; i++)
                if (ATH_TXQ_SETUP(sc, i))
                        ATH_TXQ_LOCK_DESTROY(&sc->sc_txq[i]);

#ifdef CONFIG_SYSCTL
        ath_dynamic_sysctl_unregister(sc);
#endif /* CONFIG_SYSCTL */
        ATH_LOCK_DESTROY(sc);
        unregister_netdev(&sc->dev);
        //ieee80211_ifdetach(dev);

        return 0;
}

void
ath_suspend(struct net_device *dev)
{
  struct ath_softc *sc = dev->priv;
  DPRINTF(sc, ATH_DEBUG_ANY, "ath_suspend flags %x\n", dev->flags);
  ath_stop(dev);
}

void
ath_resume(struct net_device *dev)
{
  struct ath_softc *sc = dev->priv;
  DPRINTF(sc, ATH_DEBUG_ANY, "ath_resume %x\n", dev->flags);
  ath_init(dev);
}

void
ath_shutdown(struct net_device *dev)
{
  struct ath_softc *sc = dev->priv;
  DPRINTF(sc, ATH_DEBUG_ANY, "ath_shutdown %x\n", dev->flags);
  ath_stop(dev);
}

/*
 * Interrupt handler.  Most of the actual processing is
 * deferred to tasklets.
 */
irqreturn_t
ath_intr(int irq, void *dev_id, struct pt_regs *regs)
{
        struct net_device *dev = dev_id;
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        HAL_INT status;
        int needmark;

        if (sc->sc_invalid) {
                /*
                 * The hardware is not ready/present, don't touch anything.
                 * Note this can happen early on if the IRQ is shared.
                 */
                return IRQ_NONE;
        }
        if (!ath_hal_intrpend(ah)) {            /* shared irq, not for us */
                return IRQ_NONE;
        }
        if ((dev->flags & (IFF_RUNNING|IFF_UP)) != (IFF_RUNNING|IFF_UP)) {
          printk("%s: %s: flags 0x%x\n", dev->name, __func__, dev->flags);
          ath_hal_getisr(ah, &status);  /* clear ISR */
          ath_hal_intrset(ah, 0);               /* disable further intr's */
          return IRQ_HANDLED;
        }
        needmark = 0;
        ath_hal_getisr(ah, &status);
        DPRINTF(sc, ATH_DEBUG_ANY, "%s: interrupt, status 0x%x\n", dev->name, status);
#ifdef AR_DEBUG
        if (ath_debug &&
            (status & (HAL_INT_FATAL|HAL_INT_RXORN|HAL_INT_BMISS))) {
                printk("%s: ath_intr: status 0x%x\n", dev->name, status);
                //ath_hal_dumpstate(ah);
        }
#endif /* AR_DEBUG */
        status &= sc->sc_imask;                 /* discard unasked for bits */
        if (status & HAL_INT_FATAL) {
          printk("%s: %s: FATAL\n", dev->name, __func__);
                sc->sc_stats.ast_hardware++;
                ath_hal_intrset(ah, 0);         /* disable intr's until reset */
                ATH_SCHEDULE_TQUEUE(&sc->sc_fataltq, &needmark);
        } else if (status & HAL_INT_RXORN) {
          printk("%s: %s: RXORN\n", dev->name, __func__);
                sc->sc_stats.ast_rxorn++;
                ath_hal_intrset(ah, 0);         /* disable intr's until reset */
                ATH_SCHEDULE_TQUEUE(&sc->sc_rxorntq, &needmark);
        } else {
                if (status & HAL_INT_RXEOL) {
                  DPRINTF(sc, ATH_DEBUG_ANY, "%s: ath_intr: RXEOL\n", dev->name);
                        /*
                         * NB: the hardware should re-read the link when
                         *     RXE bit is written, but it doesn't work at
                         *     least on older hardware revs.
                         */
                        sc->sc_stats.ast_rxeol++;
                        sc->sc_rxlink = NULL;
                }
                if (status & HAL_INT_TXURN) {
                  DPRINTF(sc, ATH_DEBUG_ANY, "%s: ath_intr: TXURN\n", dev->name);
                        sc->sc_stats.ast_txurn++;
                        /* bump tx trigger level */
                        ath_hal_updatetxtriglevel(ah, AH_TRUE);
                }
                if (status & HAL_INT_RX) {
                  DPRINTF(sc, ATH_DEBUG_ANY, "%s: ath_intr: RX\n", dev->name);
                  ATH_SCHEDULE_TQUEUE(&sc->sc_rxtq, &needmark);
                }
                if (status & HAL_INT_TX) {
                  DPRINTF(sc, ATH_DEBUG_ANY, "%s: ath_intr: TX\n", dev->name);
                  ATH_SCHEDULE_TQUEUE(&sc->sc_txtq, &needmark);

                }
                if (status & HAL_INT_SWBA) {
                  DPRINTF(sc, ATH_DEBUG_ANY, "%s: ath_intr: SWBA?\n", dev->name);
                        /*
                         * Handle beacon transmission directly; deferring
                         * this is too slow to meet timing constraints
                         * under load.
                         */
                  //ath_beacon_tasklet(dev);
                }
                if (status & HAL_INT_BMISS) {
                  DPRINTF(sc, ATH_DEBUG_ANY, "%s: ath_intr: BMISS?\n", dev->name);
                        sc->sc_stats.ast_bmiss++;
                        //needmark |= queue_task(&sc->sc_bmisstq, &tq_immediate);
                }
        }
        if (needmark)
                mark_bh(IMMEDIATE_BH);
        return IRQ_HANDLED;
}

static void
ath_fatal_tasklet(TQUEUE_ARG data)
{
        struct net_device *dev = (struct net_device *) data;

        printk("%s: hardware error; resetting\n", dev->name);
        ath_reset(dev);
}

static void
ath_rxorn_tasklet(TQUEUE_ARG data)
{
        struct net_device *dev = (struct net_device *) data;

        printk("%s: rx FIFO overrun; resetting\n", dev->name);
        ath_reset(dev);
}


static u_int
ath_chan2flags(struct ath_softc *sc, struct ieee80211channel *chan)
{
        static const u_int modeflags[] = {
                0,                      /* IEEE80211_MODE_AUTO */
                CHANNEL_A,              /* IEEE80211_MODE_11A */
                CHANNEL_B,              /* IEEE80211_MODE_11B */
                CHANNEL_PUREG,          /* IEEE80211_MODE_11G */
                CHANNEL_T               /* IEEE80211_MODE_TURBO */
        };
        return modeflags[chan2mode(sc, chan)];
}

static int
ath_init(struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        HAL_STATUS status;
        HAL_CHANNEL hchan;

        DPRINTF(sc, ATH_DEBUG_ANY, "ath_init: mode=%d\n",sc->ic_opmode);
        /*
         * Stop anything previously setup.  This is safe
         * whether this is the first time through or not.
         */
        ath_stop(dev);
        
        /*
         * Resize receive skb's if changing to or from monitor mode
         */
        if (sc->ic_opmode == IEEE80211_M_MONITOR) {
                struct ath_buf *bf;
                STAILQ_FOREACH(bf, &sc->sc_rxbuf, bf_list)
                        if (bf->bf_skb != NULL) {
                                bus_unmap_single(sc->sc_bdev,
                                                 bf->bf_skbaddr, sc->sc_rxbufsize,
                                                 BUS_DMA_FROMDEVICE);
                                dev_kfree_skb_any(bf->bf_skb);
                                bf->bf_skb = NULL;
                        }
        }

        /*
         * Change our interface type if we are in monitor mode.
         */
        dev->addr_len = ETH_ALEN;
        dev->type = sc->dev_type;


        if (sc->current_channel == NULL) {
          printk("%s: current_channel == NULL\n", dev->name);
          return EIO;
        }
        
        /*
         * The basic interface to setting the hardware in a good
         * state is ``reset''.  On return the hardware is known to
         * be powered up and with interrupts disabled.  This must
         * be followed by initialization of the appropriate bits
         * and then setup of the interrupt mask.
         */
        if (ath_setchannel(sc, sc->current_channel) != 0) {
          return EIO;
        }

        hchan.channel = sc->current_channel->ic_freq;
        hchan.channelFlags = ath_chan2flags(sc, sc->current_channel);


        if (!ath_hal_reset(ah, sc->ic_opmode, &hchan, AH_FALSE, &status)) {
          printk("%s: unable to reset hardware; hal status %u\n",
                 dev->name, status);
          return EIO;
        }
        

        /*
         * Setup the hardware after reset: the key cache
         * is filled as needed and the receive engine is
         * set going.  Frame transmit is handled entirely
         * in the frame output path; there's nothing to do
         * here except setup the interrupt mask.
         */
        ath_initkeytable(dev);
        if (ath_startrecv(dev) != 0) {
                printk("%s: unable to start recv logic\n", dev->name);
                return EIO;
        }


        if (chan2mode(sc, sc->current_channel) != sc->ic_curmode) {
          printk (KERN_EMERG "%s: mode incorrect!\n",
                  __func__);
          return -EIO;
        }
        

        dev->flags |= IFF_RUNNING;

        /*
         * Enable interrupts.
         */
        sc->sc_imask = HAL_INT_RX | HAL_INT_TX
                  | HAL_INT_RXEOL | HAL_INT_RXORN
                  | HAL_INT_FATAL | HAL_INT_GLOBAL;
        ath_hal_intrset(ah, sc->sc_imask);

        netif_start_queue(dev);
        //ath_hal_setassocid(ah, sc->bssid, 0);
        return 0;
}

static int
ath_stop_locked(struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;

        DPRINTF(sc, ATH_DEBUG_ANY, "%s: invalid %u flags 0x%x\n",
                __func__, sc->sc_invalid, dev->flags);

        if (dev->flags & IFF_RUNNING) {
                /*
                 * Shutdown the hardware and driver:
                 *    reset 802.11 state machine (do first so
                 *      station deassoc/deauth frames can be sent)
                 *    stop output from above
                 *    disable interrupts
                 *    turn off timers
                 *    turn off the radio
                 *    clear transmit machinery
                 *    clear receive machinery
                 *    reclaim beacon resources
                 *    power down hardware
                 *
                 * Note that some of this work is not possible if the
                 * hardware is gone (invalid).
                 */
                netif_stop_queue(dev);
                dev->flags &= ~IFF_RUNNING;
                if (!sc->sc_invalid) {
                        if (sc->sc_softled)
                                ath_hal_gpioset(ah, sc->sc_ledpin, 1);
                        ath_hal_intrset(ah, 0);
                }
                ath_draintxq(sc);
                if (!sc->sc_invalid) {
                        ath_stoprecv(sc);
                        ath_hal_phydisable(ah);
                } else
                        sc->sc_rxlink = NULL;
        }
        return 0;
}

static int
ath_stop(struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        int error;

        ATH_LOCK(sc);
        error = ath_stop_locked(dev);
        if (error == 0 && !sc->sc_invalid) {
                /*
                 * Set the chip in full sleep mode.  Note that we are
                 * careful to do this only when bringing the interface
                 * completely to a stop.  When the chip is in this state
                 * it must be carefully woken up or references to
                 * registers in the PCI clock domain may freeze the bus
                 * (and system).  This varies by chip and is mostly an
                 * issue with newer parts that go to sleep more quickly.
                 */
                ath_hal_setpower(sc->sc_ah, HAL_PM_FULL_SLEEP, 0);
        }
        ATH_UNLOCK(sc);
        return error;
}

/*
 * Reset the hardware w/o losing operational state.  This is
 * basically a more efficient way of doing ath_stop, ath_init,
 * followed by state transitions to the current 802.11
 * operational state.  Used to recover from errors rx overrun
 * and to reset the hardware when rf gain settings must be reset.
 */
static int
ath_reset(struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        struct ieee80211channel *c;
        HAL_STATUS status;
        HAL_CHANNEL hchan;

        /*
         * Convert to a HAL channel description with the flags
         * constrained to reflect the current operating mode.
         */
        c = sc->current_channel;
        hchan.channel = c->ic_freq;
        hchan.channelFlags = ath_chan2flags(sc, c);

        ath_hal_intrset(ah, 0);         /* disable interrupts */
        ath_draintxq(sc);               /* stop xmit side */
        ath_stoprecv(sc);               /* stop recv side */
        /* NB: indicate channel change so we do a full reset */
        if (!ath_hal_reset(ah, sc->ic_opmode, &hchan, AH_TRUE, &status))
                printk("%s: %s: unable to reset hardware; hal status %u\n",
                        dev->name, __func__, status);
        if (ath_startrecv(dev) != 0)    /* restart recv */
                printk("%s: %s: unable to start recv logic\n",
                        dev->name, __func__);

        ath_hal_intrset(ah, sc->sc_imask);

        
        netif_wake_queue(dev);  /* restart xmit */
        return 0;
}

/*
 * XXX System may not be
 * configured to leave enough headroom for us to push the
 * 802.11 frame.  In that case fallback on reallocating
 * the frame with enough space.  Alternatively we can carry
 * the frame separately and use s/g support in the hardware.
 */
static int
ath_skbhdr_adjust(struct sk_buff *skb, struct net_device *dev)
{
        struct ath_softc *sc = (void*)dev->priv;
        int len = sizeof(struct ieee80211_qosframe) + sizeof(struct llc) +
                IEEE80211_ADDR_LEN - sizeof(struct ether_header);

        if (sc->ic_flags & IEEE80211_F_WEPON)
                len += IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN;
        if ((skb_headroom(skb) < len) &&
            pskb_expand_head(skb, len - skb_headroom(skb), 0, GFP_ATOMIC)) {
                dev_kfree_skb_any(skb);
                return -ENOMEM;
        }
        return 0;
}

/*
 * Transmit a data packet.  On failure caller is
 * assumed to reclaim the resources.
 */
static int
ath_hardstart(struct sk_buff *skb, struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        struct ath_buf *bf = NULL;
        int error;


        DPRINTF(sc, ATH_DEBUG_ANY, "%s: hardstart\n", dev->name);

        if ((dev->flags & IFF_RUNNING) == 0 || sc->sc_invalid) {
                DPRINTF(sc, ATH_DEBUG_ANY, "%s: discard, invalid %d flags %x\n", __func__,
                        sc->sc_invalid, dev->flags);
                sc->sc_stats.ast_tx_invalid++;
                return -ENETDOWN;
        }
        
        error = ath_skbhdr_adjust(skb, dev);
        if (error != 0)
                return error;


        /*
         * We don't need to encapsulate the packets here,
         * they should be ieee_80211_frames.
         */


        if (skb->len > sizeof(wlan_ng_prism2_header)) {
          pull_prism2_header(skb);
        }


        if (skb->len > sizeof(struct click_wifi_extra)) {
          pull_wifi_extra_header(skb);
        }



        /*
         * Grab a TX buffer and associated resources.
         */
        ATH_TXBUF_LOCK_BH(sc);
        bf = STAILQ_FIRST(&sc->sc_txbuf);
        if (bf != NULL)
          STAILQ_REMOVE_HEAD(&sc->sc_txbuf, bf_list);
        /* XXX use a counter and leave at least one for mgmt frames */
        if (STAILQ_EMPTY(&sc->sc_txbuf)) {
                DPRINTF(sc, ATH_DEBUG_ANY, "%s: stop queue\n", __func__);
                sc->sc_stats.ast_tx_qstop++;
                netif_stop_queue(dev);
        }
        ATH_TXBUF_UNLOCK_BH(sc);
        if (bf == NULL) {               /* NB: should not happen */
                printk("%s: discard, no xmit buf\n", __func__);
                sc->sc_stats.ast_tx_nobuf++;
                goto bad;
        }


        /*
         * Locate node state.  When operating
         * in station mode we always use ic_bss.
         */

        error = ath_tx_start(dev, bf, skb);


        //print_intr(sc);


        if (error == 0)
                return 0;
        /* fall thru... */
bad:
        printk("%s: %s got to bad\n", dev->name, __func__);
        if (bf != NULL) {
                ATH_TXBUF_LOCK_BH(sc);
                STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list);
                ATH_TXBUF_UNLOCK_BH(sc);
        }
        if (skb)
                dev_kfree_skb_any(skb);
        return 0;       /* NB: return !0 only in a ``hard error condition'' */
}

/*
 * Calculate the receive filter according to the
 * operating mode and state:
 *
 * o always accept unicast, broadcast, and multicast traffic
 * o maintain current state of phy error reception
 * o probe request frames are accepted only when operating in
 *   hostap, adhoc, or monitor modes
 * o enable promiscuous mode according to the interface state
 * o accept beacons:
 *   - when operating in adhoc mode so the 802.11 layer creates
 *     node table entries for peers,
 *   - when operating in station mode for collecting rssi data when
 *     the station is otherwise quiet, or
 *   - when scanning
 */
static u_int32_t
ath_calcrxfilter(struct net_device *dev)
{
        u_int32_t rfilt;

        rfilt = HAL_RX_FILTER_UCAST | HAL_RX_FILTER_BCAST | HAL_RX_FILTER_MCAST;

        rfilt |= HAL_RX_FILTER_PROBEREQ;

        if (dev->flags & IFF_PROMISC) {
        rfilt |= HAL_RX_FILTER_PROM;
        rfilt |= HAL_RX_FILTER_CONTROL;
        }

        if (ath_phyerr) {
          rfilt |= HAL_RX_FILTER_PHYERR;
        }


        rfilt |= HAL_RX_FILTER_BEACON;
        return rfilt;
}

static void
ath_mode_init(struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        u_int32_t rfilt, mfilt[2], val;
        u_int8_t pos;
        struct dev_mc_list *mc;

        /* configure rx filter */
        rfilt = ath_calcrxfilter(dev);
        ath_hal_setrxfilter(ah, rfilt);

        /* configure operational mode */
        ath_hal_setopmode(ah);

        /* calculate and install multicast filter */
        if ((dev->flags & IFF_ALLMULTI) == 0) {
                mfilt[0] = mfilt[1] = 0;
                for (mc = dev->mc_list; mc; mc = mc->next) {
                        /* calculate XOR of eight 6bit values */
                        val = LE_READ_4(mc->dmi_addr + 0);
                        pos = (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
                        val = LE_READ_4(mc->dmi_addr + 3);
                        pos ^= (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
                        pos &= 0x3f;
                        mfilt[pos / 32] |= (1 << (pos % 32));
                }
        } else {
                mfilt[0] = mfilt[1] = ~0;
        }
        ath_hal_setmcastfilter(ah, mfilt[0], mfilt[1]);
        DPRINTF(sc, ATH_DEBUG_ANY, "ath_mode_init: RX filter 0x%x, MC filter %08x:%08x\n",
                rfilt, mfilt[0], mfilt[1]);
}

static struct sk_buff *
ath_alloc_skb(u_int size, u_int align)
{
        struct sk_buff *skb;
        u_int off;

        skb = dev_alloc_skb(size + align-1);
        if (skb != NULL) {
                off = ((unsigned long) skb->data) % align;
                if (off != 0)
                        skb_reserve(skb, align - off);
        }
        return skb;
}

static int
ath_desc_alloc(struct ath_softc *sc)
{
#define DS2PHYS(_sc, _ds) \
        ((_sc)->sc_desc_daddr + ((caddr_t)(_ds) - (caddr_t)(_sc)->sc_desc))
        int i, bsize;
        struct ath_desc *ds;
        struct ath_buf *bf;

        /* allocate descriptors */
        sc->sc_desc_len = sizeof(struct ath_desc) *
                (ATH_TXBUF * ATH_TXDESC + ATH_RXBUF + 1);
        sc->sc_desc = bus_alloc_consistent(sc->sc_bdev,
                                           sc->sc_desc_len, &sc->sc_desc_daddr);
        if (sc->sc_desc == NULL)
                return ENOMEM;
        ds = sc->sc_desc;
        DPRINTF(sc, ATH_DEBUG_ANY, "ath_desc_alloc: DMA map: %p (%d) -> %p\n",
            ds, sc->sc_desc_len, (caddr_t) sc->sc_desc_daddr);

        /* allocate buffers */
        bsize = sizeof(struct ath_buf) * (ATH_TXBUF + ATH_RXBUF + 1);
        bf = kmalloc(bsize, GFP_KERNEL);
        if (bf == NULL)
                goto bad;
        memset(bf, 0, bsize);
        sc->sc_bufptr = bf;

        STAILQ_INIT(&sc->sc_rxbuf);
        for (i = 0; i < ATH_RXBUF; i++, bf++, ds++) {
                bf->bf_desc = ds;
                bf->bf_daddr = sc->sc_desc_daddr +
                    ((caddr_t)ds - (caddr_t)sc->sc_desc);
                STAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list);
        }

        STAILQ_INIT(&sc->sc_txbuf);
        for (i = 0; i < ATH_TXBUF; i++, bf++, ds += ATH_TXDESC) {
                bf->bf_desc = ds;
                bf->bf_daddr = sc->sc_desc_daddr +
                    ((caddr_t)ds - (caddr_t)sc->sc_desc);
                STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list);
        }
        /* beacon buffer */
        //bf->bf_desc = ds;
        //bf->bf_daddr = sc->sc_desc_daddr + ((caddr_t)ds - (caddr_t)sc->sc_desc);
        //sc->sc_bcbuf = bf;
        sc->sc_bcbuf = NULL;
        return 0;
bad:
        bus_free_consistent(sc->sc_bdev, sc->sc_desc_len,
                            sc->sc_desc, sc->sc_desc_daddr);
        sc->sc_desc = NULL;
        return ENOMEM;
}

static void
ath_desc_free(struct ath_softc *sc)
{
        struct ath_buf *bf;

        /*
         * NB: TX queues have already been freed in ath_draintxq(),
         * which must be called before calling this function.
         */

        /* Free all pre-allocated RX skb */
        STAILQ_FOREACH(bf, &sc->sc_rxbuf, bf_list)
                if (bf->bf_skb != NULL) {
                        bus_unmap_single(sc->sc_bdev,
                                         bf->bf_skbaddr, sc->sc_rxbufsize,
                                         BUS_DMA_FROMDEVICE);
                        dev_kfree_skb_any(bf->bf_skb);
                        bf->bf_skb = NULL;
                }

        /* If beacon skb has not been freed yet, do it now */
        if (sc->sc_bcbuf != NULL) {
                bf = sc->sc_bcbuf;
                if (bf->bf_skb != NULL) {
                        bus_unmap_single(sc->sc_bdev, bf->bf_skbaddr,
                                         bf->bf_skb->len, BUS_DMA_TODEVICE);
                }
                sc->sc_bcbuf = NULL;
        }

        /* Free memory associated with all descriptors */
        bus_free_consistent(sc->sc_bdev, sc->sc_desc_len,
                            sc->sc_desc, sc->sc_desc_daddr);

        STAILQ_INIT(&sc->sc_rxbuf);
        STAILQ_INIT(&sc->sc_txbuf);
        kfree(sc->sc_bufptr);
        sc->sc_bufptr = NULL;
}

static int
ath_rxbuf_init(struct ath_softc *sc, struct ath_buf *bf)
{
        struct ath_hal *ah = sc->sc_ah;
        struct sk_buff *skb;
        struct ath_desc *ds;

        skb = bf->bf_skb;
        if (skb == NULL) {
          
          /*
           * Cache-line-align.  This is important (for the
           * 5210 at least) as not doing so causes bogus data
           * in rx'd frames.
           */
          skb = ath_alloc_skb(sc->sc_rxbufsize, sc->sc_cachelsz);
          if (skb == NULL) {
            DPRINTF(sc, ATH_DEBUG_ANY, "%s: skbuff alloc of size %u failed\n",
                     __func__, sc->sc_rxbufsize);
            sc->sc_stats.ast_rx_nobuf++;
            return ENOMEM;
          }

          skb_reserve(skb, sizeof(wlan_ng_prism2_header));

          skb->dev = &sc->dev;
          bf->bf_skb = skb;
          bf->bf_skbaddr = bus_map_single(sc->sc_bdev,
                                          skb->data, sc->sc_rxbufsize, BUS_DMA_FROMDEVICE);
        }

        /*
         * Setup descriptors.  For receive we always terminate
         * the descriptor list with a self-linked entry so we'll
         * not get overrun under high load (as can happen with a
         * 5212 when ANI processing enables PHY errors).
         *
         * To insure the last descriptor is self-linked we create
         * each descriptor as self-linked and add it to the end.  As
         * each additional descriptor is added the previous self-linked
         * entry is ``fixed'' naturally.  This should be safe even
         * if DMA is happening.  When processing RX interrupts we
         * never remove/process the last, self-linked, entry on the
         * descriptor list.  This insures the hardware always has
         * someplace to write a new frame.
         */
        ds = bf->bf_desc;
        ds->ds_link = bf->bf_daddr;             /* link to self */
        ds->ds_data = bf->bf_skbaddr;
        ath_hal_setuprxdesc(ah, ds
                , skb_tailroom(skb)             /* buffer size */
                , 0
        );

        if (sc->sc_rxlink != NULL)
                *sc->sc_rxlink = bf->bf_daddr;
        sc->sc_rxlink = &ds->ds_link;
        return 0;
}


static void
ath_update_led (struct ath_softc *sc, u_int16_t ledstate)
{
        struct ath_hal *ah = sc->sc_ah;
        /*
         * When not associated, flash LED on for 5s, off for 200ms.
         * XXX this assumes 100ms beacon interval.
         */
        ath_hal_gpioCfgOutput(ah, sc->sc_ledpin);
        ath_hal_gpioset(ah, sc->sc_ledpin, ledstate);
        sc->sc_ledstate = ledstate;

}

struct sk_buff *
ieee80211_decap(struct net_device *dev, struct sk_buff *skb)
{
        struct ether_header *eh;
        struct ieee80211_frame wh;
        struct llc *llc;
        u_short ether_type = 0;

        memcpy(&wh, skb->data, sizeof(struct ieee80211_frame));
        llc = (struct llc *) skb_pull(skb, sizeof(struct ieee80211_frame));
        if (llc->llc_dsap == LLC_SNAP_LSAP && llc->llc_ssap == LLC_SNAP_LSAP &&
            llc->llc_control == LLC_UI && llc->llc_snap.org_code[0] == 0 &&
            llc->llc_snap.org_code[1] == 0 && llc->llc_snap.org_code[2] == 0) {
                ether_type = llc->llc_un.type_snap.ether_type;
                skb_pull(skb, sizeof(struct llc));
                llc = NULL;
        }
        eh = (struct ether_header *) skb_push(skb, sizeof(struct ether_header));
        if (!eh) {
          return skb;
        }
        switch (wh.i_fc[1] & IEEE80211_FC1_DIR_MASK) {
        case IEEE80211_FC1_DIR_NODS:
                IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr1);
                IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr2);
                break;
        case IEEE80211_FC1_DIR_TODS:
                IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr3);
                IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr2);
                break;
        case IEEE80211_FC1_DIR_FROMDS:
                IEEE80211_ADDR_COPY(eh->ether_dhost, wh.i_addr1);
                IEEE80211_ADDR_COPY(eh->ether_shost, wh.i_addr3);
                break;
        case IEEE80211_FC1_DIR_DSTODS:
                /* not yet supported */
                printk("%s: DS to DS\n", __func__);
                dev_kfree_skb_any(skb);
                return NULL;
        }
        if (!ALIGNED_POINTER(skb->data + sizeof(*eh), u_int32_t)) {
                struct sk_buff *n;

                /* XXX does this always work? */
                n = skb_copy(skb, GFP_ATOMIC);
                dev_kfree_skb_any(skb);
                if (n == NULL)
                        return NULL;
                skb = n;
                eh = (struct ether_header *) skb->data;
        }
        if (llc != NULL)
                eh->ether_type = htons(skb->len - sizeof(*eh));
        else
                eh->ether_type = ether_type;
        return skb;
}

static struct timeval get_stamp(struct ath_hal *ah, u_int32_t t) {
  struct timeval now;
  struct timeval stamp;
  u_int32_t tsf_now;
  u_int32_t tsf;
  u_int32_t d;
  u_int32_t period;
  struct timeval diff;

  /*
   * Rx descriptor has the low 15 bits of the tsf at
   * the time the frame was received.  Use the current
   * tsf to extend this to 32 bits.
   */
  t &= 0x7fff;

  
  tsf_now = ath_hal_gettsf32(ah);
  tsf = tsf_now;
  do_gettimeofday(&now);
  if ((tsf & 0x7fff) < t)
    tsf -= 0x8000;
  
  tsf = t | (tsf &~ 0x7fff);
  
  d = (tsf_now - tsf);
  //printk("tsf is %d now %d d %d\n", tsf, tsf_now, d);
  period = 1000*1000;
  diff.tv_sec = d/period;
  diff.tv_usec = d % period;
  timersub(&now, &diff, &stamp);
  return stamp;

}

static void
ath_setdefantenna(struct ath_softc *sc, u_int antenna)
{
        struct ath_hal *ah = sc->sc_ah;

        /* XXX block beacon interrupts */
        ath_hal_setdefantenna(ah, antenna);
        sc->sc_defant = antenna;
        sc->sc_rxotherant = 0;
}

static void
ath_rx_tasklet(TQUEUE_ARG data)
{
#define PA2DESC(_sc, _pa) \
        ((struct ath_desc *)((caddr_t)(_sc)->sc_desc + \
                ((_pa) - (_sc)->sc_desc_daddr)))
        struct net_device *dev = (struct net_device *) data;
        struct ath_buf *bf;
        struct ath_softc *sc = dev->priv;
        struct net_device_stats *stats = &sc->ic_stats;
        struct ath_hal *ah = sc->sc_ah;
        struct ath_desc *ds;
        struct sk_buff *skb;
        struct ieee80211_frame *wh;
        int len;
        int prev_more = 0;
        u_int8_t phyerr;
        HAL_STATUS status;
        const HAL_RATE_TABLE *rt;
        u_int16_t dur = 0;

        DPRINTF(sc, ATH_DEBUG_ANY, "%s\n", __func__);
        do {
                bf = STAILQ_FIRST(&sc->sc_rxbuf);
                if (bf == NULL) {               /* XXX ??? can this happen */
                        printk("ath_rx_tasklet: no buffer\n");
                        break;
                }
                ds = bf->bf_desc;
                if (ds->ds_link == bf->bf_daddr) {
                        /* NB: never process the self-linked entry at the end */
                        break;
                }
                skb = bf->bf_skb;
                if (skb == NULL) {              /* XXX ??? can this happen */
                        printk("ath_rx_tasklet: no skbuff\n");
                        continue;
                }
                /* XXX sync descriptor memory */
                /*
                 * Must provide the virtual address of the current
                 * descriptor, the physical address, and the virtual
                 * address of the next descriptor in the h/w chain.
                 * This allows the HAL to look ahead to see if the
                 * hardware is done with a descriptor by checking the
                 * done bit in the following descriptor and the address
                 * of the current descriptor the DMA engine is working
                 * on.  All this is necessary because of our use of
                 * a self-linked list to avoid rx overruns.
                 */
                status = ath_hal_rxprocdesc(ah, ds,
                                bf->bf_daddr, PA2DESC(sc, ds->ds_link));
#ifdef AR_DEBUG
                if (ath_debug > 1)
                        ath_printrxbuf(bf, status == HAL_OK); 
#endif
                if (status == HAL_EINPROGRESS)
                        break;
                STAILQ_REMOVE_HEAD(&sc->sc_rxbuf, bf_list);

                if (ds->ds_rxstat.rs_more) {
                        /*
                         * Frame spans multiple descriptors; this
                         * cannot happen yet as we don't support
                         * jumbograms.  If not in monitor mode,
                         * discard the frame.
                         */

                } else if (ds->ds_rxstat.rs_status != 0) {
                        if (ds->ds_rxstat.rs_status & HAL_RXERR_CRC)
                                sc->sc_stats.ast_rx_crcerr++;
                        if (ds->ds_rxstat.rs_status & HAL_RXERR_FIFO)
                                sc->sc_stats.ast_rx_fifoerr++;
                        if (ds->ds_rxstat.rs_status & HAL_RXERR_DECRYPT)
                                sc->sc_stats.ast_rx_badcrypt++;
                        if (ds->ds_rxstat.rs_status & HAL_RXERR_PHY) {
                                sc->sc_stats.ast_rx_phyerr++;
                                phyerr = ds->ds_rxstat.rs_phyerr & 0x1f;
                                sc->sc_stats.ast_rx_phy[phyerr]++;
                        }

                        /*
                         * reject error frames, we normally don't want
                         * to see them in monitor mode.
                         */
                        if (!ath_phyerr && 
                            ((ds->ds_rxstat.rs_status & HAL_RXERR_DECRYPT ) ||
                             (ds->ds_rxstat.rs_status & HAL_RXERR_PHY))) {
                          goto rx_next;
                        }
                         

                        /*
                         * In monitor mode, allow through packets that
                         * cannot be decrypted
                         */
                        if (!ath_phyerr && 
                            ((ds->ds_rxstat.rs_status & ~HAL_RXERR_DECRYPT) ||
                            sc->ic_opmode != IEEE80211_M_MONITOR)) {
                          goto rx_next;
                        }
                }

                len = ds->ds_rxstat.rs_datalen;
                if (len == 0) {
                  if (0) {
                    printk(KERN_WARNING "%s: ath_rx_tasklet: short packet %d\n",
                           dev->name, len);
                  }
                  sc->sc_stats.ast_rx_tooshort++;
                  goto rx_next;
                }
                
                bus_dma_sync_single(sc->sc_bdev,
                        bf->bf_skbaddr, len, BUS_DMA_FROMDEVICE);

                /*
                 * Normal receive.
                 */
                wh = (struct ieee80211_frame *) skb->data;
                switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) {
                case IEEE80211_FC0_TYPE_CTL:
                        sc->sc_stats.ast_rx_ctl++;
                case IEEE80211_FC0_TYPE_MGT:
                        sc->sc_stats.ast_rx_mgt++;
                }
                bus_unmap_single(sc->sc_bdev, bf->bf_skbaddr,
                                 sc->sc_rxbufsize, BUS_DMA_FROMDEVICE);
                bf->bf_skb = NULL;
                skb_put(skb, len);
                skb->protocol = ETH_P_CONTROL;          /* XXX */
                if (IFF_DUMPPKTS(sc)) {
                        ieee80211_dump_pkt(skb->data, len,
                                   sc->sc_hwmap[ds->ds_rxstat.rs_rate] &
                                        IEEE80211_RATE_VAL,
                                   ds->ds_rxstat.rs_rssi);
                }
                if (!prev_more) {
                  skb_trim(skb, skb->len - IEEE80211_CRC_LEN);
                }

                prev_more = ds->ds_rxstat.rs_more;

                if (0 && sc->sc_softled) {
                  ath_update_led(sc, sc->sc_ledstate ^= 1);
                }

                //skb_push(skb, 14);
                //dev_kfree_skb_any(skb);
                if (skb != NULL) {

                  struct click_wifi_extra *ceh = (struct click_wifi_extra *) (skb->cb + EXTRA_HEADER_CB_OFFSET);
                  memset(ceh, 0, sizeof(struct click_wifi_extra));
                  ceh->magic = WIFI_EXTRA_MAGIC;
                  ceh->flags = 0;
                  /* click */
                  if (ds->ds_rxstat.rs_status) {
                    ceh->flags |= WIFI_EXTRA_RX_ERR;
                  }
                  if (ds->ds_rxstat.rs_more) {
                    ceh->flags |= WIFI_EXTRA_RX_MORE;
                  }
                  ceh->rssi = ds->ds_rxstat.rs_rssi;
                  ceh->silence = 0;
                  ceh->rate = sc->sc_hwmap[ds->ds_rxstat.rs_rate] & IEEE80211_RATE_VAL;

                  skb->protocol = 0;
                  dev->last_rx = jiffies;
                  skb->dev = &sc->dev;

                  rt = sc->sc_currates;
                  if (rt) {
                    int index = sc->sc_rixmap[ceh->rate];
                    if (index >= 0 && index < rt->rateCount) {
                      dur = ath_hal_computetxtime(ah, rt, len, 
                                                  index, AH_TRUE);
                    }
                  }
                  skb->stamp = get_stamp(ah, ds->ds_rxstat.rs_tstamp);


                  
                  if (sc->dev_type == ARPHRD_IEEE80211_PRISM) {
                      /*
                     * Rx descriptor has the low 15 bits of the tsf at
                     * the time the frame was received.  Use the current
                     * tsf to extend this to 32 bits.
                     */
                    
                    u_int32_t tsf = ath_hal_gettsf32(sc->sc_ah);

                    if ((tsf & 0x7fff) < ds->ds_rxstat.rs_tstamp)
                      tsf -= 0x8000;

                    tsf = ds->ds_rxstat.rs_tstamp | (tsf &~ 0x7fff);
                    
                    push_prism2_header(&sc->dev, skb, 
                                       ds->ds_rxstat.rs_datalen,
                                       ds->ds_rxstat.rs_rssi,
                                       sc->sc_hwmap[ds->ds_rxstat.rs_rate] & 
                                       IEEE80211_RATE_VAL,
                                       0,
                                       tsf);
                  } else {
                    push_wifi_extra_header(skb);
                  }
                  
                  if (skb) {
                    netif_rx(skb);
                  }


                }
//rx_done:
                stats->rx_packets++;
                stats->rx_bytes += len;
rx_next:
                STAILQ_INSERT_TAIL(&sc->sc_rxbuf, bf, bf_list);
        } while (ath_rxbuf_init(sc, bf) == 0);

        //ath_hal_rxmonitor(ah);                /* rx signal state monitoring */
#undef PA2DESC
}

/*
 * Setup a hardware data transmit queue for the specified
 * access control.  The hal may not support all requested
 * queues in which case it will return a reference to a
 * previously setup queue.  We record the mapping from ac's
 * to h/w queues for use by ath_tx_start and also track
 * the set of h/w queues being used to optimize work in the
 * transmit interrupt handler and related routines.
 */
static int
ath_tx_setup(struct ath_softc *sc, int ac, int haltype)
{
#define N(a)    (sizeof(a)/sizeof(a[0]))
        struct ath_hal *ah = sc->sc_ah;
        HAL_TXQ_INFO qi;
        int qnum;

        if (ac >= N(sc->sc_ac2q)) {
                printk("%s: AC %u out of range, max %u!\n",
                       sc->dev.name, ac, N(sc->sc_ac2q));
                return 0;
        }
        memset(&qi, 0, sizeof(qi));
        qi.tqi_subtype = haltype;
        /*
         * Enable interrupts only for EOL and DESC conditions.
         * We mark tx descriptors to receive a DESC interrupt
         * when a tx queue gets deep; otherwise waiting for the
         * EOL to reap descriptors.  Note that this is done to
         * reduce interrupt load and this only defers reaping
         * descriptors, never transmitting frames.  Aside from
         * reducing interrupts this also permits more concurrency.
         * The only potential downside is if the tx queue backs
         * up in which case the top half of the kernel may backup
         * due to a lack of tx descriptors.
         */
        qi.tqi_qflags = TXQ_FLAG_TXEOLINT_ENABLE | TXQ_FLAG_TXDESCINT_ENABLE;
        qnum = ath_hal_setuptxqueue(ah, HAL_TX_QUEUE_DATA, &qi);
        if (qnum == -1) {
                printk("%s: Unable to setup hardware queue for %s traffic!\n",
                        sc->dev.name, acnames[ac]);
                return 0;
        }
        if (qnum >= N(sc->sc_txq)) {
                printk("%s: hal qnum %u out of range, max %u!\n",
                        sc->dev.name, qnum, N(sc->sc_txq));
                return 0;
        }
        if (!ATH_TXQ_SETUP(sc, qnum)) {
                struct ath_txq *txq = &sc->sc_txq[qnum];

                txq->axq_qnum = qnum;
                txq->axq_depth = 0;
                txq->axq_intrcnt = 0;
                txq->axq_link = NULL;
                STAILQ_INIT(&txq->axq_q);
                ATH_TXQ_LOCK_INIT(txq);
                sc->sc_txqsetup |= 1<<qnum;
        }
        sc->sc_ac2q[ac] = &sc->sc_txq[qnum];
        return 1;
#undef N
}
/*                                                                                                              
 * Fill the hardware key cache with key entries.                                                                
 */
static void
ath_initkeytable(struct net_device *dev)
{
  struct ath_softc *sc = dev->priv;
  struct ath_hal *ah = sc->sc_ah;
  int i;

  /* XXX maybe should reset all keys when !WEPON */
  for (i = 0; i < IEEE80211_WEP_NKID; i++) {
      ath_hal_keyreset(ah, i);
  }
}

/*
 * XXX Size of an ACK control frame in bytes.
 */
#define IEEE80211_ACK_SIZE      (2+2+IEEE80211_ADDR_LEN+4)

static int
ath_tx_start(struct net_device *dev, struct ath_buf *bf,
    struct sk_buff *skb)
{
#define MIN(a,b)        ((a) < (b) ? (a) : (b))
#define MAX(a,b)        ((a) > (b) ? (a) : (b))
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        struct net_device_stats *stats = &sc->ic_stats;
        int iswep, hdrlen, pktlen, try0,isqos=0;
        u_int8_t rix, txrate, ctsrate;
        struct ath_desc *ds;
        struct ieee80211_frame *wh;
        u_int8_t acc=0;
        u_int flags, ctsduration, antenna;
        HAL_PKT_TYPE atype;
        HAL_BOOL shortPreamble;
        struct ath_txq *txq;
        struct click_wifi_extra *ceh = (struct click_wifi_extra *) (skb->cb + EXTRA_HEADER_CB_OFFSET);
        u_int8_t dot11Rate = ceh->rate;
        const HAL_RATE_TABLE *rt;
        int txrate_index;
        int power;

        
        wh = (struct ieee80211_frame *) skb->data;
        iswep = wh->i_fc[1] & IEEE80211_FC1_WEP;
        hdrlen = sizeof(struct ieee80211_frame);
        if (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_QOS) {
                isqos = 1;
                acc = skb->priority;
                hdrlen += sizeof(struct ieee80211_qoscntl);
        }
        txq = sc->sc_ac2q[acc];



        pktlen = skb->len;

        pktlen += IEEE80211_CRC_LEN;

        /*
         * Load the DMA map so any coalescing is done.  This
         * also calculates the number of descriptors we need.
         */
        bf->bf_skbaddr = bus_map_single(sc->sc_bdev,
                                        skb->data, pktlen, BUS_DMA_TODEVICE);
        DPRINTF(sc, ATH_DEBUG_ANY, "ath_tx_start: skb %p [data %p len %u] skbaddr %x\n",
                skb, skb->data, skb->len, bf->bf_skbaddr);
        bf->bf_skb = skb;
        bf->bf_node = NULL;

        /* setup descriptors */
        ds = bf->bf_desc;

        /*
         * NB: the 802.11 layer marks whether or not we should
         * use short preamble based on the current mode and
         * negotiated parameters.
         */
        shortPreamble = AH_TRUE;

        /*
         * Calculate Atheros packet type from IEEE80211 packet header
         * and setup for rate calculations.
         */
        atype = HAL_PKT_TYPE_NORMAL;                    /* default */
        if (ceh->magic == WIFI_EXTRA_MAGIC && 
            (ceh->flags & WIFI_EXTRA_NO_SEQ)) {
          atype = HAL_PKT_TYPE_PSPOLL;
        }
        rix = 0;
        try0 = ATH_TXMAXTRY;


        if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_MGT) {
          u_int subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
          switch (subtype) {
          case IEEE80211_FC0_SUBTYPE_BEACON:
            atype = HAL_PKT_TYPE_BEACON;
            break;
          case IEEE80211_FC0_SUBTYPE_PROBE_RESP: {
            /* fill time stamp */
            u_int64_t tsf;
            u_int32_t *tstamp;

            atype = HAL_PKT_TYPE_PROBE_RESP;
            tsf = ath_hal_gettsf64(ah);
            /* XXX: adjust 100us delay to xmit */
            tsf += 100;
            tstamp = (u_int32_t *)&wh[1];
            tstamp[0] = cpu_to_le32(tsf & 0xffffffff);
            tstamp[1] = cpu_to_le32(tsf >> 32);
            break;
          }
          case IEEE80211_FC0_SUBTYPE_ATIM:
            atype = HAL_PKT_TYPE_ATIM;
            break;
          }
        }

        /*
         * Calculate miscellaneous flags.
         */
        flags = HAL_TXDESC_CLRDMASK;            /* XXX needed for wep errors */
        if (IEEE80211_IS_MULTICAST(wh->i_addr1)) {
          DPRINTF(sc, ATH_DEBUG_ANY, "%s: %s: noack\n", dev->name,__func__);
          flags |= HAL_TXDESC_NOACK;    /* no ack on broad/multicast */
          sc->sc_stats.ast_tx_noack++;
        } else if (ceh->magic == WIFI_EXTRA_MAGIC &&
                   (ceh->flags & WIFI_EXTRA_DO_RTS_CTS)) {
          flags |= HAL_TXDESC_RTSENA;
          sc->sc_stats.ast_tx_rts++;
        } 
        if (ceh->magic == WIFI_EXTRA_MAGIC &&
            ceh->flags & WIFI_EXTRA_DO_CTS) {
          flags |= HAL_TXDESC_CTSENA;
        }


        rt = sc->sc_currates;
        KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode));

        txrate = 0;
        txrate_index = 0;
        dot11Rate = ceh->rate;
        if (ceh->magic == WIFI_EXTRA_MAGIC && dot11Rate) {
          int index = sc->sc_rixmap[dot11Rate & IEEE80211_RATE_VAL];
          if (index >= 0 && index < rt->rateCount) {
            txrate = rt->info[index].rateCode;
            txrate_index = index;
          }
        }

        if (txrate == 0) {
          int index;
          dot11Rate = sc->ic_fixed_rate;
          index = sc->sc_rixmap[dot11Rate & IEEE80211_RATE_VAL];
          if (index >= 0 && index < rt->rateCount) {
            txrate = rt->info[index].rateCode;
            txrate_index = index;
          } else {
            printk(KERN_WARNING "%s: %s: fixed rate is %d, index invalid %d rateCount %d\n",
                   dev->name,
                   __func__,
                   dot11Rate,
                   index,
                   rt->info[index].rateCode);
          }
        }
        
        if (txrate == 0) {
          printk(KERN_WARNING "%s: %s: can't find txrate! fixed rate is %d\n",
                 dev->name,
                 __func__,
                 sc->ic_fixed_rate);
          
          // our final attempt at finding a rate.
          txrate = rt->info[0].rateCode;
          txrate_index = 0;
        }


        /*
         * Calculate duration.  This logically belongs in the 802.11
         * layer but it lacks sufficient information to calculate it.
         */

        if ((flags & HAL_TXDESC_NOACK) == 0 &&
            (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_CTL) {
          u_int16_t dur;
          // XXX not right with fragmentation.
          dur = ath_hal_computetxtime(ah, rt, IEEE80211_ACK_SIZE,
                                      txrate_index, shortPreamble);
          *(u_int16_t *)wh->i_dur = cpu_to_le16(dur);
        }
        
        /*
         * Calculate RTS/CTS rate and duration if needed.
         */
        ctsduration = 0;
        ctsrate = 0;

        if (flags & (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA)) {
                /*
                 * CTS transmit rate is derived from the transmit rate
                 * by looking in the h/w rate table.  We must also factor
                 * in whether or not a short preamble is to be used.
                 */
          u_int8_t cix = rt->info[txrate_index].controlRate;
                ctsrate = rt->info[cix].rateCode;
                if (shortPreamble)
                        ctsrate |= rt->info[cix].shortPreamble;
                /*
                 * Compute the transmit duration based on the size
                 * of an ACK frame.  We call into the HAL to do the
                 * computation since it depends on the characteristics
                 * of the actual PHY being used.
                 */
                if (flags & HAL_TXDESC_RTSENA) {        /* SIFS + CTS */
                        ctsduration += ath_hal_computetxtime(ah,
                                rt, IEEE80211_ACK_SIZE, cix, shortPreamble);
                }
                /* SIFS + data */
                ctsduration += ath_hal_computetxtime(ah,
                        rt, pktlen, rix, shortPreamble);
                if ((flags & HAL_TXDESC_NOACK) == 0) {  /* SIFS + ACK */
                        ctsduration += ath_hal_computetxtime(ah,
                                rt, IEEE80211_ACK_SIZE, cix, shortPreamble);
                }
        }








        antenna = 0;

        if (IFF_DUMPPKTS(sc)) {
          ieee80211_dump_pkt(skb->data, skb->len,
                             0 & IEEE80211_RATE_VAL, -1);
        }


        if (1) {
          flags |= HAL_TXDESC_INTREQ;
          txq->axq_intrcnt = 0;
        }
        /* make sure values from click fall within range */
        try0 = (ceh->magic == WIFI_EXTRA_MAGIC && ceh->max_retries) ? ceh->max_retries : ATH_TXMAXTRY;
        try0 = max(0, try0);
        try0 = min(ATH_TXMAXTRY, try0);
        
        
        power = (ceh->magic == WIFI_EXTRA_MAGIC && ceh->power) ?
        ceh->power : ATH_TPC_MAX;
        power = max(0, power);
        power = min(ATH_TPC_MAX, power);

        /*
         * Formulate first tx descriptor with tx controls.
         */
        if (!ath_hal_setuptxdesc(ah, ds
                                 , pktlen               /* packet length */
                                 , hdrlen               /* header length */
                                 , atype                /* Atheros packet type */
                                 , MIN(60,power)        /* txpower */
                                 , txrate, try0         /* series 0 rate/tries */
                                 , HAL_TXKEYIX_INVALID
                                 , sc->sc_txantenna     /* antenna mode */
                                 , flags                /* flags */
                                 , ctsrate              /* rts/cts rate */
                                 , ctsduration          /* rts/cts duration */
                                 )) {
          printk("%s: %s ath_hal_setuptxdesc failed\n", dev->name, __func__);
          printk("%s: ah %d ds %d pktlen %d hrdlen %d atype %d twpower %d txrate %d tries %d wep %d antenna %d flags %d ctsrate %d ctsduration %d\n" 
                   , dev->name
                   , (int)ah
                   , (int)ds
                   , pktlen
                   , hdrlen
                   , atype
                   , ATH_TPC_MAX /* txpower */
                   , txrate, try0               /* series 0 rate/tries */
                   , HAL_TXKEYIX_INVALID
                   , antenna            /* antenna mode */
                   , flags                      /* flags */
                   , ctsrate            /* rts/cts rate */
                   , ctsduration                /* rts/cts duration */
                   );

          return -1;
        }


        ds->ds_link = 0;
        ds->ds_data = bf->bf_skbaddr;


        /*
         * Setup the multi-rate retry state only when we're
         * going to use it.  This assumes ath_hal_setuptxdesc
         * initializes the descriptors (so we don't have to)
         * when the hardware supports multi-rate retry and
         * we don't use it.
         */
        if (!(flags & HAL_TXDESC_NOACK) && 
            ceh->magic == WIFI_EXTRA_MAGIC && 
            ceh->rate1) {
          /* make sure values from click fall within range */
          int index1 = sc->sc_rixmap[ceh->rate1 & IEEE80211_RATE_VAL];
          int index2 = sc->sc_rixmap[ceh->rate2 & IEEE80211_RATE_VAL];
          int index3 = sc->sc_rixmap[ceh->rate3 & IEEE80211_RATE_VAL];

          u_int8_t txrate1;
          u_int8_t txrate2;
          u_int8_t txrate3;
          
          index1 = MAX(0, MIN(index1, rt->rateCount));
          index2 = MAX(0, MIN(index2, rt->rateCount));
          index3 = MAX(0, MIN(index3, rt->rateCount));

          txrate1 = rt->info[index1].rateCode;
          txrate2 = rt->info[index2].rateCode;
          txrate3 = rt->info[index3].rateCode;
          
            if (AH_TRUE != ath_hal_setupxtxdesc(ah, ds
                                                , txrate1, ceh->max_retries1    /* series 1 */
                                                , txrate2, ceh->max_retries2    /* series 2 */
                                                , txrate3, ceh->max_retries3    /* series 3 */
                                                )) {
              printk(KERN_WARNING "%s: %s: couldn't setupxtxdesc\n",
                     dev->name,
                     __func__);
            }

        }

        if (AH_TRUE != ath_hal_filltxdesc(ah, ds
                                          , roundup(skb->len,4) /* segment length */
                                          , AH_TRUE             /* first segment */
                                          , AH_TRUE             /* last segment */
                                          , ds
                                          )) {
          DPRINTF(sc, ATH_DEBUG_ANY, "%s: %s ath_hal_filltxdesc failed\n", dev->name, __func__);
        }
        DPRINTF(sc, ATH_DEBUG_ANY, "ath_tx_start: %d: %08x %08x %08x %08x %08x %08x\n",
            0, ds->ds_link, ds->ds_data, ds->ds_ctl0, ds->ds_ctl1,
            ds->ds_hw[0], ds->ds_hw[1]);

        /*
         * Insert the frame on the outbound list and
         * pass it on to the hardware.
         */
        ATH_TXQ_LOCK_BH(txq);
        ATH_TXQ_INSERT_TAIL(txq, bf, bf_list);
        DPRINTF(sc, ATH_DEBUG_ANY, "%s: txq depth = %d\n",
                __func__, txq->axq_depth);
        if (txq->axq_link == NULL) {
          if (AH_TRUE != ath_hal_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr)) {
            printk("%s: %s ath_hal_puttxbuf failed\n",
                   dev->name,
                   __func__);
          }
        } else {
                *txq->axq_link = bf->bf_daddr;
                DPRINTF(sc, ATH_DEBUG_ANY, "%s: link[%u](%p)=%p (%p)\n",
                        __func__,
                    txq->axq_qnum, txq->axq_link,
                    (caddr_t)bf->bf_daddr, bf->bf_desc);
        }
        txq->axq_link = &ds->ds_link;
        ATH_TXQ_UNLOCK_BH(txq);

        if (0 && sc->sc_softled)
                ath_update_led(sc, sc->sc_ledstate ^= 1);


        if (AH_TRUE != ath_hal_txstart(ah, txq->axq_qnum)) {
          printk("%s: %s ath_hal_txstart failed\n", dev->name, __func__);
        }
        
        stats->tx_packets++;
        stats->tx_bytes += pktlen;

        sc->subsequent_kicks = 0;
        dev->trans_start = jiffies;
        return 0;
#undef MIN
}

/*
 * Process completed xmit descriptors from the specified queue.
 */
static void
ath_tx_processq(struct ath_softc *sc, struct ath_txq *txq)
{
  struct ath_hal *ah = sc->sc_ah;
  struct ath_buf *bf;
  struct ath_desc *ds;
  HAL_STATUS status;
  struct click_wifi_extra *ceh;
  struct ieee80211_frame *wh;

  
  DPRINTF(sc, ATH_DEBUG_ANY, "%s: tx queue %p, link %p\n", __func__,
          (caddr_t) ath_hal_gettxbuf(sc->sc_ah, txq->axq_qnum),
          txq->axq_link);
  for (;;) {
    ATH_TXQ_LOCK(txq);
    txq->axq_intrcnt = 0;
    bf = STAILQ_FIRST(&txq->axq_q);
    if (bf == NULL) {
      txq->axq_link = NULL;
      ATH_TXQ_UNLOCK(txq);
      break;
    }
    ds = bf->bf_desc;       /* NB: last decriptor */
    status = ath_hal_txprocdesc(ah, ds);

    if (ath_debug > 1)
      ath_printtxbuf(bf, status == HAL_OK);

    
    if (status == HAL_EINPROGRESS) {
      ATH_TXQ_UNLOCK(txq);
      break;
    }

    ATH_TXQ_REMOVE_HEAD(txq, bf_list);
    ATH_TXQ_UNLOCK(txq);
                                
    bus_unmap_single(sc->sc_bdev,
                     bf->bf_skbaddr, bf->bf_skb->len, BUS_DMA_TODEVICE);

    ceh = (struct click_wifi_extra *) (bf->bf_skb->cb + EXTRA_HEADER_CB_OFFSET);
    
    if (1) {
      ceh->len = bf->bf_skb->len;
      if (bf->bf_skb->len > sizeof(struct ieee80211_frame)) {
        //skb_trim(bf->bf_skb, sizeof(struct ieee80211_frame) + sizeof(struct llc));
      }
      
      if (ceh->magic != WIFI_EXTRA_MAGIC) {
        ceh->flags = 0;
      }
      ceh->magic = WIFI_EXTRA_MAGIC;
      ceh->flags |= WIFI_EXTRA_TX;
      if (ds->ds_txstat.ts_status) {
        ceh->flags |= WIFI_EXTRA_TX_FAIL;
      }
      if (ds->ds_txstat.ts_rate & HAL_TXSTAT_ALTRATE) {
        ceh->flags |= WIFI_EXTRA_TX_USED_ALT_RATE;
      }
      if (!ceh->rate) {
        ceh->rate = sc->sc_hwmap[ds->ds_txstat.ts_rate] & IEEE80211_RATE_VAL;
      }
      //bf->bf_skb->stamp = get_stamp(ah, ds->ds_txstat.ts_tstamp);
      
      /* rate was already set when we trasmitted */
      ceh->retries = ds->ds_txstat.ts_longretry;
      ceh->rssi = ds->ds_txstat.ts_rssi;
      ceh->virt_col = ds->ds_txstat.ts_virtcol;
      // try extracting bits [12:4] from ds_hw[3]
      ceh->virt_col = ((ds->ds_hw[3] >> 16) & 0xf);
    }
    
    wh = (struct ieee80211_frame *) bf->bf_skb->data;
    if (0) {
      u_int16_t old_seq = le16_to_cpu(*(u_int16_t *)wh->i_seq) >> IEEE80211_SEQ_SEQ_SHIFT;
      printk ("old seq %d new seq %d\n",
              old_seq, 
              ds->ds_txstat.ts_seqnum);
    }
    
    
    if (!(ceh->flags & WIFI_EXTRA_NO_SEQ) &&
        bf->bf_skb->len >= sizeof(struct ieee80211_frame)) {
      /* grab the sequence number the card assigned */
      *(u_int16_t *) wh->i_seq = cpu_to_le16(ds->ds_txstat.ts_seqnum << IEEE80211_SEQ_SEQ_SHIFT);
    }
    
    if (sc->dev_type == ARPHRD_IEEE80211_PRISM) {
      push_prism2_header(&sc->dev, bf->bf_skb, 
                         ds->ds_rxstat.rs_datalen,
                         ds->ds_rxstat.rs_rssi,
                         sc->sc_hwmap[ds->ds_txstat.ts_rate] & 
                         IEEE80211_RATE_VAL,
                         1,
                         0);
    }
    if (ceh->magic == WIFI_EXTRA_MAGIC && !(ceh->flags & WIFI_EXTRA_NO_TXF)) {
      /* need to copy before we spit it back to the device, for
       * some weird reason. Otherwise the sockets don't get 
       * empty their buffers.
       */       
      
      if (atomic_read(&bf->bf_skb->users) != 1) {
        struct sk_buff *skb2=bf->bf_skb;
        bf->bf_skb=skb_clone(bf->bf_skb, GFP_ATOMIC);
        if (bf->bf_skb == NULL) {
          dev_kfree_skb(skb2);
          bf->bf_skb = NULL;
        }
        kfree_skb(skb2);
      } else {
        skb_orphan(bf->bf_skb);
      }
      if (bf->bf_skb) {
        bf->bf_skb->dev = &sc->dev;
        bf->bf_skb = push_wifi_extra_header(bf->bf_skb);
        if (bf->bf_skb) {
          netif_rx(bf->bf_skb);
        }
      }
    } else {
      dev_kfree_skb(bf->bf_skb);
    }
    
    
    bf->bf_skb = NULL;
    bf->bf_node = NULL;
    
    ATH_TXBUF_LOCK(sc);
    STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list);
    ATH_TXBUF_UNLOCK(sc);
  }
}


static void
ath_tx_tasklet(TQUEUE_ARG data)
{
        struct net_device *dev = (struct net_device *) data;
        struct ath_softc *sc = dev->priv;
        //struct ieee80211com *ic = &sc->sc_ic;
        int i;

        DPRINTF(sc, ATH_DEBUG_ANY, "%s: %s\n", dev->name, __func__);
        for (i = 0; i < HAL_NUM_TX_QUEUES; i++) {
          if (ATH_TXQ_SETUP(sc, i))
            ath_tx_processq(sc, &sc->sc_txq[i]);
        }
        /*
         * Don't wakeup unless we're associated; this insures we don't
         * signal the upper layer it's ok to start sending data frames.
         */
        /* XXX use a low watermark to reduce wakeups */
        //if (ic->ic_state == IEEE80211_S_RUN)
        if (!STAILQ_EMPTY(&sc->sc_txbuf) && netif_queue_stopped(dev)) {
          netif_wake_queue(dev);
        }
}

static void
ath_tx_timeout(struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        sc->sc_stats.ast_watchdog++;
        printk("%s: %s timeout at %ld, latency %ld pending %d\n",
               dev->name,
               __func__,
               jiffies,
               jiffies - dev->trans_start,
               ath_hal_intrpend(sc->sc_ah));

        sc->subsequent_kicks++;
        if (sc->subsequent_kicks == 1) {
          /* maybe we missed an interrupt? */
          ath_intr(dev->irq, dev, 0);
        } else {
          /* don't make me reset you! */
          ath_init(dev);
          //ath_hal_dumpstate(sc->sc_ah);
        }
}

static void
ath_tx_draintxq(struct ath_softc *sc, struct ath_txq *txq)
{
        struct ath_hal *ah = sc->sc_ah;
        struct ath_buf *bf;

        /*
         * NB: this assumes output has been stopped and
         *     we do not need to block ath_tx_tasklet
         */
        for (;;) {
                ATH_TXQ_LOCK(txq);
                bf = STAILQ_FIRST(&txq->axq_q);
                if (bf == NULL) {
                        txq->axq_link = NULL;
                        ATH_TXQ_UNLOCK(txq);
                        break;
                }
                ATH_TXQ_REMOVE_HEAD(txq, bf_list);
                ATH_TXQ_UNLOCK(txq);
#ifdef AR_DEBUG
                if (sc->sc_debug & ATH_DEBUG_ANY)
                        ath_printtxbuf(bf,
                                ath_hal_txprocdesc(ah, bf->bf_desc) == HAL_OK);
#endif /* AR_DEBUG */
                bus_unmap_single(sc->sc_bdev,
                        bf->bf_skbaddr, bf->bf_skb->len, BUS_DMA_TODEVICE);
                dev_kfree_skb(bf->bf_skb);
                bf->bf_skb = NULL;
                bf->bf_node = NULL;
                ATH_TXBUF_LOCK(sc);
                STAILQ_INSERT_TAIL(&sc->sc_txbuf, bf, bf_list);
                ATH_TXBUF_UNLOCK(sc);
        }
}
static void
ath_tx_stopdma(struct ath_softc *sc, struct ath_txq *txq)
{
        struct ath_hal *ah = sc->sc_ah;

        (void) ath_hal_stoptxdma(ah, txq->axq_qnum);
        DPRINTF(sc, ATH_DEBUG_ANY, "%s: tx queue [%u] %p, link %p\n",
            __func__, txq->axq_qnum,
            (caddr_t) ath_hal_gettxbuf(ah, txq->axq_qnum), txq->axq_link);
}
/*
 * Drain the transmit queues and reclaim resources.
 */
static void
ath_draintxq(struct ath_softc *sc)
{
        int i;

        /* XXX return value */
        if (!sc->sc_invalid) {
          for (i = 0; i < HAL_NUM_TX_QUEUES; i++)
            if (ATH_TXQ_SETUP(sc, i))
              ath_tx_stopdma(sc, &sc->sc_txq[i]);
        }
        sc->dev.trans_start = jiffies;
        netif_start_queue(&sc->dev);
        for (i = 0; i < HAL_NUM_TX_QUEUES; i++)
                if (ATH_TXQ_SETUP(sc, i))
                        ath_tx_draintxq(sc, &sc->sc_txq[i]);
}

/*
 * Disable the receive h/w in preparation for a reset.
 */
static void
ath_stoprecv(struct ath_softc *sc)
{
#define PA2DESC(_sc, _pa) \
        ((struct ath_desc *)((caddr_t)(_sc)->sc_desc + \
                ((_pa) - (_sc)->sc_desc_daddr)))
        struct ath_hal *ah = sc->sc_ah;

        ath_hal_stoppcurecv(ah);        /* disable PCU */
        ath_hal_setrxfilter(ah, 0);     /* clear recv filter */
        ath_hal_stopdmarecv(ah);        /* disable DMA engine */
        mdelay(3);                      /* 3ms is long enough for 1 frame */
#ifdef AR_DEBUG
        if (ath_debug) {
                struct ath_buf *bf;

                printk("ath_stoprecv: rx queue %p, link %p\n",
                    (caddr_t) ath_hal_getrxbuf(ah), sc->sc_rxlink);
                STAILQ_FOREACH(bf, &sc->sc_rxbuf, bf_list) {
                        struct ath_desc *ds = bf->bf_desc;
                        HAL_STATUS status = ath_hal_rxprocdesc(ah, ds,
                                bf->bf_daddr, PA2DESC(sc, ds->ds_link));
                        if (status == HAL_OK || (sc->sc_debug & ATH_DEBUG_ANY))
                                ath_printrxbuf(bf, status == HAL_OK);
                }
        }
#endif
        sc->sc_rxlink = NULL;           /* just in case */
#undef PA2DESC
}

/*
 * Enable the receive h/w following a reset.
 */
static int
ath_startrecv(struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        struct ath_buf *bf;

        //sc->sc_rxbufsize = roundup(IEEE80211_MAX_LEN, sc->sc_cachelsz);
        sc->sc_rxbufsize = roundup(3196, sc->sc_cachelsz);
        //sc->sc_rxbufsize = roundup(4100, sc->sc_cachelsz);
        DPRINTF(sc, ATH_DEBUG_ANY, "ath_startrecv: mtu %u cachelsz %u rxbufsize %u\n",
                dev->mtu, sc->sc_cachelsz, sc->sc_rxbufsize);

        sc->sc_rxlink = NULL;

        STAILQ_FOREACH(bf, &sc->sc_rxbuf, bf_list) {
                int error = ath_rxbuf_init(sc, bf);
                if (error != 0)
                        return error;
        }

        bf = STAILQ_FIRST(&sc->sc_rxbuf);
        ath_hal_putrxbuf(ah, bf->bf_daddr);
        ath_hal_rxena(ah);              /* enable recv descriptors */
        ath_mode_init(&sc->dev);        /* set filters, etc. */
        ath_hal_startpcurecv(ah);       /* re-enable PCU/DMA engine */
        return 0;
}

/*
 * Periodically recalibrate the PHY to account
 * for temperature/environment changes.
 */
static void
ath_calibrate(unsigned long arg)
{
        struct net_device *dev = (struct net_device *) arg;
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        struct ieee80211channel *c;
        HAL_CHANNEL hchan;

        sc->sc_stats.ast_per_cal++;

        /*
         * Convert to a HAL channel description with the flags
         * constrained to reflect the current operating mode.
         */
        c = sc->current_channel;
        hchan.channel = c->ic_freq;
        hchan.channelFlags = ath_chan2flags(sc, c);

        //DPRINTF(sc"%s: channel %u/%x\n", __func__, c->ic_freq, c->ic_flags);

        if (ath_hal_getrfgain(ah) == HAL_RFGAIN_NEED_CHANGE) {
                /*
                 * Rfgain is out of bounds, reset the chip
                 * to load new gain values.
                 */
                sc->sc_stats.ast_per_rfgain++;
                ath_reset(dev);
        }
        if (!ath_hal_calibrate(ah, &hchan)) {
                DPRINTF(sc, ATH_DEBUG_ANY, "%s: %s: calibration of channel %u failed\n",
                        dev->name, __func__, c->ic_freq);
                sc->sc_stats.ast_per_calfail++;
        }
        sc->sc_cal_ch.expires = jiffies + (ath_calinterval * HZ);
        add_timer(&sc->sc_cal_ch);
}


static int
ath_getchannels(struct net_device *dev, u_int cc,
        HAL_BOOL outdoor, HAL_BOOL xchanmode)
{
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        HAL_CHANNEL *chans;
        int i, ix, nchan;

        chans = kmalloc(IEEE80211_CHAN_MAX * sizeof(HAL_CHANNEL), GFP_KERNEL);
        if (chans == NULL) {
                printk("%s: unable to allocate channel table\n", dev->name);
                return ENOMEM;
        }
        if (!ath_hal_init_channels(ah, chans, IEEE80211_CHAN_MAX, &nchan,
            cc, HAL_MODE_ALL, outdoor, xchanmode)) {
                u_int32_t rd;

                ath_hal_getregdomain(ah, &rd);
                printk("%s: unable to collect channel list from hal; "
                        "regdomain likely %u country code %u\n",
                        dev->name, rd, cc);
                kfree(chans);
                return 0;
                //return EINVAL;
        }


        /*
         * Convert HAL channels to ieee80211 ones and insert
         * them in the table according to their channel number.
         */
        for (i = 0; i < nchan; i++) {
                HAL_CHANNEL *c = &chans[i];
                ix = ath_hal_mhz2ieee(c->channel, c->channelFlags);
                if (ix > IEEE80211_CHAN_MAX) {
                        continue;
                }
                /* NB: flags are known to be compatible */
                if (sc->ic_channels[ix].ic_freq == 0) {
                        sc->ic_channels[ix].ic_freq = c->channel;
                        sc->ic_channels[ix].ic_flags = c->channelFlags;
                } else {
                        /* channels overlap; e.g. 11g and 11b */
                        sc->ic_channels[ix].ic_flags |= c->channelFlags;
                }
        }

        kfree(chans);
        return 0;
}

static int
ath_setchannel(struct ath_softc *sc,   struct ieee80211channel *channel)
{


#define N(a)    (sizeof(a) / sizeof(a[0]))
        static const u_int chanflags[] = {
                0,                      /* IEEE80211_MODE_AUTO */
                IEEE80211_CHAN_A,       /* IEEE80211_MODE_11A */
                IEEE80211_CHAN_B,       /* IEEE80211_MODE_11B */
                IEEE80211_CHAN_PUREG,   /* IEEE80211_MODE_11G */
                IEEE80211_CHAN_T,       /* IEEE80211_MODE_TURBO */
        };
        struct ieee80211channel *c;
        u_int modeflags;
        int i;
        const HAL_RATE_TABLE *rt;
        

        /*
         * set the mode according to the channel 
         */
        enum ieee80211_phymode mode = chan2mode(sc, channel);

        /*
         * Verify at least one channel is present in the available
         * channel list before committing to the new mode.
         */
        KASSERT(mode < N(chanflags), ("Unexpected mode %u\n", mode));
        modeflags = chanflags[mode];
        for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
                c = &sc->ic_channels[i];
                if (mode == IEEE80211_MODE_AUTO) {
                        /* ignore turbo channels for autoselect */
                        if ((c->ic_flags &~ IEEE80211_CHAN_TURBO) != 0)
                                break;
                } else {
                        if ((c->ic_flags & modeflags) == modeflags)
                                break;
                }
        }
        if (i > IEEE80211_CHAN_MAX) {
          printk("%s: no channels found for mode %u\n",
                 __func__, mode);
          return -EINVAL;
        }

        /*
         * If no current/default channel is setup or the current
         * channel is wrong for the mode then pick the first
         * available channel from the active list.  This is likely
         * not the right one.
         */
        if (channel == NULL ||
            isclr(sc->ic_chan_avail, chan2ieee(sc, channel))) {
          printk("%s: %s: invalid channel %d\n", 
                 __func__,
                 sc->dev.name,
                 channel ? chan2ieee(sc, channel) : 0);
          channel = NULL;
          for (i = 0; i <= IEEE80211_CHAN_MAX; i++)
            if ((c->ic_flags & modeflags) == modeflags) {
              channel = &sc->ic_channels[i];
              break;
            }
        }
        
        if (!channel) {
          printk("%s: %s couldn't find valid channel\n",
                 __func__,
                 sc->dev.name);
          return -EINVAL;
        }

        rt = sc->sc_rates[mode];        
        if (!rt) {
          printk("%s: %s: no h/w rate set for phy mode %u", 
                 __func__,
                 sc->dev.name, 
                 mode);
          return -EINVAL;
        }
        sc->current_channel = channel;
        sc->ic_curmode = mode;

        memset(sc->sc_rixmap, 0xff, sizeof(sc->sc_rixmap));



        /* set the current bitrate as invalid */
        sc->ic_fixed_rate = 0;

        for (i = 0; i < rt->rateCount; i++) {
          sc->sc_rixmap[rt->info[i].dot11Rate & IEEE80211_RATE_VAL] = i;
          if (!sc->ic_fixed_rate && rt->info[i].valid) {
            /* set the bitrate to the first one available */
            sc->ic_fixed_rate = rt->info[i].dot11Rate & IEEE80211_RATE_VAL;
          }
        }

        memset(sc->sc_hwmap, 0, sizeof(sc->sc_hwmap));
        for (i = 0; i < 32; i++) {
                u_int8_t ix = rt->rateCodeToIndex[i];
                if (ix != 0xff)
                        sc->sc_hwmap[i] = rt->info[ix].dot11Rate;

        }
        sc->sc_currates = rt;
        return 0;
}


static int
ath_rate_setup(struct net_device *dev, u_int mode)
{
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        const HAL_RATE_TABLE *rt;
        int maxrates;
        int x = 0;
        switch (mode) {
        case IEEE80211_MODE_11A:
                sc->sc_rates[mode] = ath_hal_getratetable(ah, HAL_MODE_11A);
                break;
        case IEEE80211_MODE_11B:
                sc->sc_rates[mode] = ath_hal_getratetable(ah, HAL_MODE_11B);
                break;
        case IEEE80211_MODE_11G:
                sc->sc_rates[mode] = ath_hal_getratetable(ah, HAL_MODE_11G);
                break;
        case IEEE80211_MODE_TURBO:
                sc->sc_rates[mode] = ath_hal_getratetable(ah, HAL_MODE_TURBO);
                break;
        default:
                DPRINTF(sc, ATH_DEBUG_ANY, "%s: invalid mode %u\n", __func__, mode);
                return 0;
        }
        rt = sc->sc_rates[mode];
        if (rt == NULL)
                return 0;
        if (rt->rateCount > IEEE80211_RATE_MAXSIZE) {
                DPRINTF(sc, ATH_DEBUG_ANY, "%s: rate table too small (%u > %u)\n",
                        __func__, rt->rateCount, IEEE80211_RATE_MAXSIZE);
                maxrates = IEEE80211_RATE_MAXSIZE;
        } else
                maxrates = rt->rateCount;

        printk("%s: mode %d rates (in Mbps):",
               dev->name,
               mode);
        for ( x = 0; x < rt->rateCount; x++) {
          if (rt->info[x].valid) {
            if (rt->info[x].rateKbps % 1000) {
              printk(" %d.%1d", 
                     rt->info[x].rateKbps / 1000,
                     (rt->info[x].rateKbps % 1000) / 100);
            } else {
              printk(" %d", rt->info[x].rateKbps / 1000);
            }
          }
        }
        printk("\n");
        return 1;
}

#ifdef AR_DEBUG
static void
ath_printrxbuf(struct ath_buf *bf, int done)
{
        struct ath_desc *ds = bf->bf_desc;

        printk("R (%p %p) %08x %08x %08x %08x %08x %08x %c\n",
            ds, (struct ath_desc *)bf->bf_daddr,
            ds->ds_link, ds->ds_data,
            ds->ds_ctl0, ds->ds_ctl1,
            ds->ds_hw[0], ds->ds_hw[1],
            !done ? ' ' : (ds->ds_rxstat.rs_status == 0) ? '*' : '!');
}

static void
ath_printtxbuf(struct ath_buf *bf, int done)
{
        struct ath_desc *ds = bf->bf_desc;

        printk("T (%p %p) %08x %08x %08x %08x %08x %08x %08x %08x %c\n",
            ds, (struct ath_desc *)bf->bf_daddr,
            ds->ds_link, ds->ds_data,
            ds->ds_ctl0, ds->ds_ctl1,
            ds->ds_hw[0], ds->ds_hw[1], ds->ds_hw[2], ds->ds_hw[3],
            !done ? ' ' : (ds->ds_txstat.ts_status == 0) ? '*' : '!');
}
#endif /* AR_DEBUG */

/*
 * Return netdevice statistics.
 */
static struct net_device_stats *
ath_getstats(struct net_device *dev)
{
        struct ath_softc *sc = dev->priv;
        struct net_device_stats *stats = &sc->ic_stats;

        /* update according to private statistics */
        stats->tx_errors = sc->sc_stats.ast_tx_encap
                         + sc->sc_stats.ast_tx_nonode
                         + sc->sc_stats.ast_tx_xretries
                         + sc->sc_stats.ast_tx_fifoerr
                         + sc->sc_stats.ast_tx_filtered
                         ;
        stats->tx_dropped = sc->sc_stats.ast_tx_nobuf
                        + sc->sc_stats.ast_tx_nobufmgt;
        stats->rx_errors = sc->sc_stats.ast_rx_tooshort
                        + sc->sc_stats.ast_rx_crcerr
                        + sc->sc_stats.ast_rx_fifoerr
                        + sc->sc_stats.ast_rx_badcrypt
                        ;
        stats->rx_crc_errors = sc->sc_stats.ast_rx_crcerr;

        return stats;
}

static int
ath_set_mac_address(struct net_device *dev, void *addr)
{
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        struct sockaddr *mac = addr;

        if (netif_running(dev)) {
                DPRINTF(sc, ATH_DEBUG_ANY, "%s: cannot set address; device running\n", __func__);
                return -EBUSY;
        }
        DPRINTF(sc, ATH_DEBUG_ANY, "%s: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n", __func__,
                mac->sa_data[0], mac->sa_data[1], mac->sa_data[2],
                mac->sa_data[3], mac->sa_data[4], mac->sa_data[5]);
        IEEE80211_ADDR_COPY(dev->dev_addr, mac->sa_data);
        ath_hal_setmac(ah, dev->dev_addr);
        return -ath_reset(dev);
}

static int      
ath_change_mtu(struct net_device *dev, int mtu) 
{
        if (!(ATH_MIN_MTU < mtu && mtu <= ATH_MAX_MTU)) {
                return -EINVAL;
        }
        dev->mtu = mtu;
        return -ath_reset(dev);
}

/*
 * Diagnostic interface to the HAL.  This is used by various
 * tools to do things like retrieve register contents for
 * debugging.  The mechanism is intentionally opaque so that
 * it can change frequently w/o concern for compatiblity.
 */
static int
ath_ioctl_diag(struct ath_softc *sc, struct ath_diag *ad)
{
        struct ath_hal *ah = sc->sc_ah;
        u_int id = ad->ad_id & ATH_DIAG_ID;
        void *indata = NULL;
        void *outdata = NULL;
        u_int32_t insize = ad->ad_in_size;
        u_int32_t outsize = ad->ad_out_size;
        int error = 0;

        if (ad->ad_id & ATH_DIAG_IN) {
                /*
                 * Copy in data.
                 */
                indata = kmalloc(insize, GFP_KERNEL);
                if (indata == NULL) {
                        error = -ENOMEM;
                        goto bad;
                }
                if (copy_from_user(indata, ad->ad_in_data, insize)) {
                        error = -EFAULT;
                        goto bad;
                }
        }
        if (ad->ad_id & ATH_DIAG_DYN) {
                /*
                 * Allocate a buffer for the results (otherwise the HAL
                 * returns a pointer to a buffer where we can read the
                 * results).  Note that we depend on the HAL leaving this
                 * pointer for us to use below in reclaiming the buffer;
                 * may want to be more defensive.
                 */
                outdata = kmalloc(outsize, GFP_KERNEL);
                if (outdata == NULL) {
                        error = -ENOMEM;
                        goto bad;
                }
        }
        if (ath_hal_getdiagstate(ah, id, indata, insize, &outdata, &outsize)) {
                if (outsize < ad->ad_out_size)
                        ad->ad_out_size = outsize;
                if (outdata &&
                     copy_to_user(ad->ad_out_data, outdata, ad->ad_out_size))
                        error = -EFAULT;
        } else {
                error = -EINVAL;
        }
bad:
        if ((ad->ad_id & ATH_DIAG_IN) && indata != NULL)
                kfree(indata);
        if ((ad->ad_id & ATH_DIAG_DYN) && outdata != NULL)
                kfree(outdata);
        return error;
}


extern  int ath_ioctl_ethtool(struct ath_softc *sc, int cmd, void *addr);

static int
ath_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
        struct ath_softc *sc = dev->priv;
        int error;

        switch (cmd) {
        case SIOCGATHSTATS:
                        error = 0;
                break;
        case SIOCGATHDIAG:
                if (!capable(CAP_NET_ADMIN))
                        error = -EPERM;
                else
                        error = ath_ioctl_diag(sc, (struct ath_diag *) ifr);
                break;
        case SIOCETHTOOL:
                if (copy_from_user(&cmd, ifr->ifr_data, sizeof(cmd)))
                        error = -EFAULT;
                else
                        error = ath_ioctl_ethtool(sc, cmd, ifr->ifr_data);
                        break;
        default:
                error = 0;
                break;
        }
        return error;
}

#ifdef CONFIG_SYSCTL
/*
 * Sysctls are split into ``static'' and ``dynamic'' tables.
 * The former are defined at module load time and are used
 * control parameters common to all devices.  The latter are
 * tied to particular device instances and come and go with
 * each device.  The split is currently a bit tenuous; many of
 * the static ones probably should be dynamic but having them
 * static (e.g. debug) means they can be set after a module is
 * loaded and before bringing up a device.  The alternative
 * is to add module parameters.
 */

/*
 * Dynamic (i.e. per-device) sysctls.  These are automatically
 * mirrored in /proc/sys.
 */
enum {
        ATH_SLOTTIME    = 1,
        ATH_ACKTIMEOUT  = 2,
        ATH_CTSTIMEOUT  = 3,
        ATH_SOFTLED     = 4,
        ATH_LEDPIN      = 5,
        ATH_COUNTRYCODE = 6,
        ATH_REGDOMAIN   = 7,
        ATH_DEBUG       = 8,
        ATH_TXANTENNA   = 9,
        ATH_RXANTENNA   = 10,
        ATH_DIVERSITY   = 11,
        ATH_PHYERR      = 12,
};

static int
ATH_SYSCTL_DECL(ath_sysctl_halparam, ctl, write, filp, buffer, lenp, ppos)
{
        struct ath_softc *sc = ctl->extra1;
        struct ath_hal *ah = sc->sc_ah;
        u_int val;
        int ret;

        ctl->data = &val;
        ctl->maxlen = sizeof(val);
        if (write) {
                ret = ATH_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer,
                                lenp, ppos);
                if (ret == 0) {
                        switch (ctl->ctl_name) {
                        case ATH_SLOTTIME:
                                if (!ath_hal_setslottime(ah, val))
                                        ret = -EINVAL;
                                break;
                        case ATH_ACKTIMEOUT:
                                if (!ath_hal_setacktimeout(ah, val))
                                        ret = -EINVAL;
                                break;
                        case ATH_CTSTIMEOUT:
                                if (!ath_hal_setctstimeout(ah, val))
                                        ret = -EINVAL;
                                break;
                        case ATH_SOFTLED:
                                if (val != sc->sc_softled) {
                                        if (val)
                                                ath_hal_gpioCfgOutput(ah,
                                                        sc->sc_ledpin);
                                        ath_hal_gpioset(ah, sc->sc_ledpin,!val);
                                        sc->sc_softled = val;
                                }
                                break;
                        case ATH_LEDPIN:
                                sc->sc_ledpin = val;
                                break;
                        case ATH_DEBUG:
                                sc->sc_debug = val;
                                break;
                        case ATH_TXANTENNA:
                                /* XXX validate? */
                                sc->sc_txantenna = val;
                                break;
                        case ATH_RXANTENNA:
                                /* XXX validate? */
                                ath_setdefantenna(sc, val);
                                break;
                        case ATH_DIVERSITY:
                                /* XXX validate? */
                                if (!sc->sc_hasdiversity)
                                        return -EINVAL;
                                sc->sc_diversity = val;
                                ath_hal_setdiversity(ah, val);
                                break;
                        case ATH_PHYERR: {
                          uint32_t rfilt = ath_calcrxfilter(&sc->dev);
                          ath_phyerr = val;
                          ath_hal_setrxfilter(ah, rfilt);
                          break;
                        }
                        default:
                                return -EINVAL;
                        }
                }
        } else {
                switch (ctl->ctl_name) {
                case ATH_SLOTTIME:
                        val = ath_hal_getslottime(ah);
                        break;
                case ATH_ACKTIMEOUT:
                        val = ath_hal_getacktimeout(ah);
                        break;
                case ATH_CTSTIMEOUT:
                        val = ath_hal_getctstimeout(ah);
                        break;
                case ATH_SOFTLED:
                        val = sc->sc_softled;
                        break;
                case ATH_LEDPIN:
                        val = sc->sc_ledpin;
                        break;
                case ATH_COUNTRYCODE:
                        ath_hal_getcountrycode(ah, &val);
                        break;
                case ATH_REGDOMAIN:
                        ath_hal_getregdomain(ah, &val);
                        break;
                case ATH_DEBUG:
                        val = sc->sc_debug;
                        break;
                case ATH_TXANTENNA:
                        val = sc->sc_txantenna;
                        break;
                case ATH_RXANTENNA:
                        val = ath_hal_getdefantenna(ah);
                        break;
                case ATH_DIVERSITY:
                        val = sc->sc_diversity;
                        break;
                case ATH_PHYERR:
                        val = ath_phyerr;
                        break;
                default:
                        return -EINVAL;
                }
                ret = ATH_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer,
                                lenp, ppos);
        }
        return ret;
}

static  int mindwelltime = 100;                 /* 100ms */
static  int mincalibrate = 1;                   /* once a second */
static  int maxint = 0x7fffffff;                /* 32-bit big */

#define CTL_AUTO        -2      /* cannot be CTL_ANY or CTL_NONE */

static const ctl_table ath_sysctl_template[] = {
        { .ctl_name     = ATH_SLOTTIME,
          .procname     = "slottime",
          .mode         = 0644,
          .proc_handler = ath_sysctl_halparam
        },
        { .ctl_name     = ATH_ACKTIMEOUT,
          .procname     = "acktimeout",
          .mode         = 0644,
          .proc_handler = ath_sysctl_halparam
        },
        { .ctl_name     = ATH_CTSTIMEOUT,
          .procname     = "ctstimeout",
          .mode         = 0644,
          .proc_handler = ath_sysctl_halparam
        },
        { .ctl_name     = ATH_SOFTLED,
          .procname     = "softled",
          .mode         = 0644,
          .proc_handler = ath_sysctl_halparam
        },
        { .ctl_name     = ATH_LEDPIN,
          .procname     = "ledpin",
          .mode         = 0644,
          .proc_handler = ath_sysctl_halparam
        },
        { .ctl_name     = ATH_COUNTRYCODE,
          .procname     = "countrycode",
          .mode         = 0444,
          .proc_handler = ath_sysctl_halparam
        },
        { .ctl_name     = ATH_REGDOMAIN,
          .procname     = "regdomain",
          .mode         = 0444,
          .proc_handler = ath_sysctl_halparam
        },
#ifdef AR_DEBUG
        { .ctl_name     = ATH_DEBUG,
          .procname     = "debug",
          .mode         = 0644,
          .proc_handler = ath_sysctl_halparam
        },
#endif
        { .ctl_name     = ATH_TXANTENNA,
          .procname     = "txantenna",
          .mode         = 0644,
          .proc_handler = ath_sysctl_halparam
        },
        { .ctl_name     = ATH_RXANTENNA,
          .procname     = "rxantenna",
          .mode         = 0644,
          .proc_handler = ath_sysctl_halparam
        },
        { .ctl_name     = ATH_DIVERSITY,
          .procname     = "diversity",
          .mode         = 0644,
          .proc_handler = ath_sysctl_halparam
        },
        { .ctl_name     = ATH_PHYERR,
          .procname     = "phyerr",
          .mode         = 0644,
          .proc_handler = ath_sysctl_halparam
        },
        { 0 }
};

static void
ath_dynamic_sysctl_register(struct ath_softc *sc)
{
        int i, space;

        space = 5*sizeof(struct ctl_table) + sizeof(ath_sysctl_template);
        sc->sc_sysctls = kmalloc(space, GFP_KERNEL);
        if (sc->sc_sysctls == NULL) {
                printk("%s: no memory for sysctl table!\n", __func__);
                return;
        }

        /* setup the table */
        memset(sc->sc_sysctls, 0, space);
        sc->sc_sysctls[0].ctl_name = CTL_DEV;
        sc->sc_sysctls[0].procname = "dev";
        sc->sc_sysctls[0].mode = 0555;
        sc->sc_sysctls[0].child = &sc->sc_sysctls[2];
        /* [1] is NULL terminator */
        sc->sc_sysctls[2].ctl_name = CTL_AUTO;
        sc->sc_sysctls[2].procname = sc->dev.name;
        sc->sc_sysctls[2].mode = 0555;
        sc->sc_sysctls[2].child = &sc->sc_sysctls[4];
        /* [3] is NULL terminator */
        /* copy in pre-defined data */
        memcpy(&sc->sc_sysctls[4], ath_sysctl_template,
                sizeof(ath_sysctl_template));

        /* add in dynamic data references */
        for (i = 4; sc->sc_sysctls[i].ctl_name; i++)
                if (sc->sc_sysctls[i].extra1 == NULL)
                        sc->sc_sysctls[i].extra1 = sc;

        /* and register everything */
        sc->sc_sysctl_header = register_sysctl_table(sc->sc_sysctls, 1);
        if (!sc->sc_sysctl_header) {
                printk("%s: failed to register sysctls!\n", sc->dev.name);
                kfree(sc->sc_sysctls);
                sc->sc_sysctls = NULL;
        }

        /* initialize values */
        sc->sc_debug = ath_debug;
        sc->sc_txantenna = 0;           /* default to auto-selection */
}

static void
ath_dynamic_sysctl_unregister(struct ath_softc *sc)
{
        if (sc->sc_sysctl_header) {
                unregister_sysctl_table(sc->sc_sysctl_header);
                sc->sc_sysctl_header = NULL;
        }
        if (sc->sc_sysctls) {
                kfree(sc->sc_sysctls);
                sc->sc_sysctls = NULL;
        }
}

/*
 * Announce various information on device/driver attach.
 */
static void
ath_announce(struct net_device *dev)
{
#define HAL_MODE_DUALBAND       (HAL_MODE_11A|HAL_MODE_11B)
        struct ath_softc *sc = dev->priv;
        struct ath_hal *ah = sc->sc_ah;
        u_int modes, cc;
        int i;

        printk("%s: mac %d.%d phy %d.%d", dev->name,
                ah->ah_macVersion, ah->ah_macRev,
                ah->ah_phyRev >> 4, ah->ah_phyRev & 0xf);
        /*
         * Print radio revision(s).  We check the wireless modes
         * to avoid falsely printing revs for inoperable parts.
         * Dual-band radio revs are returned in the 5Ghz rev number.
         */
        ath_hal_getcountrycode(ah, &cc);
        modes = ath_hal_getwirelessmodes(ah, cc);
        if ((modes & HAL_MODE_DUALBAND) == HAL_MODE_DUALBAND) {
                if (ah->ah_analog5GhzRev && ah->ah_analog2GhzRev)
                        printk(" 5ghz radio %d.%d 2ghz radio %d.%d",
                                ah->ah_analog5GhzRev >> 4,
                                ah->ah_analog5GhzRev & 0xf,
                                ah->ah_analog2GhzRev >> 4,
                                ah->ah_analog2GhzRev & 0xf);
                else
                        printk(" radio %d.%d", ah->ah_analog5GhzRev >> 4,
                                ah->ah_analog5GhzRev & 0xf);
        } else
                printk(" radio %d.%d", ah->ah_analog5GhzRev >> 4,
                        ah->ah_analog5GhzRev & 0xf);
        printk("\n");
        printk("%s: 802.11 address: %s\n",
                dev->name, ether_sprintf(dev->dev_addr));
        for (i = 0; i <= WME_AC_VO; i++) {
                struct ath_txq *txq = sc->sc_ac2q[i];
                printk("%s: Use hw queue %u for %s traffic\n",
                        dev->name, txq->axq_qnum, acnames[i]);
        }
#undef HAL_MODE_DUALBAND
}

/*
 * Static (i.e. global) sysctls.  Note that the hal sysctls
 * are located under ours by sharing the setting for DEV_ATH.
 */
enum {
        DEV_ATH         = 9,                    /* XXX known by hal */
};

static ctl_table ath_static_sysctls[] = {
#ifdef AR_DEBUG
        { .ctl_name     = CTL_AUTO,
           .procname    = "debug",
          .mode         = 0644,
          .data         = &ath_debug,
          .maxlen       = sizeof(ath_debug),
          .proc_handler = proc_dointvec
        },
#endif
        { .ctl_name     = CTL_AUTO,
          .procname     = "countrycode",
          .mode         = 0444,
          .data         = &ath_countrycode,
          .maxlen       = sizeof(ath_countrycode),
          .proc_handler = proc_dointvec
        },
        { .ctl_name     = CTL_AUTO,
          .procname     = "regdomain",
          .mode         = 0444,
          .data         = &ath_regdomain,
          .maxlen       = sizeof(ath_regdomain),
          .proc_handler = proc_dointvec
        },
        { .ctl_name     = CTL_AUTO,
          .procname     = "outdoor",
          .mode         = 0444,
          .data         = &ath_outdoor,
          .maxlen       = sizeof(ath_outdoor),
          .proc_handler = proc_dointvec
        },
        { .ctl_name     = CTL_AUTO,
          .procname     = "xchanmode",
          .mode         = 0444,
          .data         = &ath_xchanmode,
          .maxlen       = sizeof(ath_xchanmode),
          .proc_handler = proc_dointvec
        },
        { .ctl_name     = CTL_AUTO,
          .procname     = "dwelltime",
          .mode         = 0644,
          .data         = &ath_dwelltime,
          .maxlen       = sizeof(ath_dwelltime),
          .extra1       = &mindwelltime,
          .extra2       = &maxint,
          .proc_handler = proc_dointvec_minmax
        },
        { .ctl_name     = CTL_AUTO,
          .procname     = "calibrate",
          .mode         = 0644,
          .data         = &ath_calinterval,
          .maxlen       = sizeof(ath_calinterval),
          .extra1       = &mincalibrate,
          .extra2       = &maxint,
          .proc_handler = proc_dointvec_minmax
        },
        { 0 }
};
static ctl_table ath_ath_table[] = {
        { .ctl_name     = DEV_ATH,
          .procname     = "ath",
          .mode         = 0555,
          .child        = ath_static_sysctls
        }, { 0 }
};
static ctl_table ath_root_table[] = {
        { .ctl_name     = CTL_DEV,
          .procname     = "dev",
          .mode         = 0555,
          .child        = ath_ath_table
        }, { 0 }
};
static struct ctl_table_header *ath_sysctl_header;

void
ath_sysctl_register(void)
{
        static int initialized = 0;

        if (!initialized) {
                ath_sysctl_header =
                        register_sysctl_table(ath_root_table, 1);
                initialized = 1;
        }
}

void
ath_sysctl_unregister(void)
{
        if (ath_sysctl_header)
                unregister_sysctl_table(ath_sysctl_header);
}
#endif /* CONFIG_SYSCTL */

---