Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 094d05dc32fc2930e381189a942016e5561775d9

Authored by Sujith 2008-12-12 14:27:43 +0800

Committed by John W. Linville 2008-12-20 04:22:54 +0800

Exists in master and in 7 other branches

mac80211: Fix HT channel selection

HT management is done differently for AP and STA modes, unify
to just the ->config() callback since HT is fundamentally a
PHY property and cannot be per-BSS.

Rename enum nl80211_sec_chan_offset as nl80211_channel_type to denote
the channel type ( NO_HT, HT20, HT40+, HT40- ).

Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Sujith <Sujith.Manoharan@atheros.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

Showing 13 changed files with 109 additions and 169 deletions Inline Diff

drivers/net/wireless/ath9k/main.c
drivers/net/wireless/iwlwifi/iwl-agn.c
drivers/net/wireless/mac80211_hwsim.c
include/linux/nl80211.h
include/net/cfg80211.h
include/net/mac80211.h
net/mac80211/cfg.c
net/mac80211/ht.c
net/mac80211/ieee80211_i.h
net/mac80211/main.c
net/mac80211/mlme.c
net/mac80211/util.c
net/wireless/nl80211.c

drivers/net/wireless/ath9k/main.c

Diff comments View file @ 094d05d

 /*
  * Copyright (c) 2008 Atheros Communications Inc.
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 #include <linux/nl80211.h>
 #include "core.h"
 #include "reg.h"
 #include "hw.h"
 #define ATH_PCI_VERSION "0.1"
 static char *dev_info = "ath9k";
 MODULE_AUTHOR("Atheros Communications");
 MODULE_DESCRIPTION("Support for Atheros 802.11n wireless LAN cards.");
 MODULE_SUPPORTED_DEVICE("Atheros 802.11n WLAN cards");
 MODULE_LICENSE("Dual BSD/GPL");
 static struct pci_device_id ath_pci_id_table[] __devinitdata = {
 	{ PCI_VDEVICE(ATHEROS, 0x0023) }, /* PCI   */
 	{ PCI_VDEVICE(ATHEROS, 0x0024) }, /* PCI-E */
 	{ PCI_VDEVICE(ATHEROS, 0x0027) }, /* PCI   */
 	{ PCI_VDEVICE(ATHEROS, 0x0029) }, /* PCI   */
 	{ PCI_VDEVICE(ATHEROS, 0x002A) }, /* PCI-E */
 	{ PCI_VDEVICE(ATHEROS, 0x002B) }, /* PCI-E */
 	{ 0 }
 };
 static void ath_detach(struct ath_softc *sc);
 /* return bus cachesize in 4B word units */
 static void bus_read_cachesize(struct ath_softc *sc, int *csz)
 {
 	u8 u8tmp;
 	pci_read_config_byte(sc->pdev, PCI_CACHE_LINE_SIZE, (u8 *)&u8tmp);
 	*csz = (int)u8tmp;
 	/*
 	 * This check was put in to avoid "unplesant" consequences if
 	 * the bootrom has not fully initialized all PCI devices.
 	 * Sometimes the cache line size register is not set
 	 */
 	if (*csz == 0)
 		*csz = DEFAULT_CACHELINE >> 2;   /* Use the default size */
 }
 static void ath_setcurmode(struct ath_softc *sc, enum wireless_mode mode)
 {
 	if (!sc->sc_curaid)
 		sc->cur_rate_table = sc->hw_rate_table[mode];
 	/*
 	 * All protection frames are transmited at 2Mb/s for
 	 * 11g, otherwise at 1Mb/s.
 	 * XXX select protection rate index from rate table.
 	 */
 	sc->sc_protrix = (mode == ATH9K_MODE_11G ? 1 : 0);
 }
 static enum wireless_mode ath_chan2mode(struct ath9k_channel *chan)
 {
 	if (chan->chanmode == CHANNEL_A)
 		return ATH9K_MODE_11A;
 	else if (chan->chanmode == CHANNEL_G)
 		return ATH9K_MODE_11G;
 	else if (chan->chanmode == CHANNEL_B)
 		return ATH9K_MODE_11B;
 	else if (chan->chanmode == CHANNEL_A_HT20)
 		return ATH9K_MODE_11NA_HT20;
 	else if (chan->chanmode == CHANNEL_G_HT20)
 		return ATH9K_MODE_11NG_HT20;
 	else if (chan->chanmode == CHANNEL_A_HT40PLUS)
 		return ATH9K_MODE_11NA_HT40PLUS;
 	else if (chan->chanmode == CHANNEL_A_HT40MINUS)
 		return ATH9K_MODE_11NA_HT40MINUS;
 	else if (chan->chanmode == CHANNEL_G_HT40PLUS)
 		return ATH9K_MODE_11NG_HT40PLUS;
 	else if (chan->chanmode == CHANNEL_G_HT40MINUS)
 		return ATH9K_MODE_11NG_HT40MINUS;
 	WARN_ON(1); /* should not get here */
 	return ATH9K_MODE_11B;
 }
 static void ath_update_txpow(struct ath_softc *sc)
 {
 	struct ath_hal *ah = sc->sc_ah;
 	u32 txpow;
 	if (sc->sc_curtxpow != sc->sc_config.txpowlimit) {
 		ath9k_hw_set_txpowerlimit(ah, sc->sc_config.txpowlimit);
 		/* read back in case value is clamped */
 		ath9k_hw_getcapability(ah, ATH9K_CAP_TXPOW, 1, &txpow);
 		sc->sc_curtxpow = txpow;
 	}
 }
 static u8 parse_mpdudensity(u8 mpdudensity)
 {
 	/*
 	 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
 	 *   0 for no restriction
 	 *   1 for 1/4 us
 	 *   2 for 1/2 us
 	 *   3 for 1 us
 	 *   4 for 2 us
 	 *   5 for 4 us
 	 *   6 for 8 us
 	 *   7 for 16 us
 	 */
 	switch (mpdudensity) {
 	case 0:
 		return 0;
 	case 1:
 	case 2:
 	case 3:
 		/* Our lower layer calculations limit our precision to
 		   1 microsecond */
 		return 1;
 	case 4:
 		return 2;
 	case 5:
 		return 4;
 	case 6:
 		return 8;
 	case 7:
 		return 16;
 	default:
 		return 0;
 	}
 }
 static void ath_setup_rates(struct ath_softc *sc, enum ieee80211_band band)
 {
 	struct ath_rate_table *rate_table = NULL;
 	struct ieee80211_supported_band *sband;
 	struct ieee80211_rate *rate;
 	int i, maxrates;
 	switch (band) {
 	case IEEE80211_BAND_2GHZ:
 		rate_table = sc->hw_rate_table[ATH9K_MODE_11G];
 		break;
 	case IEEE80211_BAND_5GHZ:
 		rate_table = sc->hw_rate_table[ATH9K_MODE_11A];
 		break;
 	default:
 		break;
 	}
 	if (rate_table == NULL)
 		return;
 	sband = &sc->sbands[band];
 	rate = sc->rates[band];
 	if (rate_table->rate_cnt > ATH_RATE_MAX)
 		maxrates = ATH_RATE_MAX;
 	else
 		maxrates = rate_table->rate_cnt;
 	for (i = 0; i < maxrates; i++) {
 		rate[i].bitrate = rate_table->info[i].ratekbps / 100;
 		rate[i].hw_value = rate_table->info[i].ratecode;
 		sband->n_bitrates++;
 		DPRINTF(sc, ATH_DBG_CONFIG, "Rate: %2dMbps, ratecode: %2d\n",
 			rate[i].bitrate / 10, rate[i].hw_value);
 	}
 }
 static int ath_setup_channels(struct ath_softc *sc)
 {
 	struct ath_hal *ah = sc->sc_ah;
 	int nchan, i, a = 0, b = 0;
 	u8 regclassids[ATH_REGCLASSIDS_MAX];
 	u32 nregclass = 0;
 	struct ieee80211_supported_band *band_2ghz;
 	struct ieee80211_supported_band *band_5ghz;
 	struct ieee80211_channel *chan_2ghz;
 	struct ieee80211_channel *chan_5ghz;
 	struct ath9k_channel *c;
 	/* Fill in ah->ah_channels */
 	if (!ath9k_regd_init_channels(ah, ATH_CHAN_MAX, (u32 *)&nchan,
 				      regclassids, ATH_REGCLASSIDS_MAX,
 				      &nregclass, CTRY_DEFAULT, false, 1)) {
 		u32 rd = ah->ah_currentRD;
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to collect channel list; "
 			"regdomain likely %u country code %u\n",
 			rd, CTRY_DEFAULT);
 		return -EINVAL;
 	}
 	band_2ghz = &sc->sbands[IEEE80211_BAND_2GHZ];
 	band_5ghz = &sc->sbands[IEEE80211_BAND_5GHZ];
 	chan_2ghz = sc->channels[IEEE80211_BAND_2GHZ];
 	chan_5ghz = sc->channels[IEEE80211_BAND_5GHZ];
 	for (i = 0; i < nchan; i++) {
 		c = &ah->ah_channels[i];
 		if (IS_CHAN_2GHZ(c)) {
 			chan_2ghz[a].band = IEEE80211_BAND_2GHZ;
 			chan_2ghz[a].center_freq = c->channel;
 			chan_2ghz[a].max_power = c->maxTxPower;
 			if (c->privFlags & CHANNEL_DISALLOW_ADHOC)
 				chan_2ghz[a].flags |= IEEE80211_CHAN_NO_IBSS;
 			if (c->channelFlags & CHANNEL_PASSIVE)
 				chan_2ghz[a].flags |= IEEE80211_CHAN_PASSIVE_SCAN;
 			band_2ghz->n_channels = ++a;
 			DPRINTF(sc, ATH_DBG_CONFIG, "2MHz channel: %d, "
 				"channelFlags: 0x%x\n",
 				c->channel, c->channelFlags);
 		} else if (IS_CHAN_5GHZ(c)) {
 			chan_5ghz[b].band = IEEE80211_BAND_5GHZ;
 			chan_5ghz[b].center_freq = c->channel;
 			chan_5ghz[b].max_power = c->maxTxPower;
 			if (c->privFlags & CHANNEL_DISALLOW_ADHOC)
 				chan_5ghz[b].flags |= IEEE80211_CHAN_NO_IBSS;
 			if (c->channelFlags & CHANNEL_PASSIVE)
 				chan_5ghz[b].flags |= IEEE80211_CHAN_PASSIVE_SCAN;
 			band_5ghz->n_channels = ++b;
 			DPRINTF(sc, ATH_DBG_CONFIG, "5MHz channel: %d, "
 				"channelFlags: 0x%x\n",
 				c->channel, c->channelFlags);
 		}
 	}
 	return 0;
 }
 /*
  * Set/change channels.  If the channel is really being changed, it's done
  * by reseting the chip.  To accomplish this we must first cleanup any pending
  * DMA, then restart stuff.
 */
 static int ath_set_channel(struct ath_softc *sc, struct ath9k_channel *hchan)
 {
 	struct ath_hal *ah = sc->sc_ah;
 	bool fastcc = true, stopped;
 	if (sc->sc_flags & SC_OP_INVALID)
 		return -EIO;
 	if (hchan->channel != sc->sc_ah->ah_curchan->channel ||
 	    hchan->channelFlags != sc->sc_ah->ah_curchan->channelFlags ||
 	    (sc->sc_flags & SC_OP_CHAINMASK_UPDATE) ||
 	    (sc->sc_flags & SC_OP_FULL_RESET)) {
 		int status;
 		/*
 		 * This is only performed if the channel settings have
 		 * actually changed.
 		 *
 		 * To switch channels clear any pending DMA operations;
 		 * wait long enough for the RX fifo to drain, reset the
 		 * hardware at the new frequency, and then re-enable
 		 * the relevant bits of the h/w.
 		 */
 		ath9k_hw_set_interrupts(ah, 0);
 		ath_draintxq(sc, false);
 		stopped = ath_stoprecv(sc);
 		/* XXX: do not flush receive queue here. We don't want
 		 * to flush data frames already in queue because of
 		 * changing channel. */
 		if (!stopped || (sc->sc_flags & SC_OP_FULL_RESET))
 			fastcc = false;
 		DPRINTF(sc, ATH_DBG_CONFIG,
 			"(%u MHz) -> (%u MHz), cflags:%x, chanwidth: %d\n",
 			sc->sc_ah->ah_curchan->channel,
 			hchan->channel, hchan->channelFlags, sc->tx_chan_width);
 		spin_lock_bh(&sc->sc_resetlock);
 		if (!ath9k_hw_reset(ah, hchan, sc->tx_chan_width,
 				    sc->sc_tx_chainmask, sc->sc_rx_chainmask,
 				    sc->sc_ht_extprotspacing, fastcc, &status)) {
 			DPRINTF(sc, ATH_DBG_FATAL,
 				"Unable to reset channel %u (%uMhz) "
 				"flags 0x%x hal status %u\n",
 				ath9k_hw_mhz2ieee(ah, hchan->channel,
 						  hchan->channelFlags),
 				hchan->channel, hchan->channelFlags, status);
 			spin_unlock_bh(&sc->sc_resetlock);
 			return -EIO;
 		}
 		spin_unlock_bh(&sc->sc_resetlock);
 		sc->sc_flags &= ~SC_OP_CHAINMASK_UPDATE;
 		sc->sc_flags &= ~SC_OP_FULL_RESET;
 		if (ath_startrecv(sc) != 0) {
 			DPRINTF(sc, ATH_DBG_FATAL,
 				"Unable to restart recv logic\n");
 			return -EIO;
 		}
 		ath_setcurmode(sc, ath_chan2mode(hchan));
 		ath_update_txpow(sc);
 		ath9k_hw_set_interrupts(ah, sc->sc_imask);
 	}
 	return 0;
 }
 /*
  *  This routine performs the periodic noise floor calibration function
  *  that is used to adjust and optimize the chip performance.  This
  *  takes environmental changes (location, temperature) into account.
  *  When the task is complete, it reschedules itself depending on the
  *  appropriate interval that was calculated.
  */
 static void ath_ani_calibrate(unsigned long data)
 {
 	struct ath_softc *sc;
 	struct ath_hal *ah;
 	bool longcal = false;
 	bool shortcal = false;
 	bool aniflag = false;
 	unsigned int timestamp = jiffies_to_msecs(jiffies);
 	u32 cal_interval;
 	sc = (struct ath_softc *)data;
 	ah = sc->sc_ah;
 	/*
 	* don't calibrate when we're scanning.
 	* we are most likely not on our home channel.
 	*/
 	if (sc->rx.rxfilter & FIF_BCN_PRBRESP_PROMISC)
 		return;
 	/* Long calibration runs independently of short calibration. */
 	if ((timestamp - sc->sc_ani.sc_longcal_timer) >= ATH_LONG_CALINTERVAL) {
 		longcal = true;
 		DPRINTF(sc, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
 		sc->sc_ani.sc_longcal_timer = timestamp;
 	}
 	/* Short calibration applies only while sc_caldone is false */
 	if (!sc->sc_ani.sc_caldone) {
 		if ((timestamp - sc->sc_ani.sc_shortcal_timer) >=
 		    ATH_SHORT_CALINTERVAL) {
 			shortcal = true;
 			DPRINTF(sc, ATH_DBG_ANI, "shortcal @%lu\n", jiffies);
 			sc->sc_ani.sc_shortcal_timer = timestamp;
 			sc->sc_ani.sc_resetcal_timer = timestamp;
 		}
 	} else {
 		if ((timestamp - sc->sc_ani.sc_resetcal_timer) >=
 		    ATH_RESTART_CALINTERVAL) {
 			ath9k_hw_reset_calvalid(ah, ah->ah_curchan,
 						&sc->sc_ani.sc_caldone);
 			if (sc->sc_ani.sc_caldone)
 				sc->sc_ani.sc_resetcal_timer = timestamp;
 		}
 	}
 	/* Verify whether we must check ANI */
 	if ((timestamp - sc->sc_ani.sc_checkani_timer) >=
 	   ATH_ANI_POLLINTERVAL) {
 		aniflag = true;
 		sc->sc_ani.sc_checkani_timer = timestamp;
 	}
 	/* Skip all processing if there's nothing to do. */
 	if (longcal || shortcal || aniflag) {
 		/* Call ANI routine if necessary */
 		if (aniflag)
 			ath9k_hw_ani_monitor(ah, &sc->sc_halstats,
 					     ah->ah_curchan);
 		/* Perform calibration if necessary */
 		if (longcal || shortcal) {
 			bool iscaldone = false;
 			if (ath9k_hw_calibrate(ah, ah->ah_curchan,
 					       sc->sc_rx_chainmask, longcal,
 					       &iscaldone)) {
 				if (longcal)
 					sc->sc_ani.sc_noise_floor =
 						ath9k_hw_getchan_noise(ah,
 							       ah->ah_curchan);
 				DPRINTF(sc, ATH_DBG_ANI,
 					"calibrate chan %u/%x nf: %d\n",
 					ah->ah_curchan->channel,
 					ah->ah_curchan->channelFlags,
 					sc->sc_ani.sc_noise_floor);
 			} else {
 				DPRINTF(sc, ATH_DBG_ANY,
 					"calibrate chan %u/%x failed\n",
 					ah->ah_curchan->channel,
 					ah->ah_curchan->channelFlags);
 			}
 			sc->sc_ani.sc_caldone = iscaldone;
 		}
 	}
 	/*
 	* Set timer interval based on previous results.
 	* The interval must be the shortest necessary to satisfy ANI,
 	* short calibration and long calibration.
 	*/
 	cal_interval = ATH_LONG_CALINTERVAL;
 	if (sc->sc_ah->ah_config.enable_ani)
 		cal_interval = min(cal_interval, (u32)ATH_ANI_POLLINTERVAL);
 	if (!sc->sc_ani.sc_caldone)
 		cal_interval = min(cal_interval, (u32)ATH_SHORT_CALINTERVAL);
 	mod_timer(&sc->sc_ani.timer, jiffies + msecs_to_jiffies(cal_interval));
 }
 /*
  * Update tx/rx chainmask. For legacy association,
  * hard code chainmask to 1x1, for 11n association, use
  * the chainmask configuration.
  */
 static void ath_update_chainmask(struct ath_softc *sc, int is_ht)
 {
 	sc->sc_flags |= SC_OP_CHAINMASK_UPDATE;
 	if (is_ht) {
 		sc->sc_tx_chainmask = sc->sc_ah->ah_caps.tx_chainmask;
 		sc->sc_rx_chainmask = sc->sc_ah->ah_caps.rx_chainmask;
 	} else {
 		sc->sc_tx_chainmask = 1;
 		sc->sc_rx_chainmask = 1;
 	}
 	DPRINTF(sc, ATH_DBG_CONFIG, "tx chmask: %d, rx chmask: %d\n",
 		sc->sc_tx_chainmask, sc->sc_rx_chainmask);
 }
 static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta)
 {
 	struct ath_node *an;
 	an = (struct ath_node *)sta->drv_priv;
 	if (sc->sc_flags & SC_OP_TXAGGR)
 		ath_tx_node_init(sc, an);
 	an->maxampdu = 1 << (IEEE80211_HTCAP_MAXRXAMPDU_FACTOR +
 			     sta->ht_cap.ampdu_factor);
 	an->mpdudensity = parse_mpdudensity(sta->ht_cap.ampdu_density);
 }
 static void ath_node_detach(struct ath_softc *sc, struct ieee80211_sta *sta)
 {
 	struct ath_node *an = (struct ath_node *)sta->drv_priv;
 	if (sc->sc_flags & SC_OP_TXAGGR)
 		ath_tx_node_cleanup(sc, an);
 }
 static void ath9k_tasklet(unsigned long data)
 {
 	struct ath_softc *sc = (struct ath_softc *)data;
 	u32 status = sc->sc_intrstatus;
 	if (status & ATH9K_INT_FATAL) {
 		/* need a chip reset */
 		ath_reset(sc, false);
 		return;
 	} else {
 		if (status &
 		    (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN)) {
 			spin_lock_bh(&sc->rx.rxflushlock);
 			ath_rx_tasklet(sc, 0);
 			spin_unlock_bh(&sc->rx.rxflushlock);
 		}
 		/* XXX: optimize this */
 		if (status & ATH9K_INT_TX)
 			ath_tx_tasklet(sc);
 	}
 	/* re-enable hardware interrupt */
 	ath9k_hw_set_interrupts(sc->sc_ah, sc->sc_imask);
 }
 static irqreturn_t ath_isr(int irq, void *dev)
 {
 	struct ath_softc *sc = dev;
 	struct ath_hal *ah = sc->sc_ah;
 	enum ath9k_int status;
 	bool sched = false;
 	do {
 		if (sc->sc_flags & SC_OP_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 (!ath9k_hw_intrpend(ah)) {	/* shared irq, not for us */
 			return IRQ_NONE;
 		}
 		/*
 		 * Figure out the reason(s) for the interrupt.  Note
 		 * that the hal returns a pseudo-ISR that may include
 		 * bits we haven't explicitly enabled so we mask the
 		 * value to insure we only process bits we requested.
 		 */
 		ath9k_hw_getisr(ah, &status);	/* NB: clears ISR too */
 		status &= sc->sc_imask;	/* discard unasked-for bits */
 		/*
 		 * If there are no status bits set, then this interrupt was not
 		 * for me (should have been caught above).
 		 */
 		if (!status)
 			return IRQ_NONE;
 		sc->sc_intrstatus = status;
 		if (status & ATH9K_INT_FATAL) {
 			/* need a chip reset */
 			sched = true;
 		} else if (status & ATH9K_INT_RXORN) {
 			/* need a chip reset */
 			sched = true;
 		} else {
 			if (status & ATH9K_INT_SWBA) {
 				/* schedule a tasklet for beacon handling */
 				tasklet_schedule(&sc->bcon_tasklet);
 			}
 			if (status & ATH9K_INT_RXEOL) {
 				/*
 				 * NB: the hardware should re-read the link when
 				 *     RXE bit is written, but it doesn't work
 				 *     at least on older hardware revs.
 				 */
 				sched = true;
 			}
 			if (status & ATH9K_INT_TXURN)
 				/* bump tx trigger level */
 				ath9k_hw_updatetxtriglevel(ah, true);
 			/* XXX: optimize this */
 			if (status & ATH9K_INT_RX)
 				sched = true;
 			if (status & ATH9K_INT_TX)
 				sched = true;
 			if (status & ATH9K_INT_BMISS)
 				sched = true;
 			/* carrier sense timeout */
 			if (status & ATH9K_INT_CST)
 				sched = true;
 			if (status & ATH9K_INT_MIB) {
 				/*
 				 * Disable interrupts until we service the MIB
 				 * interrupt; otherwise it will continue to
 				 * fire.
 				 */
 				ath9k_hw_set_interrupts(ah, 0);
 				/*
 				 * Let the hal handle the event. We assume
 				 * it will clear whatever condition caused
 				 * the interrupt.
 				 */
 				ath9k_hw_procmibevent(ah, &sc->sc_halstats);
 				ath9k_hw_set_interrupts(ah, sc->sc_imask);
 			}
 			if (status & ATH9K_INT_TIM_TIMER) {
 				if (!(ah->ah_caps.hw_caps &
 				      ATH9K_HW_CAP_AUTOSLEEP)) {
 					/* Clear RxAbort bit so that we can
 					 * receive frames */
 					ath9k_hw_setrxabort(ah, 0);
 					sched = true;
 				}
 			}
 		}
 	} while (0);
 	ath_debug_stat_interrupt(sc, status);
 	if (sched) {
 		/* turn off every interrupt except SWBA */
 		ath9k_hw_set_interrupts(ah, (sc->sc_imask & ATH9K_INT_SWBA));
 		tasklet_schedule(&sc->intr_tq);
 	}
 	return IRQ_HANDLED;
 }
 static int ath_get_channel(struct ath_softc *sc,
 			   struct ieee80211_channel *chan)
 {
 	int i;
 	for (i = 0; i < sc->sc_ah->ah_nchan; i++) {
 		if (sc->sc_ah->ah_channels[i].channel == chan->center_freq)
 			return i;
 	}
 	return -1;
 }
-/* ext_chan_offset: (-1, 0, 1) (below, none, above) */
 static u32 ath_get_extchanmode(struct ath_softc *sc,
 			       struct ieee80211_channel *chan,
-			       int ext_chan_offset,
+			       enum nl80211_channel_type channel_type)
-			       enum ath9k_ht_macmode tx_chan_width)
 {
 	u32 chanmode = 0;
 	switch (chan->band) {
 	case IEEE80211_BAND_2GHZ:
-		if ((ext_chan_offset == 0) &&
+		switch(channel_type) {
-		    (tx_chan_width == ATH9K_HT_MACMODE_20))
+		case NL80211_CHAN_NO_HT:
+		case NL80211_CHAN_HT20:
 			chanmode = CHANNEL_G_HT20;
-		if ((ext_chan_offset == 1) &&
+			break;
-		    (tx_chan_width == ATH9K_HT_MACMODE_2040))
+		case NL80211_CHAN_HT40PLUS:
 			chanmode = CHANNEL_G_HT40PLUS;
-		if ((ext_chan_offset == -1) &&
+			break;
-		    (tx_chan_width == ATH9K_HT_MACMODE_2040))
+		case NL80211_CHAN_HT40MINUS:
 			chanmode = CHANNEL_G_HT40MINUS;
+			break;
+		}
 		break;
 	case IEEE80211_BAND_5GHZ:
-		if ((ext_chan_offset == 0) &&
+		switch(channel_type) {
-		    (tx_chan_width == ATH9K_HT_MACMODE_20))
+		case NL80211_CHAN_NO_HT:
+		case NL80211_CHAN_HT20:
 			chanmode = CHANNEL_A_HT20;
-		if ((ext_chan_offset == 1) &&
+			break;
-		    (tx_chan_width == ATH9K_HT_MACMODE_2040))
+		case NL80211_CHAN_HT40PLUS:
 			chanmode = CHANNEL_A_HT40PLUS;
-		if ((ext_chan_offset == -1) &&
+			break;
-		    (tx_chan_width == ATH9K_HT_MACMODE_2040))
+		case NL80211_CHAN_HT40MINUS:
 			chanmode = CHANNEL_A_HT40MINUS;
+			break;
+		}
 		break;
 	default:
 		break;
 	}
 	return chanmode;
 }
 static void ath_key_reset(struct ath_softc *sc, u16 keyix, int freeslot)
 {
 	ath9k_hw_keyreset(sc->sc_ah, keyix);
 	if (freeslot)
 		clear_bit(keyix, sc->sc_keymap);
 }
 static int ath_keyset(struct ath_softc *sc, u16 keyix,
 	       struct ath9k_keyval *hk, const u8 mac[ETH_ALEN])
 {
 	bool status;
 	status = ath9k_hw_set_keycache_entry(sc->sc_ah,
 		keyix, hk, mac, false);
 	return status != false;
 }
 static int ath_setkey_tkip(struct ath_softc *sc,
 			   struct ieee80211_key_conf *key,
 			   struct ath9k_keyval *hk,
 			   const u8 *addr)
 {
 	u8 *key_rxmic = NULL;
 	u8 *key_txmic = NULL;
 	key_txmic = key->key + NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY;
 	key_rxmic = key->key + NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY;
 	if (addr == NULL) {
 		/* Group key installation */
 		memcpy(hk->kv_mic,  key_rxmic, sizeof(hk->kv_mic));
 		return ath_keyset(sc, key->keyidx, hk, addr);
 	}
 	if (!sc->sc_splitmic) {
 		/*
 		 * data key goes at first index,
 		 * the hal handles the MIC keys at index+64.
 		 */
 		memcpy(hk->kv_mic, key_rxmic, sizeof(hk->kv_mic));
 		memcpy(hk->kv_txmic, key_txmic, sizeof(hk->kv_txmic));
 		return ath_keyset(sc, key->keyidx, hk, addr);
 	}
 	/*
 	 * TX key goes at first index, RX key at +32.
 	 * The hal handles the MIC keys at index+64.
 	 */
 	memcpy(hk->kv_mic, key_txmic, sizeof(hk->kv_mic));
 	if (!ath_keyset(sc, key->keyidx, hk, NULL)) {
 		/* Txmic entry failed. No need to proceed further */
 		DPRINTF(sc, ATH_DBG_KEYCACHE,
 			"Setting TX MIC Key Failed\n");
 		return 0;
 	}
 	memcpy(hk->kv_mic, key_rxmic, sizeof(hk->kv_mic));
 	/* XXX delete tx key on failure? */
 	return ath_keyset(sc, key->keyidx+32, hk, addr);
 }
 static int ath_key_config(struct ath_softc *sc,
 			  const u8 *addr,
 			  struct ieee80211_key_conf *key)
 {
 	struct ieee80211_vif *vif;
 	struct ath9k_keyval hk;
 	const u8 *mac = NULL;
 	int ret = 0;
 	enum nl80211_iftype opmode;
 	memset(&hk, 0, sizeof(hk));
 	switch (key->alg) {
 	case ALG_WEP:
 		hk.kv_type = ATH9K_CIPHER_WEP;
 		break;
 	case ALG_TKIP:
 		hk.kv_type = ATH9K_CIPHER_TKIP;
 		break;
 	case ALG_CCMP:
 		hk.kv_type = ATH9K_CIPHER_AES_CCM;
 		break;
 	default:
 		return -EINVAL;
 	}
 	hk.kv_len  = key->keylen;
 	memcpy(hk.kv_val, key->key, key->keylen);
 	if (!sc->sc_vaps[0])
 		return -EIO;
 	vif = sc->sc_vaps[0];
 	opmode = vif->type;
 	/*
 	 *  Strategy:
 	 *   For STA mc tx, we will not setup a key at
 	 *   all since we never tx mc.
 	 *
 	 *   For STA mc rx, we will use the keyID.
 	 *
 	 *   For ADHOC mc tx, we will use the keyID, and no macaddr.
 	 *
 	 *   For ADHOC mc rx, we will alloc a slot and plumb the mac of
 	 *   the peer node.
 	 *   BUT we will plumb a cleartext key so that we can do
 	 *   per-Sta default key table lookup in software.
 	 */
 	if (is_broadcast_ether_addr(addr)) {
 		switch (opmode) {
 		case NL80211_IFTYPE_STATION:
 			/* default key:  could be group WPA key
 			 * or could be static WEP key */
 			mac = NULL;
 			break;
 		case NL80211_IFTYPE_ADHOC:
 			break;
 		case NL80211_IFTYPE_AP:
 			break;
 		default:
 			ASSERT(0);
 			break;
 		}
 	} else {
 		mac = addr;
 	}
 	if (key->alg == ALG_TKIP)
 		ret = ath_setkey_tkip(sc, key, &hk, mac);
 	else
 		ret = ath_keyset(sc, key->keyidx, &hk, mac);
 	if (!ret)
 		return -EIO;
 	return 0;
 }
 static void ath_key_delete(struct ath_softc *sc, struct ieee80211_key_conf *key)
 {
 	int freeslot;
 	freeslot = (key->keyidx >= 4) ? 1 : 0;
 	ath_key_reset(sc, key->keyidx, freeslot);
 }
 static void setup_ht_cap(struct ieee80211_sta_ht_cap *ht_info)
 {
 #define	ATH9K_HT_CAP_MAXRXAMPDU_65536 0x3	/* 2 ^ 16 */
 #define	ATH9K_HT_CAP_MPDUDENSITY_8 0x6		/* 8 usec */
 	ht_info->ht_supported = true;
 	ht_info->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
 		       IEEE80211_HT_CAP_SM_PS |
 		       IEEE80211_HT_CAP_SGI_40 |
 		       IEEE80211_HT_CAP_DSSSCCK40;
 	ht_info->ampdu_factor = ATH9K_HT_CAP_MAXRXAMPDU_65536;
 	ht_info->ampdu_density = ATH9K_HT_CAP_MPDUDENSITY_8;
 	/* set up supported mcs set */
 	memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
 	ht_info->mcs.rx_mask[0] = 0xff;
 	ht_info->mcs.rx_mask[1] = 0xff;
 	ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
 }
-static void ath9k_ht_conf(struct ath_softc *sc,
-			  struct ieee80211_bss_conf *bss_conf)
-{
-	if (sc->hw->conf.ht.enabled) {
-		if (bss_conf->ht.width_40_ok)
-			sc->tx_chan_width = ATH9K_HT_MACMODE_2040;
-		else
-			sc->tx_chan_width = ATH9K_HT_MACMODE_20;
-		ath9k_hw_set11nmac2040(sc->sc_ah, sc->tx_chan_width);
-		DPRINTF(sc, ATH_DBG_CONFIG,
-			"BSS Changed HT, chanwidth: %d\n", sc->tx_chan_width);
-	}
-}
-static inline int ath_sec_offset(u8 ext_offset)
-{
-	if (ext_offset == IEEE80211_HT_PARAM_CHA_SEC_NONE)
-		return 0;
-	else if (ext_offset == IEEE80211_HT_PARAM_CHA_SEC_ABOVE)
-		return 1;
-	else if (ext_offset == IEEE80211_HT_PARAM_CHA_SEC_BELOW)
-		return -1;
-	return 0;
-}
 static void ath9k_bss_assoc_info(struct ath_softc *sc,
 				 struct ieee80211_vif *vif,
 				 struct ieee80211_bss_conf *bss_conf)
 {
-	struct ieee80211_hw *hw = sc->hw;
-	struct ieee80211_channel *curchan = hw->conf.channel;
 	struct ath_vap *avp = (void *)vif->drv_priv;
-	int pos;
 	if (bss_conf->assoc) {
-		DPRINTF(sc, ATH_DBG_CONFIG, "Bss Info ASSOC %d\n", bss_conf->aid);
+		DPRINTF(sc, ATH_DBG_CONFIG, "Bss Info ASSOC %d, bssid: %pM\n",
+			bss_conf->aid, sc->sc_curbssid);
 		/* New association, store aid */
 		if (avp->av_opmode == NL80211_IFTYPE_STATION) {
 			sc->sc_curaid = bss_conf->aid;
 			ath9k_hw_write_associd(sc->sc_ah, sc->sc_curbssid,
 					       sc->sc_curaid);
 		}
 		/* Configure the beacon */
 		ath_beacon_config(sc, 0);
 		sc->sc_flags |= SC_OP_BEACONS;
 		/* Reset rssi stats */
 		sc->sc_halstats.ns_avgbrssi = ATH_RSSI_DUMMY_MARKER;
 		sc->sc_halstats.ns_avgrssi = ATH_RSSI_DUMMY_MARKER;
 		sc->sc_halstats.ns_avgtxrssi = ATH_RSSI_DUMMY_MARKER;
 		sc->sc_halstats.ns_avgtxrate = ATH_RATE_DUMMY_MARKER;
-		/* Update chainmask */
-		ath_update_chainmask(sc, hw->conf.ht.enabled);
-		DPRINTF(sc, ATH_DBG_CONFIG,
-			"bssid %pM aid 0x%x\n",
-			sc->sc_curbssid, sc->sc_curaid);
-		pos = ath_get_channel(sc, curchan);
-		if (pos == -1) {
-			DPRINTF(sc, ATH_DBG_FATAL,
-				"Invalid channel: %d\n", curchan->center_freq);
-			return;
-		}
-		if (hw->conf.ht.enabled) {
-			int offset =
-				ath_sec_offset(bss_conf->ht.secondary_channel_offset);
-			sc->tx_chan_width = (bss_conf->ht.width_40_ok) ?
-				ATH9K_HT_MACMODE_2040 : ATH9K_HT_MACMODE_20;
-			sc->sc_ah->ah_channels[pos].chanmode =
-				ath_get_extchanmode(sc, curchan,
-						    offset, sc->tx_chan_width);
-		} else {
-			sc->sc_ah->ah_channels[pos].chanmode =
-				(curchan->band == IEEE80211_BAND_2GHZ) ?
-				CHANNEL_G : CHANNEL_A;
-		}
-		/* set h/w channel */
-		if (ath_set_channel(sc, &sc->sc_ah->ah_channels[pos]) < 0)
-			DPRINTF(sc, ATH_DBG_FATAL, "Unable to set channel: %d\n",
-				curchan->center_freq);
 		/* Start ANI */
 		mod_timer(&sc->sc_ani.timer,
 			jiffies + msecs_to_jiffies(ATH_ANI_POLLINTERVAL));
 	} else {
 		DPRINTF(sc, ATH_DBG_CONFIG, "Bss Info DISSOC\n");
 		sc->sc_curaid = 0;
 	}
 }
 /********************************/
 /*	 LED functions		*/
 /********************************/
 static void ath_led_brightness(struct led_classdev *led_cdev,
 			       enum led_brightness brightness)
 {
 	struct ath_led *led = container_of(led_cdev, struct ath_led, led_cdev);
 	struct ath_softc *sc = led->sc;
 	switch (brightness) {
 	case LED_OFF:
 		if (led->led_type == ATH_LED_ASSOC ||
 		    led->led_type == ATH_LED_RADIO)
 			sc->sc_flags &= ~SC_OP_LED_ASSOCIATED;
 		ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN,
 				(led->led_type == ATH_LED_RADIO) ? 1 :
 				!!(sc->sc_flags & SC_OP_LED_ASSOCIATED));
 		break;
 	case LED_FULL:
 		if (led->led_type == ATH_LED_ASSOC)
 			sc->sc_flags |= SC_OP_LED_ASSOCIATED;
 		ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN, 0);
 		break;
 	default:
 		break;
 	}
 }
 static int ath_register_led(struct ath_softc *sc, struct ath_led *led,
 			    char *trigger)
 {
 	int ret;
 	led->sc = sc;
 	led->led_cdev.name = led->name;
 	led->led_cdev.default_trigger = trigger;
 	led->led_cdev.brightness_set = ath_led_brightness;
 	ret = led_classdev_register(wiphy_dev(sc->hw->wiphy), &led->led_cdev);
 	if (ret)
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Failed to register led:%s", led->name);
 	else
 		led->registered = 1;
 	return ret;
 }
 static void ath_unregister_led(struct ath_led *led)
 {
 	if (led->registered) {
 		led_classdev_unregister(&led->led_cdev);
 		led->registered = 0;
 	}
 }
 static void ath_deinit_leds(struct ath_softc *sc)
 {
 	ath_unregister_led(&sc->assoc_led);
 	sc->sc_flags &= ~SC_OP_LED_ASSOCIATED;
 	ath_unregister_led(&sc->tx_led);
 	ath_unregister_led(&sc->rx_led);
 	ath_unregister_led(&sc->radio_led);
 	ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN, 1);
 }
 static void ath_init_leds(struct ath_softc *sc)
 {
 	char *trigger;
 	int ret;
 	/* Configure gpio 1 for output */
 	ath9k_hw_cfg_output(sc->sc_ah, ATH_LED_PIN,
 			    AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
 	/* LED off, active low */
 	ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN, 1);
 	trigger = ieee80211_get_radio_led_name(sc->hw);
 	snprintf(sc->radio_led.name, sizeof(sc->radio_led.name),
 		"ath9k-%s:radio", wiphy_name(sc->hw->wiphy));
 	ret = ath_register_led(sc, &sc->radio_led, trigger);
 	sc->radio_led.led_type = ATH_LED_RADIO;
 	if (ret)
 		goto fail;
 	trigger = ieee80211_get_assoc_led_name(sc->hw);
 	snprintf(sc->assoc_led.name, sizeof(sc->assoc_led.name),
 		"ath9k-%s:assoc", wiphy_name(sc->hw->wiphy));
 	ret = ath_register_led(sc, &sc->assoc_led, trigger);
 	sc->assoc_led.led_type = ATH_LED_ASSOC;
 	if (ret)
 		goto fail;
 	trigger = ieee80211_get_tx_led_name(sc->hw);
 	snprintf(sc->tx_led.name, sizeof(sc->tx_led.name),
 		"ath9k-%s:tx", wiphy_name(sc->hw->wiphy));
 	ret = ath_register_led(sc, &sc->tx_led, trigger);
 	sc->tx_led.led_type = ATH_LED_TX;
 	if (ret)
 		goto fail;
 	trigger = ieee80211_get_rx_led_name(sc->hw);
 	snprintf(sc->rx_led.name, sizeof(sc->rx_led.name),
 		"ath9k-%s:rx", wiphy_name(sc->hw->wiphy));
 	ret = ath_register_led(sc, &sc->rx_led, trigger);
 	sc->rx_led.led_type = ATH_LED_RX;
 	if (ret)
 		goto fail;
 	return;
 fail:
 	ath_deinit_leds(sc);
 }
 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 /*******************/
 /*	Rfkill	   */
 /*******************/
 static void ath_radio_enable(struct ath_softc *sc)
 {
 	struct ath_hal *ah = sc->sc_ah;
 	int status;
 	spin_lock_bh(&sc->sc_resetlock);
 	if (!ath9k_hw_reset(ah, ah->ah_curchan,
 			    sc->tx_chan_width,
 			    sc->sc_tx_chainmask,
 			    sc->sc_rx_chainmask,
 			    sc->sc_ht_extprotspacing,
 			    false, &status)) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to reset channel %u (%uMhz) "
 			"flags 0x%x hal status %u\n",
 			ath9k_hw_mhz2ieee(ah,
 					  ah->ah_curchan->channel,
 					  ah->ah_curchan->channelFlags),
 			ah->ah_curchan->channel,
 			ah->ah_curchan->channelFlags, status);
 	}
 	spin_unlock_bh(&sc->sc_resetlock);
 	ath_update_txpow(sc);
 	if (ath_startrecv(sc) != 0) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to restart recv logic\n");
 		return;
 	}
 	if (sc->sc_flags & SC_OP_BEACONS)
 		ath_beacon_config(sc, ATH_IF_ID_ANY);	/* restart beacons */
 	/* Re-Enable  interrupts */
 	ath9k_hw_set_interrupts(ah, sc->sc_imask);
 	/* Enable LED */
 	ath9k_hw_cfg_output(ah, ATH_LED_PIN,
 			    AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
 	ath9k_hw_set_gpio(ah, ATH_LED_PIN, 0);
 	ieee80211_wake_queues(sc->hw);
 }
 static void ath_radio_disable(struct ath_softc *sc)
 {
 	struct ath_hal *ah = sc->sc_ah;
 	int status;
 	ieee80211_stop_queues(sc->hw);
 	/* Disable LED */
 	ath9k_hw_set_gpio(ah, ATH_LED_PIN, 1);
 	ath9k_hw_cfg_gpio_input(ah, ATH_LED_PIN);
 	/* Disable interrupts */
 	ath9k_hw_set_interrupts(ah, 0);
 	ath_draintxq(sc, false);	/* clear pending tx frames */
 	ath_stoprecv(sc);		/* turn off frame recv */
 	ath_flushrecv(sc);		/* flush recv queue */
 	spin_lock_bh(&sc->sc_resetlock);
 	if (!ath9k_hw_reset(ah, ah->ah_curchan,
 			    sc->tx_chan_width,
 			    sc->sc_tx_chainmask,
 			    sc->sc_rx_chainmask,
 			    sc->sc_ht_extprotspacing,
 			    false, &status)) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to reset channel %u (%uMhz) "
 			"flags 0x%x hal status %u\n",
 			ath9k_hw_mhz2ieee(ah,
 				ah->ah_curchan->channel,
 				ah->ah_curchan->channelFlags),
 			ah->ah_curchan->channel,
 			ah->ah_curchan->channelFlags, status);
 	}
 	spin_unlock_bh(&sc->sc_resetlock);
 	ath9k_hw_phy_disable(ah);
 	ath9k_hw_setpower(ah, ATH9K_PM_FULL_SLEEP);
 }
 static bool ath_is_rfkill_set(struct ath_softc *sc)
 {
 	struct ath_hal *ah = sc->sc_ah;
 	return ath9k_hw_gpio_get(ah, ah->ah_rfkill_gpio) ==
 				  ah->ah_rfkill_polarity;
 }
 /* h/w rfkill poll function */
 static void ath_rfkill_poll(struct work_struct *work)
 {
 	struct ath_softc *sc = container_of(work, struct ath_softc,
 					    rf_kill.rfkill_poll.work);
 	bool radio_on;
 	if (sc->sc_flags & SC_OP_INVALID)
 		return;
 	radio_on = !ath_is_rfkill_set(sc);
 	/*
 	 * enable/disable radio only when there is a
 	 * state change in RF switch
 	 */
 	if (radio_on == !!(sc->sc_flags & SC_OP_RFKILL_HW_BLOCKED)) {
 		enum rfkill_state state;
 		if (sc->sc_flags & SC_OP_RFKILL_SW_BLOCKED) {
 			state = radio_on ? RFKILL_STATE_SOFT_BLOCKED
 				: RFKILL_STATE_HARD_BLOCKED;
 		} else if (radio_on) {
 			ath_radio_enable(sc);
 			state = RFKILL_STATE_UNBLOCKED;
 		} else {
 			ath_radio_disable(sc);
 			state = RFKILL_STATE_HARD_BLOCKED;
 		}
 		if (state == RFKILL_STATE_HARD_BLOCKED)
 			sc->sc_flags |= SC_OP_RFKILL_HW_BLOCKED;
 		else
 			sc->sc_flags &= ~SC_OP_RFKILL_HW_BLOCKED;
 		rfkill_force_state(sc->rf_kill.rfkill, state);
 	}
 	queue_delayed_work(sc->hw->workqueue, &sc->rf_kill.rfkill_poll,
 			   msecs_to_jiffies(ATH_RFKILL_POLL_INTERVAL));
 }
 /* s/w rfkill handler */
 static int ath_sw_toggle_radio(void *data, enum rfkill_state state)
 {
 	struct ath_softc *sc = data;
 	switch (state) {
 	case RFKILL_STATE_SOFT_BLOCKED:
 		if (!(sc->sc_flags & (SC_OP_RFKILL_HW_BLOCKED |
 		    SC_OP_RFKILL_SW_BLOCKED)))
 			ath_radio_disable(sc);
 		sc->sc_flags |= SC_OP_RFKILL_SW_BLOCKED;
 		return 0;
 	case RFKILL_STATE_UNBLOCKED:
 		if ((sc->sc_flags & SC_OP_RFKILL_SW_BLOCKED)) {
 			sc->sc_flags &= ~SC_OP_RFKILL_SW_BLOCKED;
 			if (sc->sc_flags & SC_OP_RFKILL_HW_BLOCKED) {
 				DPRINTF(sc, ATH_DBG_FATAL, "Can't turn on the"
 					"radio as it is disabled by h/w\n");
 				return -EPERM;
 			}
 			ath_radio_enable(sc);
 		}
 		return 0;
 	default:
 		return -EINVAL;
 	}
 }
 /* Init s/w rfkill */
 static int ath_init_sw_rfkill(struct ath_softc *sc)
 {
 	sc->rf_kill.rfkill = rfkill_allocate(wiphy_dev(sc->hw->wiphy),
 					     RFKILL_TYPE_WLAN);
 	if (!sc->rf_kill.rfkill) {
 		DPRINTF(sc, ATH_DBG_FATAL, "Failed to allocate rfkill\n");
 		return -ENOMEM;
 	}
 	snprintf(sc->rf_kill.rfkill_name, sizeof(sc->rf_kill.rfkill_name),
 		"ath9k-%s:rfkill", wiphy_name(sc->hw->wiphy));
 	sc->rf_kill.rfkill->name = sc->rf_kill.rfkill_name;
 	sc->rf_kill.rfkill->data = sc;
 	sc->rf_kill.rfkill->toggle_radio = ath_sw_toggle_radio;
 	sc->rf_kill.rfkill->state = RFKILL_STATE_UNBLOCKED;
 	sc->rf_kill.rfkill->user_claim_unsupported = 1;
 	return 0;
 }
 /* Deinitialize rfkill */
 static void ath_deinit_rfkill(struct ath_softc *sc)
 {
 	if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_RFSILENT)
 		cancel_delayed_work_sync(&sc->rf_kill.rfkill_poll);
 	if (sc->sc_flags & SC_OP_RFKILL_REGISTERED) {
 		rfkill_unregister(sc->rf_kill.rfkill);
 		sc->sc_flags &= ~SC_OP_RFKILL_REGISTERED;
 		sc->rf_kill.rfkill = NULL;
 	}
 }
 static int ath_start_rfkill_poll(struct ath_softc *sc)
 {
 	if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_RFSILENT)
 		queue_delayed_work(sc->hw->workqueue,
 				   &sc->rf_kill.rfkill_poll, 0);
 	if (!(sc->sc_flags & SC_OP_RFKILL_REGISTERED)) {
 		if (rfkill_register(sc->rf_kill.rfkill)) {
 			DPRINTF(sc, ATH_DBG_FATAL,
 				"Unable to register rfkill\n");
 			rfkill_free(sc->rf_kill.rfkill);
 			/* Deinitialize the device */
 			ath_detach(sc);
 			if (sc->pdev->irq)
 				free_irq(sc->pdev->irq, sc);
 			pci_iounmap(sc->pdev, sc->mem);
 			pci_release_region(sc->pdev, 0);
 			pci_disable_device(sc->pdev);
 			ieee80211_free_hw(sc->hw);
 			return -EIO;
 		} else {
 			sc->sc_flags |= SC_OP_RFKILL_REGISTERED;
 		}
 	}
 	return 0;
 }
 #endif /* CONFIG_RFKILL */
 static void ath_detach(struct ath_softc *sc)
 {
 	struct ieee80211_hw *hw = sc->hw;
 	int i = 0;
 	DPRINTF(sc, ATH_DBG_CONFIG, "Detach ATH hw\n");
 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 	ath_deinit_rfkill(sc);
 #endif
 	ath_deinit_leds(sc);
 	ieee80211_unregister_hw(hw);
 	ath_rate_control_unregister();
 	ath_rx_cleanup(sc);
 	ath_tx_cleanup(sc);
 	tasklet_kill(&sc->intr_tq);
 	tasklet_kill(&sc->bcon_tasklet);
 	if (!(sc->sc_flags & SC_OP_INVALID))
 		ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_AWAKE);
 	/* cleanup tx queues */
 	for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
 		if (ATH_TXQ_SETUP(sc, i))
 			ath_tx_cleanupq(sc, &sc->tx.txq[i]);
 	ath9k_hw_detach(sc->sc_ah);
 	ath9k_exit_debug(sc);
 }
 static int ath_init(u16 devid, struct ath_softc *sc)
 {
 	struct ath_hal *ah = NULL;
 	int status;
 	int error = 0, i;
 	int csz = 0;
 	/* XXX: hardware will not be ready until ath_open() being called */
 	sc->sc_flags |= SC_OP_INVALID;
 	if (ath9k_init_debug(sc) < 0)
 		printk(KERN_ERR "Unable to create debugfs files\n");
 	spin_lock_init(&sc->sc_resetlock);
 	tasklet_init(&sc->intr_tq, ath9k_tasklet, (unsigned long)sc);
 	tasklet_init(&sc->bcon_tasklet, ath9k_beacon_tasklet,
 		     (unsigned long)sc);
 	/*
 	 * 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 */
 	ah = ath9k_hw_attach(devid, sc, sc->mem, &status);
 	if (ah == NULL) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to attach hardware; HAL status %u\n", status);
 		error = -ENXIO;
 		goto bad;
 	}
 	sc->sc_ah = ah;
 	/* Get the hardware key cache size. */
 	sc->sc_keymax = ah->ah_caps.keycache_size;
 	if (sc->sc_keymax > ATH_KEYMAX) {
 		DPRINTF(sc, ATH_DBG_KEYCACHE,
 			"Warning, using only %u entries in %u key cache\n",
 			ATH_KEYMAX, sc->sc_keymax);
 		sc->sc_keymax = ATH_KEYMAX;
 	}
 	/*
 	 * Reset the key cache since some parts do not
 	 * reset the contents on initial power up.
 	 */
 	for (i = 0; i < sc->sc_keymax; i++)
 		ath9k_hw_keyreset(ah, (u16) i);
 	/*
 	 * Mark key cache slots associated with global keys
 	 * as in use.  If we knew TKIP was not to be used we
 	 * could leave the +32, +64, and +32+64 slots free.
 	 * XXX only for splitmic.
 	 */
 	for (i = 0; i < IEEE80211_WEP_NKID; i++) {
 		set_bit(i, sc->sc_keymap);
 		set_bit(i + 32, sc->sc_keymap);
 		set_bit(i + 64, sc->sc_keymap);
 		set_bit(i + 32 + 64, sc->sc_keymap);
 	}
 	/* Collect the channel list using the default country code */
 	error = ath_setup_channels(sc);
 	if (error)
 		goto bad;
 	/* default to MONITOR mode */
 	sc->sc_ah->ah_opmode = NL80211_IFTYPE_MONITOR;
 	/* Setup rate tables */
 	ath_rate_attach(sc);
 	ath_setup_rates(sc, IEEE80211_BAND_2GHZ);
 	ath_setup_rates(sc, IEEE80211_BAND_5GHZ);
 	/*
 	 * 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.
 	 */
 	sc->beacon.beaconq = ath_beaconq_setup(ah);
 	if (sc->beacon.beaconq == -1) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to setup a beacon xmit queue\n");
 		error = -EIO;
 		goto bad2;
 	}
 	sc->beacon.cabq = ath_txq_setup(sc, ATH9K_TX_QUEUE_CAB, 0);
 	if (sc->beacon.cabq == NULL) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to setup CAB xmit queue\n");
 		error = -EIO;
 		goto bad2;
 	}
 	sc->sc_config.cabqReadytime = ATH_CABQ_READY_TIME;
 	ath_cabq_update(sc);
 	for (i = 0; i < ARRAY_SIZE(sc->tx.hwq_map); i++)
 		sc->tx.hwq_map[i] = -1;
 	/* Setup data queues */
 	/* NB: ensure BK queue is the lowest priority h/w queue */
 	if (!ath_tx_setup(sc, ATH9K_WME_AC_BK)) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to setup xmit queue for BK traffic\n");
 		error = -EIO;
 		goto bad2;
 	}
 	if (!ath_tx_setup(sc, ATH9K_WME_AC_BE)) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to setup xmit queue for BE traffic\n");
 		error = -EIO;
 		goto bad2;
 	}
 	if (!ath_tx_setup(sc, ATH9K_WME_AC_VI)) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to setup xmit queue for VI traffic\n");
 		error = -EIO;
 		goto bad2;
 	}
 	if (!ath_tx_setup(sc, ATH9K_WME_AC_VO)) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to setup xmit queue for VO traffic\n");
 		error = -EIO;
 		goto bad2;
 	}
 	/* Initializes the noise floor to a reasonable default value.
 	 * Later on this will be updated during ANI processing. */
 	sc->sc_ani.sc_noise_floor = ATH_DEFAULT_NOISE_FLOOR;
 	setup_timer(&sc->sc_ani.timer, ath_ani_calibrate, (unsigned long)sc);
 	if (ath9k_hw_getcapability(ah, ATH9K_CAP_CIPHER,
 				   ATH9K_CIPHER_TKIP, NULL)) {
 		/*
 		 * Whether we should enable h/w TKIP MIC.
 		 * XXX: if we don't support WME TKIP MIC, then we wouldn't
 		 * report WMM capable, so it's always safe to turn on
 		 * TKIP MIC in this case.
 		 */
 		ath9k_hw_setcapability(sc->sc_ah, ATH9K_CAP_TKIP_MIC,
 				       0, 1, NULL);
 	}
 	/*
 	 * Check whether the separate key cache entries
 	 * are required to handle both tx+rx MIC keys.
 	 * With split mic keys the number of stations is limited
 	 * to 27 otherwise 59.
 	 */
 	if (ath9k_hw_getcapability(ah, ATH9K_CAP_CIPHER,
 				   ATH9K_CIPHER_TKIP, NULL)
 	    && ath9k_hw_getcapability(ah, ATH9K_CAP_CIPHER,
 				      ATH9K_CIPHER_MIC, NULL)
 	    && ath9k_hw_getcapability(ah, ATH9K_CAP_TKIP_SPLIT,
 				      0, NULL))
 		sc->sc_splitmic = 1;
 	/* turn on mcast key search if possible */
 	if (!ath9k_hw_getcapability(ah, ATH9K_CAP_MCAST_KEYSRCH, 0, NULL))
 		(void)ath9k_hw_setcapability(ah, ATH9K_CAP_MCAST_KEYSRCH, 1,
 					     1, NULL);
 	sc->sc_config.txpowlimit = ATH_TXPOWER_MAX;
 	sc->sc_config.txpowlimit_override = 0;
 	/* 11n Capabilities */
 	if (ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT) {
 		sc->sc_flags |= SC_OP_TXAGGR;
 		sc->sc_flags |= SC_OP_RXAGGR;
 	}
 	sc->sc_tx_chainmask = ah->ah_caps.tx_chainmask;
 	sc->sc_rx_chainmask = ah->ah_caps.rx_chainmask;
 	ath9k_hw_setcapability(ah, ATH9K_CAP_DIVERSITY, 1, true, NULL);
 	sc->rx.defant = ath9k_hw_getdefantenna(ah);
 	ath9k_hw_getmac(ah, sc->sc_myaddr);
 	if (ah->ah_caps.hw_caps & ATH9K_HW_CAP_BSSIDMASK) {
 		ath9k_hw_getbssidmask(ah, sc->sc_bssidmask);
 		ATH_SET_VAP_BSSID_MASK(sc->sc_bssidmask);
 		ath9k_hw_setbssidmask(ah, sc->sc_bssidmask);
 	}
 	sc->beacon.slottime = ATH9K_SLOT_TIME_9;	/* default to short slot time */
 	/* initialize beacon slots */
 	for (i = 0; i < ARRAY_SIZE(sc->beacon.bslot); i++)
 		sc->beacon.bslot[i] = ATH_IF_ID_ANY;
 	/* save MISC configurations */
 	sc->sc_config.swBeaconProcess = 1;
 	/* setup channels and rates */
 	sc->sbands[IEEE80211_BAND_2GHZ].channels =
 		sc->channels[IEEE80211_BAND_2GHZ];
 	sc->sbands[IEEE80211_BAND_2GHZ].bitrates =
 		sc->rates[IEEE80211_BAND_2GHZ];
 	sc->sbands[IEEE80211_BAND_2GHZ].band = IEEE80211_BAND_2GHZ;
 	if (test_bit(ATH9K_MODE_11A, sc->sc_ah->ah_caps.wireless_modes)) {
 		sc->sbands[IEEE80211_BAND_5GHZ].channels =
 			sc->channels[IEEE80211_BAND_5GHZ];
 		sc->sbands[IEEE80211_BAND_5GHZ].bitrates =
 			sc->rates[IEEE80211_BAND_5GHZ];
 		sc->sbands[IEEE80211_BAND_5GHZ].band = IEEE80211_BAND_5GHZ;
 	}
 	return 0;
 bad2:
 	/* cleanup tx queues */
 	for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
 		if (ATH_TXQ_SETUP(sc, i))
 			ath_tx_cleanupq(sc, &sc->tx.txq[i]);
 bad:
 	if (ah)
 		ath9k_hw_detach(ah);
 	return error;
 }
 static int ath_attach(u16 devid, struct ath_softc *sc)
 {
 	struct ieee80211_hw *hw = sc->hw;
 	int error = 0;
 	DPRINTF(sc, ATH_DBG_CONFIG, "Attach ATH hw\n");
 	error = ath_init(devid, sc);
 	if (error != 0)
 		return error;
 	/* get mac address from hardware and set in mac80211 */
 	SET_IEEE80211_PERM_ADDR(hw, sc->sc_myaddr);
 	hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
 		IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
 		IEEE80211_HW_SIGNAL_DBM |
 		IEEE80211_HW_AMPDU_AGGREGATION;
 	hw->wiphy->interface_modes =
 		BIT(NL80211_IFTYPE_AP) |
 		BIT(NL80211_IFTYPE_STATION) |
 		BIT(NL80211_IFTYPE_ADHOC);
 	hw->queues = 4;
 	hw->max_rates = 4;
 	hw->max_rate_tries = ATH_11N_TXMAXTRY;
 	hw->sta_data_size = sizeof(struct ath_node);
 	hw->vif_data_size = sizeof(struct ath_vap);
 	/* Register rate control */
 	hw->rate_control_algorithm = "ath9k_rate_control";
 	error = ath_rate_control_register();
 	if (error != 0) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to register rate control algorithm: %d\n", error);
 		ath_rate_control_unregister();
 		goto bad;
 	}
 	if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT) {
 		setup_ht_cap(&sc->sbands[IEEE80211_BAND_2GHZ].ht_cap);
 		if (test_bit(ATH9K_MODE_11A, sc->sc_ah->ah_caps.wireless_modes))
 			setup_ht_cap(&sc->sbands[IEEE80211_BAND_5GHZ].ht_cap);
 	}
 	hw->wiphy->bands[IEEE80211_BAND_2GHZ] =	&sc->sbands[IEEE80211_BAND_2GHZ];
 	if (test_bit(ATH9K_MODE_11A, sc->sc_ah->ah_caps.wireless_modes))
 		hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
 			&sc->sbands[IEEE80211_BAND_5GHZ];
 	/* initialize tx/rx engine */
 	error = ath_tx_init(sc, ATH_TXBUF);
 	if (error != 0)
 		goto detach;
 	error = ath_rx_init(sc, ATH_RXBUF);
 	if (error != 0)
 		goto detach;
 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 	/* Initialze h/w Rfkill */
 	if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_RFSILENT)
 		INIT_DELAYED_WORK(&sc->rf_kill.rfkill_poll, ath_rfkill_poll);
 	/* Initialize s/w rfkill */
 	if (ath_init_sw_rfkill(sc))
 		goto detach;
 #endif
 	error = ieee80211_register_hw(hw);
 	if (error != 0) {
 		ath_rate_control_unregister();
 		goto bad;
 	}
 	/* Initialize LED control */
 	ath_init_leds(sc);
 	return 0;
 detach:
 	ath_detach(sc);
 bad:
 	return error;
 }
 int ath_reset(struct ath_softc *sc, bool retry_tx)
 {
 	struct ath_hal *ah = sc->sc_ah;
 	int status;
 	int error = 0;
 	ath9k_hw_set_interrupts(ah, 0);
 	ath_draintxq(sc, retry_tx);
 	ath_stoprecv(sc);
 	ath_flushrecv(sc);
 	spin_lock_bh(&sc->sc_resetlock);
 	if (!ath9k_hw_reset(ah, sc->sc_ah->ah_curchan,
 			    sc->tx_chan_width,
 			    sc->sc_tx_chainmask, sc->sc_rx_chainmask,
 			    sc->sc_ht_extprotspacing, false, &status)) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to reset hardware; hal status %u\n", status);
 		error = -EIO;
 	}
 	spin_unlock_bh(&sc->sc_resetlock);
 	if (ath_startrecv(sc) != 0)
 		DPRINTF(sc, ATH_DBG_FATAL, "Unable to start recv logic\n");
 	/*
 	 * We may be doing a reset in response to a request
 	 * that changes the channel so update any state that
 	 * might change as a result.
 	 */
 	ath_setcurmode(sc, ath_chan2mode(sc->sc_ah->ah_curchan));
 	ath_update_txpow(sc);
 	if (sc->sc_flags & SC_OP_BEACONS)
 		ath_beacon_config(sc, ATH_IF_ID_ANY);	/* restart beacons */
 	ath9k_hw_set_interrupts(ah, sc->sc_imask);
 	if (retry_tx) {
 		int i;
 		for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
 			if (ATH_TXQ_SETUP(sc, i)) {
 				spin_lock_bh(&sc->tx.txq[i].axq_lock);
 				ath_txq_schedule(sc, &sc->tx.txq[i]);
 				spin_unlock_bh(&sc->tx.txq[i].axq_lock);
 			}
 		}
 	}
 	return error;
 }
 /*
  *  This function will allocate both the DMA descriptor structure, and the
  *  buffers it contains.  These are used to contain the descriptors used
  *  by the system.
 */
 int ath_descdma_setup(struct ath_softc *sc, struct ath_descdma *dd,
 		      struct list_head *head, const char *name,
 		      int nbuf, int ndesc)
 {
 #define	DS2PHYS(_dd, _ds)						\
 	((_dd)->dd_desc_paddr + ((caddr_t)(_ds) - (caddr_t)(_dd)->dd_desc))
 #define ATH_DESC_4KB_BOUND_CHECK(_daddr) ((((_daddr) & 0xFFF) > 0xF7F) ? 1 : 0)
 #define ATH_DESC_4KB_BOUND_NUM_SKIPPED(_len) ((_len) / 4096)
 	struct ath_desc *ds;
 	struct ath_buf *bf;
 	int i, bsize, error;
 	DPRINTF(sc, ATH_DBG_CONFIG, "%s DMA: %u buffers %u desc/buf\n",
 		name, nbuf, ndesc);
 	/* ath_desc must be a multiple of DWORDs */
 	if ((sizeof(struct ath_desc) % 4) != 0) {
 		DPRINTF(sc, ATH_DBG_FATAL, "ath_desc not DWORD aligned\n");
 		ASSERT((sizeof(struct ath_desc) % 4) == 0);
 		error = -ENOMEM;
 		goto fail;
 	}
 	dd->dd_name = name;
 	dd->dd_desc_len = sizeof(struct ath_desc) * nbuf * ndesc;
 	/*
 	 * Need additional DMA memory because we can't use
 	 * descriptors that cross the 4K page boundary. Assume
 	 * one skipped descriptor per 4K page.
 	 */
 	if (!(sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_4KB_SPLITTRANS)) {
 		u32 ndesc_skipped =
 			ATH_DESC_4KB_BOUND_NUM_SKIPPED(dd->dd_desc_len);
 		u32 dma_len;
 		while (ndesc_skipped) {
 			dma_len = ndesc_skipped * sizeof(struct ath_desc);
 			dd->dd_desc_len += dma_len;
 			ndesc_skipped = ATH_DESC_4KB_BOUND_NUM_SKIPPED(dma_len);
 		};
 	}
 	/* allocate descriptors */
 	dd->dd_desc = pci_alloc_consistent(sc->pdev,
 			      dd->dd_desc_len,
 			      &dd->dd_desc_paddr);
 	if (dd->dd_desc == NULL) {
 		error = -ENOMEM;
 		goto fail;
 	}
 	ds = dd->dd_desc;
 	DPRINTF(sc, ATH_DBG_CONFIG, "%s DMA map: %p (%u) -> %llx (%u)\n",
 		dd->dd_name, ds, (u32) dd->dd_desc_len,
 		ito64(dd->dd_desc_paddr), /*XXX*/(u32) dd->dd_desc_len);
 	/* allocate buffers */
 	bsize = sizeof(struct ath_buf) * nbuf;
 	bf = kmalloc(bsize, GFP_KERNEL);
 	if (bf == NULL) {
 		error = -ENOMEM;
 		goto fail2;
 	}
 	memset(bf, 0, bsize);
 	dd->dd_bufptr = bf;
 	INIT_LIST_HEAD(head);
 	for (i = 0; i < nbuf; i++, bf++, ds += ndesc) {
 		bf->bf_desc = ds;
 		bf->bf_daddr = DS2PHYS(dd, ds);
 		if (!(sc->sc_ah->ah_caps.hw_caps &
 		      ATH9K_HW_CAP_4KB_SPLITTRANS)) {
 			/*
 			 * Skip descriptor addresses which can cause 4KB
 			 * boundary crossing (addr + length) with a 32 dword
 			 * descriptor fetch.
 			 */
 			while (ATH_DESC_4KB_BOUND_CHECK(bf->bf_daddr)) {
 				ASSERT((caddr_t) bf->bf_desc <
 				       ((caddr_t) dd->dd_desc +
 					dd->dd_desc_len));
 				ds += ndesc;
 				bf->bf_desc = ds;
 				bf->bf_daddr = DS2PHYS(dd, ds);
 			}
 		}
 		list_add_tail(&bf->list, head);
 	}
 	return 0;
 fail2:
 	pci_free_consistent(sc->pdev,
 		dd->dd_desc_len, dd->dd_desc, dd->dd_desc_paddr);
 fail:
 	memset(dd, 0, sizeof(*dd));
 	return error;
 #undef ATH_DESC_4KB_BOUND_CHECK
 #undef ATH_DESC_4KB_BOUND_NUM_SKIPPED
 #undef DS2PHYS
 }
 void ath_descdma_cleanup(struct ath_softc *sc,
 			 struct ath_descdma *dd,
 			 struct list_head *head)
 {
 	pci_free_consistent(sc->pdev,
 		dd->dd_desc_len, dd->dd_desc, dd->dd_desc_paddr);
 	INIT_LIST_HEAD(head);
 	kfree(dd->dd_bufptr);
 	memset(dd, 0, sizeof(*dd));
 }
 int ath_get_hal_qnum(u16 queue, struct ath_softc *sc)
 {
 	int qnum;
 	switch (queue) {
 	case 0:
 		qnum = sc->tx.hwq_map[ATH9K_WME_AC_VO];
 		break;
 	case 1:
 		qnum = sc->tx.hwq_map[ATH9K_WME_AC_VI];
 		break;
 	case 2:
 		qnum = sc->tx.hwq_map[ATH9K_WME_AC_BE];
 		break;
 	case 3:
 		qnum = sc->tx.hwq_map[ATH9K_WME_AC_BK];
 		break;
 	default:
 		qnum = sc->tx.hwq_map[ATH9K_WME_AC_BE];
 		break;
 	}
 	return qnum;
 }
 int ath_get_mac80211_qnum(u32 queue, struct ath_softc *sc)
 {
 	int qnum;
 	switch (queue) {
 	case ATH9K_WME_AC_VO:
 		qnum = 0;
 		break;
 	case ATH9K_WME_AC_VI:
 		qnum = 1;
 		break;
 	case ATH9K_WME_AC_BE:
 		qnum = 2;
 		break;
 	case ATH9K_WME_AC_BK:
 		qnum = 3;
 		break;
 	default:
 		qnum = -1;
 		break;
 	}
 	return qnum;
 }
 /**********************/
 /* mac80211 callbacks */
 /**********************/
 static int ath9k_start(struct ieee80211_hw *hw)
 {
 	struct ath_softc *sc = hw->priv;
 	struct ieee80211_channel *curchan = hw->conf.channel;
 	struct ath9k_channel *init_channel;
 	int error = 0, pos, status;
 	DPRINTF(sc, ATH_DBG_CONFIG, "Starting driver with "
 		"initial channel: %d MHz\n", curchan->center_freq);
 	/* setup initial channel */
 	pos = ath_get_channel(sc, curchan);
 	if (pos == -1) {
 		DPRINTF(sc, ATH_DBG_FATAL, "Invalid channel: %d\n", curchan->center_freq);
 		error = -EINVAL;
 		goto error;
 	}
 	sc->tx_chan_width = ATH9K_HT_MACMODE_20;
 	sc->sc_ah->ah_channels[pos].chanmode =
 		(curchan->band == IEEE80211_BAND_2GHZ) ? CHANNEL_G : CHANNEL_A;
 	init_channel = &sc->sc_ah->ah_channels[pos];
 	/* Reset SERDES registers */
 	ath9k_hw_configpcipowersave(sc->sc_ah, 0);
 	/*
 	 * 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.
 	 */
 	spin_lock_bh(&sc->sc_resetlock);
 	if (!ath9k_hw_reset(sc->sc_ah, init_channel,
 			    sc->tx_chan_width,
 			    sc->sc_tx_chainmask, sc->sc_rx_chainmask,
 			    sc->sc_ht_extprotspacing, false, &status)) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to reset hardware; hal status %u "
 			"(freq %u flags 0x%x)\n", status,
 			init_channel->channel, init_channel->channelFlags);
 		error = -EIO;
 		spin_unlock_bh(&sc->sc_resetlock);
 		goto error;
 	}
 	spin_unlock_bh(&sc->sc_resetlock);
 	/*
 	 * This is needed only to setup initial state
 	 * but it's best done after a reset.
 	 */
 	ath_update_txpow(sc);
 	/*
 	 * Setup the hardware after reset:
 	 * 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.
 	 */
 	if (ath_startrecv(sc) != 0) {
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Unable to start recv logic\n");
 		error = -EIO;
 		goto error;
 	}
 	/* Setup our intr mask. */
 	sc->sc_imask = ATH9K_INT_RX | ATH9K_INT_TX
 		| ATH9K_INT_RXEOL | ATH9K_INT_RXORN
 		| ATH9K_INT_FATAL | ATH9K_INT_GLOBAL;
 	if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_GTT)
 		sc->sc_imask |= ATH9K_INT_GTT;
 	if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT)
 		sc->sc_imask |= ATH9K_INT_CST;
 	/*
 	 * Enable MIB interrupts when there are hardware phy counters.
 	 * Note we only do this (at the moment) for station mode.
 	 */
 	if (ath9k_hw_phycounters(sc->sc_ah) &&
 	    ((sc->sc_ah->ah_opmode == NL80211_IFTYPE_STATION) ||
 	     (sc->sc_ah->ah_opmode == NL80211_IFTYPE_ADHOC)))
 		sc->sc_imask |= ATH9K_INT_MIB;
 	/*
 	 * Some hardware processes the TIM IE and fires an
 	 * interrupt when the TIM bit is set.  For hardware
 	 * that does, if not overridden by configuration,
 	 * enable the TIM interrupt when operating as station.
 	 */
 	if ((sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_ENHANCEDPM) &&
 	    (sc->sc_ah->ah_opmode == NL80211_IFTYPE_STATION) &&
 	    !sc->sc_config.swBeaconProcess)
 		sc->sc_imask |= ATH9K_INT_TIM;
 	ath_setcurmode(sc, ath_chan2mode(init_channel));
 	sc->sc_flags &= ~SC_OP_INVALID;
 	/* Disable BMISS interrupt when we're not associated */
 	sc->sc_imask &= ~(ATH9K_INT_SWBA | ATH9K_INT_BMISS);
 	ath9k_hw_set_interrupts(sc->sc_ah, sc->sc_imask);
 	ieee80211_wake_queues(sc->hw);
 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 	error = ath_start_rfkill_poll(sc);
 #endif
 error:
 	return error;
 }
 static int ath9k_tx(struct ieee80211_hw *hw,
 		    struct sk_buff *skb)
 {
 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 	struct ath_softc *sc = hw->priv;
 	struct ath_tx_control txctl;
 	int hdrlen, padsize;
 	memset(&txctl, 0, sizeof(struct ath_tx_control));
 	/*
 	 * As a temporary workaround, assign seq# here; this will likely need
 	 * to be cleaned up to work better with Beacon transmission and virtual
 	 * BSSes.
 	 */
 	if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
 		struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 		if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
 			sc->tx.seq_no += 0x10;
 		hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
 		hdr->seq_ctrl |= cpu_to_le16(sc->tx.seq_no);
 	}
 	/* Add the padding after the header if this is not already done */
 	hdrlen = ieee80211_get_hdrlen_from_skb(skb);
 	if (hdrlen & 3) {
 		padsize = hdrlen % 4;
 		if (skb_headroom(skb) < padsize)
 			return -1;
 		skb_push(skb, padsize);
 		memmove(skb->data, skb->data + padsize, hdrlen);
 	}
 	/* Check if a tx queue is available */
 	txctl.txq = ath_test_get_txq(sc, skb);
 	if (!txctl.txq)
 		goto exit;
 	DPRINTF(sc, ATH_DBG_XMIT, "transmitting packet, skb: %p\n", skb);
 	if (ath_tx_start(sc, skb, &txctl) != 0) {
 		DPRINTF(sc, ATH_DBG_XMIT, "TX failed\n");
 		goto exit;
 	}
 	return 0;
 exit:
 	dev_kfree_skb_any(skb);
 	return 0;
 }
 static void ath9k_stop(struct ieee80211_hw *hw)
 {
 	struct ath_softc *sc = hw->priv;
 	if (sc->sc_flags & SC_OP_INVALID) {
 		DPRINTF(sc, ATH_DBG_ANY, "Device not present\n");
 		return;
 	}
 	DPRINTF(sc, ATH_DBG_CONFIG, "Cleaning up\n");
 	ieee80211_stop_queues(sc->hw);
 	/* make sure h/w will not generate any interrupt
 	 * before setting the invalid flag. */
 	ath9k_hw_set_interrupts(sc->sc_ah, 0);
 	if (!(sc->sc_flags & SC_OP_INVALID)) {
 		ath_draintxq(sc, false);
 		ath_stoprecv(sc);
 		ath9k_hw_phy_disable(sc->sc_ah);
 	} else
 		sc->rx.rxlink = NULL;
 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 	if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_RFSILENT)
 		cancel_delayed_work_sync(&sc->rf_kill.rfkill_poll);
 #endif
 	/* disable HAL and put h/w to sleep */
 	ath9k_hw_disable(sc->sc_ah);
 	ath9k_hw_configpcipowersave(sc->sc_ah, 1);
 	sc->sc_flags |= SC_OP_INVALID;
 	DPRINTF(sc, ATH_DBG_CONFIG, "Driver halt\n");
 }
 static int ath9k_add_interface(struct ieee80211_hw *hw,
 			       struct ieee80211_if_init_conf *conf)
 {
 	struct ath_softc *sc = hw->priv;
 	struct ath_vap *avp = (void *)conf->vif->drv_priv;
 	enum nl80211_iftype ic_opmode = NL80211_IFTYPE_UNSPECIFIED;
 	/* Support only vap for now */
 	if (sc->sc_nvaps)
 		return -ENOBUFS;
 	switch (conf->type) {
 	case NL80211_IFTYPE_STATION:
 		ic_opmode = NL80211_IFTYPE_STATION;
 		break;
 	case NL80211_IFTYPE_ADHOC:
 		ic_opmode = NL80211_IFTYPE_ADHOC;
 		break;
 	case NL80211_IFTYPE_AP:
 		ic_opmode = NL80211_IFTYPE_AP;
 		break;
 	default:
 		DPRINTF(sc, ATH_DBG_FATAL,
 			"Interface type %d not yet supported\n", conf->type);
 		return -EOPNOTSUPP;
 	}
 	DPRINTF(sc, ATH_DBG_CONFIG, "Attach a VAP of type: %d\n", ic_opmode);
 	/* Set the VAP opmode */
 	avp->av_opmode = ic_opmode;
 	avp->av_bslot = -1;
 	if (ic_opmode == NL80211_IFTYPE_AP)
 		ath9k_hw_set_tsfadjust(sc->sc_ah, 1);
 	sc->sc_vaps[0] = conf->vif;
 	sc->sc_nvaps++;
 	/* Set the device opmode */
 	sc->sc_ah->ah_opmode = ic_opmode;
 	if (conf->type == NL80211_IFTYPE_AP) {
 		/* TODO: is this a suitable place to start ANI for AP mode? */
 		/* Start ANI */
 		mod_timer(&sc->sc_ani.timer,
 			  jiffies + msecs_to_jiffies(ATH_ANI_POLLINTERVAL));
 	}
 	return 0;
 }
 static void ath9k_remove_interface(struct ieee80211_hw *hw,
 				   struct ieee80211_if_init_conf *conf)
 {
 	struct ath_softc *sc = hw->priv;
 	struct ath_vap *avp = (void *)conf->vif->drv_priv;
 	DPRINTF(sc, ATH_DBG_CONFIG, "Detach Interface\n");
 	/* Stop ANI */
 	del_timer_sync(&sc->sc_ani.timer);
 	/* Reclaim beacon resources */
 	if (sc->sc_ah->ah_opmode == NL80211_IFTYPE_AP ||
 	    sc->sc_ah->ah_opmode == NL80211_IFTYPE_ADHOC) {
 		ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
 		ath_beacon_return(sc, avp);
 	}
 	sc->sc_flags &= ~SC_OP_BEACONS;
 	sc->sc_vaps[0] = NULL;
 	sc->sc_nvaps--;
 }
 static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
 {
 	struct ath_softc *sc = hw->priv;
 	struct ieee80211_conf *conf = &hw->conf;
-	if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
+	if (changed & (IEEE80211_CONF_CHANGE_CHANNEL |
+		       IEEE80211_CONF_CHANGE_HT)) {
 		struct ieee80211_channel *curchan = hw->conf.channel;
 		int pos;
 		DPRINTF(sc, ATH_DBG_CONFIG, "Set channel: %d MHz\n",
 			curchan->center_freq);
 		pos = ath_get_channel(sc, curchan);
 		if (pos == -1) {
 			DPRINTF(sc, ATH_DBG_FATAL, "Invalid channel: %d\n",
 				curchan->center_freq);
 			return -EINVAL;
 		}
 		sc->tx_chan_width = ATH9K_HT_MACMODE_20;
 		sc->sc_ah->ah_channels[pos].chanmode =
 			(curchan->band == IEEE80211_BAND_2GHZ) ?
 			CHANNEL_G : CHANNEL_A;
-		if ((sc->sc_ah->ah_opmode == NL80211_IFTYPE_AP) &&
+		if (conf->ht.enabled) {
-		    (conf->ht.enabled)) {
+			if (conf->ht.channel_type == NL80211_CHAN_HT40PLUS ||
-			sc->tx_chan_width = (!!conf->ht.sec_chan_offset) ?
+			    conf->ht.channel_type == NL80211_CHAN_HT40MINUS)
-				ATH9K_HT_MACMODE_2040 : ATH9K_HT_MACMODE_20;
+				sc->tx_chan_width = ATH9K_HT_MACMODE_2040;
 			sc->sc_ah->ah_channels[pos].chanmode =
 				ath_get_extchanmode(sc, curchan,
-						    conf->ht.sec_chan_offset,
+						    conf->ht.channel_type);
-						    sc->tx_chan_width);
 		}
 		if (ath_set_channel(sc, &sc->sc_ah->ah_channels[pos]) < 0) {
 			DPRINTF(sc, ATH_DBG_FATAL, "Unable to set channel\n");
 			return -EINVAL;
 		}
-	}
-	if (changed & IEEE80211_CONF_CHANGE_HT)
 		ath_update_chainmask(sc, conf->ht.enabled);
+	}
 	if (changed & IEEE80211_CONF_CHANGE_POWER)
 		sc->sc_config.txpowlimit = 2 * conf->power_level;
 	return 0;
 }
 static int ath9k_config_interface(struct ieee80211_hw *hw,
 				  struct ieee80211_vif *vif,
 				  struct ieee80211_if_conf *conf)
 {
 	struct ath_softc *sc = hw->priv;
 	struct ath_hal *ah = sc->sc_ah;
 	struct ath_vap *avp = (void *)vif->drv_priv;
 	u32 rfilt = 0;
 	int error, i;
 	/* TODO: Need to decide which hw opmode to use for multi-interface
 	 * cases */
 	if (vif->type == NL80211_IFTYPE_AP &&
 	    ah->ah_opmode != NL80211_IFTYPE_AP) {
 		ah->ah_opmode = NL80211_IFTYPE_STATION;
 		ath9k_hw_setopmode(ah);
 		ath9k_hw_write_associd(ah, sc->sc_myaddr, 0);
 		/* Request full reset to get hw opmode changed properly */
 		sc->sc_flags |= SC_OP_FULL_RESET;
 	}
 	if ((conf->changed & IEEE80211_IFCC_BSSID) &&
 	    !is_zero_ether_addr(conf->bssid)) {
 		switch (vif->type) {
 		case NL80211_IFTYPE_STATION:
 		case NL80211_IFTYPE_ADHOC:
 			/* Set BSSID */
 			memcpy(sc->sc_curbssid, conf->bssid, ETH_ALEN);
 			sc->sc_curaid = 0;
 			ath9k_hw_write_associd(sc->sc_ah, sc->sc_curbssid,
 					       sc->sc_curaid);
 			/* Set aggregation protection mode parameters */
 			sc->sc_config.ath_aggr_prot = 0;
 			DPRINTF(sc, ATH_DBG_CONFIG,
 				"RX filter 0x%x bssid %pM aid 0x%x\n",
 				rfilt, sc->sc_curbssid, sc->sc_curaid);
 			/* need to reconfigure the beacon */
 			sc->sc_flags &= ~SC_OP_BEACONS ;
 			break;
 		default:
 			break;
 		}
 	}
 	if ((conf->changed & IEEE80211_IFCC_BEACON) &&
 	    ((vif->type == NL80211_IFTYPE_ADHOC) ||
 	     (vif->type == NL80211_IFTYPE_AP))) {
 		/*
 		 * Allocate and setup the beacon frame.
 		 *
 		 * Stop any previous beacon DMA.  This may be
 		 * necessary, for example, when an ibss merge
 		 * causes reconfiguration; we may be called
 		 * with beacon transmission active.
 		 */
 		ath9k_hw_stoptxdma(sc->sc_ah, sc->beacon.beaconq);
 		error = ath_beacon_alloc(sc, 0);
 		if (error != 0)
 			return error;
 		ath_beacon_sync(sc, 0);
 	}
 	/* Check for WLAN_CAPABILITY_PRIVACY ? */
 	if ((avp->av_opmode != NL80211_IFTYPE_STATION)) {
 		for (i = 0; i < IEEE80211_WEP_NKID; i++)
 			if (ath9k_hw_keyisvalid(sc->sc_ah, (u16)i))
 				ath9k_hw_keysetmac(sc->sc_ah,
 						   (u16)i,
 						   sc->sc_curbssid);
 	}
 	/* Only legacy IBSS for now */
 	if (vif->type == NL80211_IFTYPE_ADHOC)
 		ath_update_chainmask(sc, 0);
 	return 0;
 }
 #define SUPPORTED_FILTERS			\
 	(FIF_PROMISC_IN_BSS |			\
 	FIF_ALLMULTI |				\
 	FIF_CONTROL |				\
 	FIF_OTHER_BSS |				\
 	FIF_BCN_PRBRESP_PROMISC |		\
 	FIF_FCSFAIL)
 /* FIXME: sc->sc_full_reset ? */
 static void ath9k_configure_filter(struct ieee80211_hw *hw,
 				   unsigned int changed_flags,
 				   unsigned int *total_flags,
 				   int mc_count,
 				   struct dev_mc_list *mclist)
 {
 	struct ath_softc *sc = hw->priv;
 	u32 rfilt;
 	changed_flags &= SUPPORTED_FILTERS;
 	*total_flags &= SUPPORTED_FILTERS;
 	sc->rx.rxfilter = *total_flags;
 	rfilt = ath_calcrxfilter(sc);
 	ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
 	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
 		if (*total_flags & FIF_BCN_PRBRESP_PROMISC)
 			ath9k_hw_write_associd(sc->sc_ah, ath_bcast_mac, 0);
 	}
 	DPRINTF(sc, ATH_DBG_CONFIG, "Set HW RX filter: 0x%x\n", sc->rx.rxfilter);
 }
 static void ath9k_sta_notify(struct ieee80211_hw *hw,
 			     struct ieee80211_vif *vif,
 			     enum sta_notify_cmd cmd,
 			     struct ieee80211_sta *sta)
 {
 	struct ath_softc *sc = hw->priv;
 	switch (cmd) {
 	case STA_NOTIFY_ADD:
 		ath_node_attach(sc, sta);
 		break;
 	case STA_NOTIFY_REMOVE:
 		ath_node_detach(sc, sta);
 		break;
 	default:
 		break;
 	}
 }
 static int ath9k_conf_tx(struct ieee80211_hw *hw,
 			 u16 queue,
 			 const struct ieee80211_tx_queue_params *params)
 {
 	struct ath_softc *sc = hw->priv;
 	struct ath9k_tx_queue_info qi;
 	int ret = 0, qnum;
 	if (queue >= WME_NUM_AC)
 		return 0;
 	qi.tqi_aifs = params->aifs;
 	qi.tqi_cwmin = params->cw_min;
 	qi.tqi_cwmax = params->cw_max;
 	qi.tqi_burstTime = params->txop;
 	qnum = ath_get_hal_qnum(queue, sc);
 	DPRINTF(sc, ATH_DBG_CONFIG,
 		"Configure tx [queue/halq] [%d/%d],  "
 		"aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
 		queue, qnum, params->aifs, params->cw_min,
 		params->cw_max, params->txop);
 	ret = ath_txq_update(sc, qnum, &qi);
 	if (ret)
 		DPRINTF(sc, ATH_DBG_FATAL, "TXQ Update failed\n");
 	return ret;
 }
 static int ath9k_set_key(struct ieee80211_hw *hw,
 			 enum set_key_cmd cmd,
 			 const u8 *local_addr,
 			 const u8 *addr,
 			 struct ieee80211_key_conf *key)
 {
 	struct ath_softc *sc = hw->priv;
 	int ret = 0;
 	DPRINTF(sc, ATH_DBG_KEYCACHE, "Set HW Key\n");
 	switch (cmd) {
 	case SET_KEY:
 		ret = ath_key_config(sc, addr, key);
 		if (!ret) {
 			set_bit(key->keyidx, sc->sc_keymap);
 			key->hw_key_idx = key->keyidx;
 			/* push IV and Michael MIC generation to stack */
 			key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
 			if (key->alg == ALG_TKIP)
 				key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
 		}
 		break;
 	case DISABLE_KEY:
 		ath_key_delete(sc, key);
 		clear_bit(key->keyidx, sc->sc_keymap);
 		break;
 	default:
 		ret = -EINVAL;
 	}
 	return ret;
 }
 static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
 				   struct ieee80211_vif *vif,
 				   struct ieee80211_bss_conf *bss_conf,
 				   u32 changed)
 {
 	struct ath_softc *sc = hw->priv;
 	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
 		DPRINTF(sc, ATH_DBG_CONFIG, "BSS Changed PREAMBLE %d\n",
 			bss_conf->use_short_preamble);
 		if (bss_conf->use_short_preamble)
 			sc->sc_flags |= SC_OP_PREAMBLE_SHORT;
 		else
 			sc->sc_flags &= ~SC_OP_PREAMBLE_SHORT;
 	}
 	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
 		DPRINTF(sc, ATH_DBG_CONFIG, "BSS Changed CTS PROT %d\n",
 			bss_conf->use_cts_prot);
 		if (bss_conf->use_cts_prot &&
 		    hw->conf.channel->band != IEEE80211_BAND_5GHZ)
 			sc->sc_flags |= SC_OP_PROTECT_ENABLE;
 		else
 			sc->sc_flags &= ~SC_OP_PROTECT_ENABLE;
 	}
-	if (changed & BSS_CHANGED_HT)
-		ath9k_ht_conf(sc, bss_conf);
 	if (changed & BSS_CHANGED_ASSOC) {
 		DPRINTF(sc, ATH_DBG_CONFIG, "BSS Changed ASSOC %d\n",
 			bss_conf->assoc);
 		ath9k_bss_assoc_info(sc, vif, bss_conf);
 	}
 }
 static u64 ath9k_get_tsf(struct ieee80211_hw *hw)
 {
 	u64 tsf;
 	struct ath_softc *sc = hw->priv;
 	struct ath_hal *ah = sc->sc_ah;
 	tsf = ath9k_hw_gettsf64(ah);
 	return tsf;
 }
 static void ath9k_reset_tsf(struct ieee80211_hw *hw)
 {
 	struct ath_softc *sc = hw->priv;
 	struct ath_hal *ah = sc->sc_ah;
 	ath9k_hw_reset_tsf(ah);
 }
 static int ath9k_ampdu_action(struct ieee80211_hw *hw,
 		       enum ieee80211_ampdu_mlme_action action,
 		       struct ieee80211_sta *sta,
 		       u16 tid, u16 *ssn)
 {
 	struct ath_softc *sc = hw->priv;
 	int ret = 0;
 	switch (action) {
 	case IEEE80211_AMPDU_RX_START:
 		if (!(sc->sc_flags & SC_OP_RXAGGR))
 			ret = -ENOTSUPP;
 		break;
 	case IEEE80211_AMPDU_RX_STOP:
 		break;
 	case IEEE80211_AMPDU_TX_START:
 		ret = ath_tx_aggr_start(sc, sta, tid, ssn);
 		if (ret < 0)
 			DPRINTF(sc, ATH_DBG_FATAL,
 				"Unable to start TX aggregation\n");
 		else
 			ieee80211_start_tx_ba_cb_irqsafe(hw, sta->addr, tid);
 		break;
 	case IEEE80211_AMPDU_TX_STOP:
 		ret = ath_tx_aggr_stop(sc, sta, tid);
 		if (ret < 0)
 			DPRINTF(sc, ATH_DBG_FATAL,
 				"Unable to stop TX aggregation\n");
 		ieee80211_stop_tx_ba_cb_irqsafe(hw, sta->addr, tid);
 		break;
 	case IEEE80211_AMPDU_TX_RESUME:
 		ath_tx_aggr_resume(sc, sta, tid);
 		break;
 	default:
 		DPRINTF(sc, ATH_DBG_FATAL, "Unknown AMPDU action\n");
 	}
 	return ret;
 }
 static struct ieee80211_ops ath9k_ops = {
 	.tx 		    = ath9k_tx,
 	.start 		    = ath9k_start,
 	.stop 		    = ath9k_stop,
 	.add_interface 	    = ath9k_add_interface,
 	.remove_interface   = ath9k_remove_interface,
 	.config 	    = ath9k_config,
 	.config_interface   = ath9k_config_interface,
 	.configure_filter   = ath9k_configure_filter,
 	.sta_notify         = ath9k_sta_notify,
 	.conf_tx 	    = ath9k_conf_tx,
 	.bss_info_changed   = ath9k_bss_info_changed,
 	.set_key            = ath9k_set_key,
 	.get_tsf 	    = ath9k_get_tsf,
 	.reset_tsf 	    = ath9k_reset_tsf,
 	.ampdu_action       = ath9k_ampdu_action,
 };
 static struct {
 	u32 version;
 	const char * name;
 } ath_mac_bb_names[] = {
 	{ AR_SREV_VERSION_5416_PCI,	"5416" },
 	{ AR_SREV_VERSION_5416_PCIE,	"5418" },
 	{ AR_SREV_VERSION_9100,		"9100" },
 	{ AR_SREV_VERSION_9160,		"9160" },
 	{ AR_SREV_VERSION_9280,		"9280" },
 	{ AR_SREV_VERSION_9285,		"9285" }
 };
 static struct {
 	u16 version;
 	const char * name;
 } ath_rf_names[] = {
 	{ 0,				"5133" },
 	{ AR_RAD5133_SREV_MAJOR,	"5133" },
 	{ AR_RAD5122_SREV_MAJOR,	"5122" },
 	{ AR_RAD2133_SREV_MAJOR,	"2133" },
 	{ AR_RAD2122_SREV_MAJOR,	"2122" }
 };
 /*
  * Return the MAC/BB name. "????" is returned if the MAC/BB is unknown.
  */
 static const char *
 ath_mac_bb_name(u32 mac_bb_version)
 {
 	int i;
 	for (i=0; i<ARRAY_SIZE(ath_mac_bb_names); i++) {
 		if (ath_mac_bb_names[i].version == mac_bb_version) {
 			return ath_mac_bb_names[i].name;
 		}
 	}
 	return "????";
 }
 /*
  * Return the RF name. "????" is returned if the RF is unknown.
  */
 static const char *
 ath_rf_name(u16 rf_version)
 {
 	int i;
 	for (i=0; i<ARRAY_SIZE(ath_rf_names); i++) {
 		if (ath_rf_names[i].version == rf_version) {
 			return ath_rf_names[i].name;
 		}
 	}
 	return "????";
 }
 static int ath_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 {
 	void __iomem *mem;
 	struct ath_softc *sc;
 	struct ieee80211_hw *hw;
 	u8 csz;
 	u32 val;
 	int ret = 0;
 	struct ath_hal *ah;
 	if (pci_enable_device(pdev))
 		return -EIO;
 	ret =  pci_set_dma_mask(pdev, DMA_32BIT_MASK);
 	if (ret) {
 		printk(KERN_ERR "ath9k: 32-bit DMA not available\n");
 		goto bad;
 	}
 	ret = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
 	if (ret) {
 		printk(KERN_ERR "ath9k: 32-bit DMA consistent "
 			"DMA enable failed\n");
 		goto bad;
 	}
 	/*
 	 * Cache line size is used to size and align various
 	 * structures used to communicate with the hardware.
 	 */
 	pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &csz);
 	if (csz == 0) {
 		/*
 		 * Linux 2.4.18 (at least) writes the cache line size
 		 * register as a 16-bit wide register which is wrong.
 		 * We must have this setup properly for rx buffer
 		 * DMA to work so force a reasonable value here if it
 		 * comes up zero.
 		 */
 		csz = L1_CACHE_BYTES / sizeof(u32);
 		pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE, csz);
 	}
 	/*
 	 * The default setting of latency timer yields poor results,
 	 * set it to the value used by other systems. It may be worth
 	 * tweaking this setting more.
 	 */
 	pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0xa8);
 	pci_set_master(pdev);
 	/*
 	 * Disable the RETRY_TIMEOUT register (0x41) to keep
 	 * PCI Tx retries from interfering with C3 CPU state.
 	 */
 	pci_read_config_dword(pdev, 0x40, &val);
 	if ((val & 0x0000ff00) != 0)
 		pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
 	ret = pci_request_region(pdev, 0, "ath9k");
 	if (ret) {
 		dev_err(&pdev->dev, "PCI memory region reserve error\n");
 		ret = -ENODEV;
 		goto bad;
 	}
 	mem = pci_iomap(pdev, 0, 0);
 	if (!mem) {
 		printk(KERN_ERR "PCI memory map error\n") ;
 		ret = -EIO;
 		goto bad1;
 	}
 	hw = ieee80211_alloc_hw(sizeof(struct ath_softc), &ath9k_ops);
 	if (hw == NULL) {
 		printk(KERN_ERR "ath_pci: no memory for ieee80211_hw\n");
 		goto bad2;
 	}
 	SET_IEEE80211_DEV(hw, &pdev->dev);
 	pci_set_drvdata(pdev, hw);
 	sc = hw->priv;
 	sc->hw = hw;
 	sc->pdev = pdev;
 	sc->mem = mem;
 	if (ath_attach(id->device, sc) != 0) {
 		ret = -ENODEV;
 		goto bad3;
 	}
 	/* setup interrupt service routine */
 	if (request_irq(pdev->irq, ath_isr, IRQF_SHARED, "ath", sc)) {
 		printk(KERN_ERR "%s: request_irq failed\n",
 			wiphy_name(hw->wiphy));
 		ret = -EIO;
 		goto bad4;
 	}
 	ah = sc->sc_ah;
 	printk(KERN_INFO
 	       "%s: Atheros AR%s MAC/BB Rev:%x "
 	       "AR%s RF Rev:%x: mem=0x%lx, irq=%d\n",
 	       wiphy_name(hw->wiphy),
 	       ath_mac_bb_name(ah->ah_macVersion),
 	       ah->ah_macRev,
 	       ath_rf_name((ah->ah_analog5GhzRev & AR_RADIO_SREV_MAJOR)),
 	       ah->ah_phyRev,
 	       (unsigned long)mem, pdev->irq);
 	return 0;
 bad4:
 	ath_detach(sc);
 bad3:
 	ieee80211_free_hw(hw);
 bad2:
 	pci_iounmap(pdev, mem);
 bad1:
 	pci_release_region(pdev, 0);
 bad:
 	pci_disable_device(pdev);
 	return ret;
 }
 static void ath_pci_remove(struct pci_dev *pdev)
 {
 	struct ieee80211_hw *hw = pci_get_drvdata(pdev);
 	struct ath_softc *sc = hw->priv;
 	ath_detach(sc);
 	if (pdev->irq)
 		free_irq(pdev->irq, sc);
 	pci_iounmap(pdev, sc->mem);
 	pci_release_region(pdev, 0);
 	pci_disable_device(pdev);
 	ieee80211_free_hw(hw);
 }
 #ifdef CONFIG_PM
 static int ath_pci_suspend(struct pci_dev *pdev, pm_message_t state)
 {
 	struct ieee80211_hw *hw = pci_get_drvdata(pdev);
 	struct ath_softc *sc = hw->priv;
 	ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN, 1);
 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 	if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_RFSILENT)
 		cancel_delayed_work_sync(&sc->rf_kill.rfkill_poll);
 #endif
 	pci_save_state(pdev);
 	pci_disable_device(pdev);
 	pci_set_power_state(pdev, 3);
 	return 0;
 }
 static int ath_pci_resume(struct pci_dev *pdev)
 {
 	struct ieee80211_hw *hw = pci_get_drvdata(pdev);
 	struct ath_softc *sc = hw->priv;
 	u32 val;
 	int err;
 	err = pci_enable_device(pdev);
 	if (err)
 		return err;
 	pci_restore_state(pdev);
 	/*
 	 * Suspend/Resume resets the PCI configuration space, so we have to
 	 * re-disable the RETRY_TIMEOUT register (0x41) to keep
 	 * PCI Tx retries from interfering with C3 CPU state
 	 */
 	pci_read_config_dword(pdev, 0x40, &val);
 	if ((val & 0x0000ff00) != 0)
 		pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
 	/* Enable LED */
 	ath9k_hw_cfg_output(sc->sc_ah, ATH_LED_PIN,
 			    AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
 	ath9k_hw_set_gpio(sc->sc_ah, ATH_LED_PIN, 1);
 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 	/*
 	 * check the h/w rfkill state on resume
 	 * and start the rfkill poll timer
 	 */
 	if (sc->sc_ah->ah_caps.hw_caps & ATH9K_HW_CAP_RFSILENT)
 		queue_delayed_work(sc->hw->workqueue,
 				   &sc->rf_kill.rfkill_poll, 0);
 #endif
 	return 0;
 }
 #endif /* CONFIG_PM */
 MODULE_DEVICE_TABLE(pci, ath_pci_id_table);
 static struct pci_driver ath_pci_driver = {
 	.name       = "ath9k",
 	.id_table   = ath_pci_id_table,
 	.probe      = ath_pci_probe,
 	.remove     = ath_pci_remove,
 #ifdef CONFIG_PM
 	.suspend    = ath_pci_suspend,
 	.resume     = ath_pci_resume,
 #endif /* CONFIG_PM */
 };
 static int __init init_ath_pci(void)
 {
 	printk(KERN_INFO "%s: %s\n", dev_info, ATH_PCI_VERSION);
 	if (pci_register_driver(&ath_pci_driver) < 0) {
 		printk(KERN_ERR
 			"ath_pci: No devices found, driver not installed.\n");
 		pci_unregister_driver(&ath_pci_driver);
 		return -ENODEV;
 	}
 	return 0;
 }

drivers/net/wireless/iwlwifi/iwl-agn.c

Diff comments View file @ 094d05d

 /******************************************************************************
  *
  * Copyright(c) 2003 - 2008 Intel Corporation. All rights reserved.
  *
  * Portions of this file are derived from the ipw3945 project, as well
  * as portions of the ieee80211 subsystem header files.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  * more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program; if not, write to the Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  *
  * The full GNU General Public License is included in this distribution in the
  * file called LICENSE.
  *
  * Contact Information:
  *  Intel Linux Wireless <ilw@linux.intel.com>
  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  *
  *****************************************************************************/
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/dma-mapping.h>
 #include <linux/delay.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/wireless.h>
 #include <linux/firmware.h>
 #include <linux/etherdevice.h>
 #include <linux/if_arp.h>
 #include <net/mac80211.h>
 #include <asm/div64.h>
 #include "iwl-eeprom.h"
 #include "iwl-dev.h"
 #include "iwl-core.h"
 #include "iwl-io.h"
 #include "iwl-helpers.h"
 #include "iwl-sta.h"
 #include "iwl-calib.h"
 /******************************************************************************
  *
  * module boiler plate
  *
  ******************************************************************************/
 /*
  * module name, copyright, version, etc.
  * NOTE: DRV_NAME is defined in iwlwifi.h for use by iwl-debug.h and printk
  */
 #define DRV_DESCRIPTION	"Intel(R) Wireless WiFi Link AGN driver for Linux"
 #ifdef CONFIG_IWLWIFI_DEBUG
 #define VD "d"
 #else
 #define VD
 #endif
 #ifdef CONFIG_IWLAGN_SPECTRUM_MEASUREMENT
 #define VS "s"
 #else
 #define VS
 #endif
 #define DRV_VERSION     IWLWIFI_VERSION VD VS
 MODULE_DESCRIPTION(DRV_DESCRIPTION);
 MODULE_VERSION(DRV_VERSION);
 MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("iwl4965");
 /*************** STATION TABLE MANAGEMENT ****
  * mac80211 should be examined to determine if sta_info is duplicating
  * the functionality provided here
  */
 /**************************************************************/
 static void iwl_set_rxon_hwcrypto(struct iwl_priv *priv, int hw_decrypt)
 {
 	struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
 	if (hw_decrypt)
 		rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK;
 	else
 		rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;
 }
 /**
  * iwl_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
  * @priv: staging_rxon is compared to active_rxon
  *
  * If the RXON structure is changing enough to require a new tune,
  * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
  * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
  */
 static int iwl_full_rxon_required(struct iwl_priv *priv)
 {
 	/* These items are only settable from the full RXON command */
 	if (!(iwl_is_associated(priv)) ||
 	    compare_ether_addr(priv->staging_rxon.bssid_addr,
 			       priv->active_rxon.bssid_addr) ||
 	    compare_ether_addr(priv->staging_rxon.node_addr,
 			       priv->active_rxon.node_addr) ||
 	    compare_ether_addr(priv->staging_rxon.wlap_bssid_addr,
 			       priv->active_rxon.wlap_bssid_addr) ||
 	    (priv->staging_rxon.dev_type != priv->active_rxon.dev_type) ||
 	    (priv->staging_rxon.channel != priv->active_rxon.channel) ||
 	    (priv->staging_rxon.air_propagation !=
 	     priv->active_rxon.air_propagation) ||
 	    (priv->staging_rxon.ofdm_ht_single_stream_basic_rates !=
 	     priv->active_rxon.ofdm_ht_single_stream_basic_rates) ||
 	    (priv->staging_rxon.ofdm_ht_dual_stream_basic_rates !=
 	     priv->active_rxon.ofdm_ht_dual_stream_basic_rates) ||
 	    (priv->staging_rxon.assoc_id != priv->active_rxon.assoc_id))
 		return 1;
 	/* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
 	 * be updated with the RXON_ASSOC command -- however only some
 	 * flag transitions are allowed using RXON_ASSOC */
 	/* Check if we are not switching bands */
 	if ((priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) !=
 	    (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK))
 		return 1;
 	/* Check if we are switching association toggle */
 	if ((priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) !=
 		(priv->active_rxon.filter_flags & RXON_FILTER_ASSOC_MSK))
 		return 1;
 	return 0;
 }
 /**
  * iwl_commit_rxon - commit staging_rxon to hardware
  *
  * The RXON command in staging_rxon is committed to the hardware and
  * the active_rxon structure is updated with the new data.  This
  * function correctly transitions out of the RXON_ASSOC_MSK state if
  * a HW tune is required based on the RXON structure changes.
  */
 static int iwl_commit_rxon(struct iwl_priv *priv)
 {
 	/* cast away the const for active_rxon in this function */
 	struct iwl_rxon_cmd *active_rxon = (void *)&priv->active_rxon;
 	int ret;
 	bool new_assoc =
 		!!(priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK);
 	if (!iwl_is_alive(priv))
 		return -EBUSY;
 	/* always get timestamp with Rx frame */
 	priv->staging_rxon.flags |= RXON_FLG_TSF2HOST_MSK;
 	/* allow CTS-to-self if possible. this is relevant only for
 	 * 5000, but will not damage 4965 */
 	priv->staging_rxon.flags |= RXON_FLG_SELF_CTS_EN;
 	ret = iwl_agn_check_rxon_cmd(&priv->staging_rxon);
 	if (ret) {
 		IWL_ERROR("Invalid RXON configuration.  Not committing.\n");
 		return -EINVAL;
 	}
 	/* If we don't need to send a full RXON, we can use
 	 * iwl_rxon_assoc_cmd which is used to reconfigure filter
 	 * and other flags for the current radio configuration. */
 	if (!iwl_full_rxon_required(priv)) {
 		ret = iwl_send_rxon_assoc(priv);
 		if (ret) {
 			IWL_ERROR("Error setting RXON_ASSOC (%d)\n", ret);
 			return ret;
 		}
 		memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));
 		return 0;
 	}
 	/* station table will be cleared */
 	priv->assoc_station_added = 0;
 	/* If we are currently associated and the new config requires
 	 * an RXON_ASSOC and the new config wants the associated mask enabled,
 	 * we must clear the associated from the active configuration
 	 * before we apply the new config */
 	if (iwl_is_associated(priv) && new_assoc) {
 		IWL_DEBUG_INFO("Toggling associated bit on current RXON\n");
 		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 		ret = iwl_send_cmd_pdu(priv, REPLY_RXON,
 				      sizeof(struct iwl_rxon_cmd),
 				      &priv->active_rxon);
 		/* If the mask clearing failed then we set
 		 * active_rxon back to what it was previously */
 		if (ret) {
 			active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
 			IWL_ERROR("Error clearing ASSOC_MSK (%d)\n", ret);
 			return ret;
 		}
 	}
 	IWL_DEBUG_INFO("Sending RXON\n"
 		       "* with%s RXON_FILTER_ASSOC_MSK\n"
 		       "* channel = %d\n"
 		       "* bssid = %pM\n",
 		       (new_assoc ? "" : "out"),
 		       le16_to_cpu(priv->staging_rxon.channel),
 		       priv->staging_rxon.bssid_addr);
 	iwl_set_rxon_hwcrypto(priv, !priv->hw_params.sw_crypto);
 	/* Apply the new configuration
 	 * RXON unassoc clears the station table in uCode, send it before
 	 * we add the bcast station. If assoc bit is set, we will send RXON
 	 * after having added the bcast and bssid station.
 	 */
 	if (!new_assoc) {
 		ret = iwl_send_cmd_pdu(priv, REPLY_RXON,
 			      sizeof(struct iwl_rxon_cmd), &priv->staging_rxon);
 		if (ret) {
 			IWL_ERROR("Error setting new RXON (%d)\n", ret);
 			return ret;
 		}
 		memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));
 	}
 	iwl_clear_stations_table(priv);
 	if (!priv->error_recovering)
 		priv->start_calib = 0;
 	/* Add the broadcast address so we can send broadcast frames */
 	if (iwl_rxon_add_station(priv, iwl_bcast_addr, 0) ==
 						IWL_INVALID_STATION) {
 		IWL_ERROR("Error adding BROADCAST address for transmit.\n");
 		return -EIO;
 	}
 	/* If we have set the ASSOC_MSK and we are in BSS mode then
 	 * add the IWL_AP_ID to the station rate table */
 	if (new_assoc) {
 		if (priv->iw_mode == NL80211_IFTYPE_STATION) {
 			ret = iwl_rxon_add_station(priv,
 					   priv->active_rxon.bssid_addr, 1);
 			if (ret == IWL_INVALID_STATION) {
 				IWL_ERROR("Error adding AP address for TX.\n");
 				return -EIO;
 			}
 			priv->assoc_station_added = 1;
 			if (priv->default_wep_key &&
 			    iwl_send_static_wepkey_cmd(priv, 0))
 				IWL_ERROR("Could not send WEP static key.\n");
 		}
 		/* Apply the new configuration
 		 * RXON assoc doesn't clear the station table in uCode,
 		 */
 		ret = iwl_send_cmd_pdu(priv, REPLY_RXON,
 			      sizeof(struct iwl_rxon_cmd), &priv->staging_rxon);
 		if (ret) {
 			IWL_ERROR("Error setting new RXON (%d)\n", ret);
 			return ret;
 		}
 		memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));
 	}
 	iwl_init_sensitivity(priv);
 	/* If we issue a new RXON command which required a tune then we must
 	 * send a new TXPOWER command or we won't be able to Tx any frames */
 	ret = iwl_set_tx_power(priv, priv->tx_power_user_lmt, true);
 	if (ret) {
 		IWL_ERROR("Error sending TX power (%d)\n", ret);
 		return ret;
 	}
 	return 0;
 }
 void iwl_update_chain_flags(struct iwl_priv *priv)
 {
 	iwl_set_rxon_chain(priv);
 	iwl_commit_rxon(priv);
 }
 static int iwl_send_bt_config(struct iwl_priv *priv)
 {
 	struct iwl_bt_cmd bt_cmd = {
 		.flags = 3,
 		.lead_time = 0xAA,
 		.max_kill = 1,
 		.kill_ack_mask = 0,
 		.kill_cts_mask = 0,
 	};
 	return iwl_send_cmd_pdu(priv, REPLY_BT_CONFIG,
 				sizeof(struct iwl_bt_cmd), &bt_cmd);
 }
 static void iwl_clear_free_frames(struct iwl_priv *priv)
 {
 	struct list_head *element;
 	IWL_DEBUG_INFO("%d frames on pre-allocated heap on clear.\n",
 		       priv->frames_count);
 	while (!list_empty(&priv->free_frames)) {
 		element = priv->free_frames.next;
 		list_del(element);
 		kfree(list_entry(element, struct iwl_frame, list));
 		priv->frames_count--;
 	}
 	if (priv->frames_count) {
 		IWL_WARNING("%d frames still in use.  Did we lose one?\n",
 			    priv->frames_count);
 		priv->frames_count = 0;
 	}
 }
 static struct iwl_frame *iwl_get_free_frame(struct iwl_priv *priv)
 {
 	struct iwl_frame *frame;
 	struct list_head *element;
 	if (list_empty(&priv->free_frames)) {
 		frame = kzalloc(sizeof(*frame), GFP_KERNEL);
 		if (!frame) {
 			IWL_ERROR("Could not allocate frame!\n");
 			return NULL;
 		}
 		priv->frames_count++;
 		return frame;
 	}
 	element = priv->free_frames.next;
 	list_del(element);
 	return list_entry(element, struct iwl_frame, list);
 }
 static void iwl_free_frame(struct iwl_priv *priv, struct iwl_frame *frame)
 {
 	memset(frame, 0, sizeof(*frame));
 	list_add(&frame->list, &priv->free_frames);
 }
 static unsigned int iwl_fill_beacon_frame(struct iwl_priv *priv,
 					  struct ieee80211_hdr *hdr,
 					  const u8 *dest, int left)
 {
 	if (!iwl_is_associated(priv) || !priv->ibss_beacon ||
 	    ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
 	     (priv->iw_mode != NL80211_IFTYPE_AP)))
 		return 0;
 	if (priv->ibss_beacon->len > left)
 		return 0;
 	memcpy(hdr, priv->ibss_beacon->data, priv->ibss_beacon->len);
 	return priv->ibss_beacon->len;
 }
 static u8 iwl_rate_get_lowest_plcp(struct iwl_priv *priv)
 {
 	int i;
 	int rate_mask;
 	/* Set rate mask*/
 	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
 		rate_mask = priv->active_rate_basic & IWL_CCK_RATES_MASK;
 	else
 		rate_mask = priv->active_rate_basic & IWL_OFDM_RATES_MASK;
 	/* Find lowest valid rate */
 	for (i = IWL_RATE_1M_INDEX; i != IWL_RATE_INVALID;
 					i = iwl_rates[i].next_ieee) {
 		if (rate_mask & (1 << i))
 			return iwl_rates[i].plcp;
 	}
 	/* No valid rate was found. Assign the lowest one */
 	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
 		return IWL_RATE_1M_PLCP;
 	else
 		return IWL_RATE_6M_PLCP;
 }
 static unsigned int iwl_hw_get_beacon_cmd(struct iwl_priv *priv,
 				       struct iwl_frame *frame, u8 rate)
 {
 	struct iwl_tx_beacon_cmd *tx_beacon_cmd;
 	unsigned int frame_size;
 	tx_beacon_cmd = &frame->u.beacon;
 	memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));
 	tx_beacon_cmd->tx.sta_id = priv->hw_params.bcast_sta_id;
 	tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
 	frame_size = iwl_fill_beacon_frame(priv, tx_beacon_cmd->frame,
 				iwl_bcast_addr,
 				sizeof(frame->u) - sizeof(*tx_beacon_cmd));
 	BUG_ON(frame_size > MAX_MPDU_SIZE);
 	tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
 	if ((rate == IWL_RATE_1M_PLCP) || (rate >= IWL_RATE_2M_PLCP))
 		tx_beacon_cmd->tx.rate_n_flags =
 			iwl_hw_set_rate_n_flags(rate, RATE_MCS_CCK_MSK);
 	else
 		tx_beacon_cmd->tx.rate_n_flags =
 			iwl_hw_set_rate_n_flags(rate, 0);
 	tx_beacon_cmd->tx.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK |
 				     TX_CMD_FLG_TSF_MSK |
 				     TX_CMD_FLG_STA_RATE_MSK;
 	return sizeof(*tx_beacon_cmd) + frame_size;
 }
 static int iwl_send_beacon_cmd(struct iwl_priv *priv)
 {
 	struct iwl_frame *frame;
 	unsigned int frame_size;
 	int rc;
 	u8 rate;
 	frame = iwl_get_free_frame(priv);
 	if (!frame) {
 		IWL_ERROR("Could not obtain free frame buffer for beacon "
 			  "command.\n");
 		return -ENOMEM;
 	}
 	rate = iwl_rate_get_lowest_plcp(priv);
 	frame_size = iwl_hw_get_beacon_cmd(priv, frame, rate);
 	rc = iwl_send_cmd_pdu(priv, REPLY_TX_BEACON, frame_size,
 			      &frame->u.cmd[0]);
 	iwl_free_frame(priv, frame);
 	return rc;
 }
 /******************************************************************************
  *
  * Misc. internal state and helper functions
  *
  ******************************************************************************/
 static void iwl_ht_conf(struct iwl_priv *priv,
 			    struct ieee80211_bss_conf *bss_conf)
 {
 	struct ieee80211_sta_ht_cap *ht_conf;
 	struct iwl_ht_info *iwl_conf = &priv->current_ht_config;
 	struct ieee80211_sta *sta;
 	IWL_DEBUG_MAC80211("enter: \n");
 	if (!iwl_conf->is_ht)
 		return;
 	/*
 	 * It is totally wrong to base global information on something
 	 * that is valid only when associated, alas, this driver works
 	 * that way and I don't know how to fix it.
 	 */
 	rcu_read_lock();
 	sta = ieee80211_find_sta(priv->hw, priv->bssid);
 	if (!sta) {
 		rcu_read_unlock();
 		return;
 	}
 	ht_conf = &sta->ht_cap;
 	if (ht_conf->cap & IEEE80211_HT_CAP_SGI_20)
 		iwl_conf->sgf |= HT_SHORT_GI_20MHZ;
 	if (ht_conf->cap & IEEE80211_HT_CAP_SGI_40)
 		iwl_conf->sgf |= HT_SHORT_GI_40MHZ;
 	iwl_conf->is_green_field = !!(ht_conf->cap & IEEE80211_HT_CAP_GRN_FLD);
 	iwl_conf->max_amsdu_size =
 		!!(ht_conf->cap & IEEE80211_HT_CAP_MAX_AMSDU);
 	iwl_conf->supported_chan_width =
 		!!(ht_conf->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40);
-	iwl_conf->extension_chan_offset = bss_conf->ht.secondary_channel_offset;
+	/*
+	 * XXX: The HT configuration needs to be moved into iwl_mac_config()
+	 *	to be done there correctly.
+	 */
+	iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
+	if (priv->hw->conf.ht.channel_type == NL80211_CHAN_HT40MINUS)
+		iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
+	else if(priv->hw->conf.ht.channel_type == NL80211_CHAN_HT40PLUS)
+		iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
 	/* If no above or below channel supplied disable FAT channel */
 	if (iwl_conf->extension_chan_offset != IEEE80211_HT_PARAM_CHA_SEC_ABOVE &&
-	    iwl_conf->extension_chan_offset != IEEE80211_HT_PARAM_CHA_SEC_BELOW) {
+	    iwl_conf->extension_chan_offset != IEEE80211_HT_PARAM_CHA_SEC_BELOW)
-		iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
 		iwl_conf->supported_chan_width = 0;
-	}
 	iwl_conf->sm_ps = (u8)((ht_conf->cap & IEEE80211_HT_CAP_SM_PS) >> 2);
 	memcpy(&iwl_conf->mcs, &ht_conf->mcs, 16);
-	iwl_conf->tx_chan_width = bss_conf->ht.width_40_ok;
+	iwl_conf->tx_chan_width = iwl_conf->supported_chan_width != 0;
 	iwl_conf->ht_protection =
 		bss_conf->ht.operation_mode & IEEE80211_HT_OP_MODE_PROTECTION;
 	iwl_conf->non_GF_STA_present =
 		!!(bss_conf->ht.operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
 	rcu_read_unlock();
 	IWL_DEBUG_MAC80211("leave\n");
 }
 /*
  * QoS  support
 */
 static void iwl_activate_qos(struct iwl_priv *priv, u8 force)
 {
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 		return;
 	priv->qos_data.def_qos_parm.qos_flags = 0;
 	if (priv->qos_data.qos_cap.q_AP.queue_request &&
 	    !priv->qos_data.qos_cap.q_AP.txop_request)
 		priv->qos_data.def_qos_parm.qos_flags |=
 			QOS_PARAM_FLG_TXOP_TYPE_MSK;
 	if (priv->qos_data.qos_active)
 		priv->qos_data.def_qos_parm.qos_flags |=
 			QOS_PARAM_FLG_UPDATE_EDCA_MSK;
 	if (priv->current_ht_config.is_ht)
 		priv->qos_data.def_qos_parm.qos_flags |= QOS_PARAM_FLG_TGN_MSK;
 	if (force || iwl_is_associated(priv)) {
 		IWL_DEBUG_QOS("send QoS cmd with Qos active=%d FLAGS=0x%X\n",
 				priv->qos_data.qos_active,
 				priv->qos_data.def_qos_parm.qos_flags);
 		iwl_send_cmd_pdu_async(priv, REPLY_QOS_PARAM,
 				       sizeof(struct iwl_qosparam_cmd),
 				       &priv->qos_data.def_qos_parm, NULL);
 	}
 }
 #define MAX_UCODE_BEACON_INTERVAL	4096
 static u16 iwl_adjust_beacon_interval(u16 beacon_val)
 {
 	u16 new_val = 0;
 	u16 beacon_factor = 0;
 	beacon_factor = (beacon_val + MAX_UCODE_BEACON_INTERVAL)
 					/ MAX_UCODE_BEACON_INTERVAL;
 	new_val = beacon_val / beacon_factor;
 	return new_val;
 }
 static void iwl_setup_rxon_timing(struct iwl_priv *priv)
 {
 	u64 tsf;
 	s32 interval_tm, rem;
 	unsigned long flags;
 	struct ieee80211_conf *conf = NULL;
 	u16 beacon_int = 0;
 	conf = ieee80211_get_hw_conf(priv->hw);
 	spin_lock_irqsave(&priv->lock, flags);
 	priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
 	priv->rxon_timing.listen_interval = cpu_to_le16(conf->listen_interval);
 	if (priv->iw_mode == NL80211_IFTYPE_STATION) {
 		beacon_int = iwl_adjust_beacon_interval(priv->beacon_int);
 		priv->rxon_timing.atim_window = 0;
 	} else {
 		beacon_int = iwl_adjust_beacon_interval(conf->beacon_int);
 		/* TODO: we need to get atim_window from upper stack
 		 * for now we set to 0 */
 		priv->rxon_timing.atim_window = 0;
 	}
 	priv->rxon_timing.beacon_interval = cpu_to_le16(beacon_int);
 	tsf = priv->timestamp; /* tsf is modifed by do_div: copy it */
 	interval_tm = beacon_int * 1024;
 	rem = do_div(tsf, interval_tm);
 	priv->rxon_timing.beacon_init_val = cpu_to_le32(interval_tm - rem);
 	spin_unlock_irqrestore(&priv->lock, flags);
 	IWL_DEBUG_ASSOC("beacon interval %d beacon timer %d beacon tim %d\n",
 			le16_to_cpu(priv->rxon_timing.beacon_interval),
 			le32_to_cpu(priv->rxon_timing.beacon_init_val),
 			le16_to_cpu(priv->rxon_timing.atim_window));
 }
 static void iwl_set_flags_for_band(struct iwl_priv *priv,
 				   enum ieee80211_band band)
 {
 	if (band == IEEE80211_BAND_5GHZ) {
 		priv->staging_rxon.flags &=
 		    ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
 		      | RXON_FLG_CCK_MSK);
 		priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
 	} else {
 		/* Copied from iwl_post_associate() */
 		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
 			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
 		else
 			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
 		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
 			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
 		priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;
 		priv->staging_rxon.flags |= RXON_FLG_AUTO_DETECT_MSK;
 		priv->staging_rxon.flags &= ~RXON_FLG_CCK_MSK;
 	}
 }
 /*
  * initialize rxon structure with default values from eeprom
  */
 static void iwl_connection_init_rx_config(struct iwl_priv *priv, int mode)
 {
 	const struct iwl_channel_info *ch_info;
 	memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
 	switch (mode) {
 	case NL80211_IFTYPE_AP:
 		priv->staging_rxon.dev_type = RXON_DEV_TYPE_AP;
 		break;
 	case NL80211_IFTYPE_STATION:
 		priv->staging_rxon.dev_type = RXON_DEV_TYPE_ESS;
 		priv->staging_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
 		break;
 	case NL80211_IFTYPE_ADHOC:
 		priv->staging_rxon.dev_type = RXON_DEV_TYPE_IBSS;
 		priv->staging_rxon.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
 		priv->staging_rxon.filter_flags = RXON_FILTER_BCON_AWARE_MSK |
 						  RXON_FILTER_ACCEPT_GRP_MSK;
 		break;
 	case NL80211_IFTYPE_MONITOR:
 		priv->staging_rxon.dev_type = RXON_DEV_TYPE_SNIFFER;
 		priv->staging_rxon.filter_flags = RXON_FILTER_PROMISC_MSK |
 		    RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_ACCEPT_GRP_MSK;
 		break;
 	default:
 		IWL_ERROR("Unsupported interface type %d\n", mode);
 		break;
 	}
 #if 0
 	/* TODO:  Figure out when short_preamble would be set and cache from
 	 * that */
 	if (!hw_to_local(priv->hw)->short_preamble)
 		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
 	else
 		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
 #endif
 	ch_info = iwl_get_channel_info(priv, priv->band,
 				       le16_to_cpu(priv->active_rxon.channel));
 	if (!ch_info)
 		ch_info = &priv->channel_info[0];
 	/*
 	 * in some case A channels are all non IBSS
 	 * in this case force B/G channel
 	 */
 	if ((priv->iw_mode == NL80211_IFTYPE_ADHOC) &&
 	    !(is_channel_ibss(ch_info)))
 		ch_info = &priv->channel_info[0];
 	priv->staging_rxon.channel = cpu_to_le16(ch_info->channel);
 	priv->band = ch_info->band;
 	iwl_set_flags_for_band(priv, priv->band);
 	priv->staging_rxon.ofdm_basic_rates =
 	    (IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
 	priv->staging_rxon.cck_basic_rates =
 	    (IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
 	priv->staging_rxon.flags &= ~(RXON_FLG_CHANNEL_MODE_MIXED_MSK |
 					RXON_FLG_CHANNEL_MODE_PURE_40_MSK);
 	memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
 	memcpy(priv->staging_rxon.wlap_bssid_addr, priv->mac_addr, ETH_ALEN);
 	priv->staging_rxon.ofdm_ht_single_stream_basic_rates = 0xff;
 	priv->staging_rxon.ofdm_ht_dual_stream_basic_rates = 0xff;
 	iwl_set_rxon_chain(priv);
 }
 static int iwl_set_mode(struct iwl_priv *priv, int mode)
 {
 	iwl_connection_init_rx_config(priv, mode);
 	memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
 	iwl_clear_stations_table(priv);
 	/* dont commit rxon if rf-kill is on*/
 	if (!iwl_is_ready_rf(priv))
 		return -EAGAIN;
 	cancel_delayed_work(&priv->scan_check);
 	if (iwl_scan_cancel_timeout(priv, 100)) {
 		IWL_WARNING("Aborted scan still in progress after 100ms\n");
 		IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
 		return -EAGAIN;
 	}
 	iwl_commit_rxon(priv);
 	return 0;
 }
 static void iwl_set_rate(struct iwl_priv *priv)
 {
 	const struct ieee80211_supported_band *hw = NULL;
 	struct ieee80211_rate *rate;
 	int i;
 	hw = iwl_get_hw_mode(priv, priv->band);
 	if (!hw) {
 		IWL_ERROR("Failed to set rate: unable to get hw mode\n");
 		return;
 	}
 	priv->active_rate = 0;
 	priv->active_rate_basic = 0;
 	for (i = 0; i < hw->n_bitrates; i++) {
 		rate = &(hw->bitrates[i]);
 		if (rate->hw_value < IWL_RATE_COUNT)
 			priv->active_rate |= (1 << rate->hw_value);
 	}
 	IWL_DEBUG_RATE("Set active_rate = %0x, active_rate_basic = %0x\n",
 		       priv->active_rate, priv->active_rate_basic);
 	/*
 	 * If a basic rate is configured, then use it (adding IWL_RATE_1M_MASK)
 	 * otherwise set it to the default of all CCK rates and 6, 12, 24 for
 	 * OFDM
 	 */
 	if (priv->active_rate_basic & IWL_CCK_BASIC_RATES_MASK)
 		priv->staging_rxon.cck_basic_rates =
 		    ((priv->active_rate_basic &
 		      IWL_CCK_RATES_MASK) >> IWL_FIRST_CCK_RATE) & 0xF;
 	else
 		priv->staging_rxon.cck_basic_rates =
 		    (IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
 	if (priv->active_rate_basic & IWL_OFDM_BASIC_RATES_MASK)
 		priv->staging_rxon.ofdm_basic_rates =
 		    ((priv->active_rate_basic &
 		      (IWL_OFDM_BASIC_RATES_MASK | IWL_RATE_6M_MASK)) >>
 		      IWL_FIRST_OFDM_RATE) & 0xFF;
 	else
 		priv->staging_rxon.ofdm_basic_rates =
 		   (IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
 }
 /******************************************************************************
  *
  * Generic RX handler implementations
  *
  ******************************************************************************/
 static void iwl_rx_reply_alive(struct iwl_priv *priv,
 				struct iwl_rx_mem_buffer *rxb)
 {
 	struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
 	struct iwl_alive_resp *palive;
 	struct delayed_work *pwork;
 	palive = &pkt->u.alive_frame;
 	IWL_DEBUG_INFO("Alive ucode status 0x%08X revision "
 		       "0x%01X 0x%01X\n",
 		       palive->is_valid, palive->ver_type,
 		       palive->ver_subtype);
 	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
 		IWL_DEBUG_INFO("Initialization Alive received.\n");
 		memcpy(&priv->card_alive_init,
 		       &pkt->u.alive_frame,
 		       sizeof(struct iwl_init_alive_resp));
 		pwork = &priv->init_alive_start;
 	} else {
 		IWL_DEBUG_INFO("Runtime Alive received.\n");
 		memcpy(&priv->card_alive, &pkt->u.alive_frame,
 		       sizeof(struct iwl_alive_resp));
 		pwork = &priv->alive_start;
 	}
 	/* We delay the ALIVE response by 5ms to
 	 * give the HW RF Kill time to activate... */
 	if (palive->is_valid == UCODE_VALID_OK)
 		queue_delayed_work(priv->workqueue, pwork,
 				   msecs_to_jiffies(5));
 	else
 		IWL_WARNING("uCode did not respond OK.\n");
 }
 static void iwl_rx_reply_error(struct iwl_priv *priv,
 				   struct iwl_rx_mem_buffer *rxb)
 {
 	struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
 	IWL_ERROR("Error Reply type 0x%08X cmd %s (0x%02X) "
 		"seq 0x%04X ser 0x%08X\n",
 		le32_to_cpu(pkt->u.err_resp.error_type),
 		get_cmd_string(pkt->u.err_resp.cmd_id),
 		pkt->u.err_resp.cmd_id,
 		le16_to_cpu(pkt->u.err_resp.bad_cmd_seq_num),
 		le32_to_cpu(pkt->u.err_resp.error_info));
 }
 #define TX_STATUS_ENTRY(x) case TX_STATUS_FAIL_ ## x: return #x
 static void iwl_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
 {
 	struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
 	struct iwl_rxon_cmd *rxon = (void *)&priv->active_rxon;
 	struct iwl_csa_notification *csa = &(pkt->u.csa_notif);
 	IWL_DEBUG_11H("CSA notif: channel %d, status %d\n",
 		      le16_to_cpu(csa->channel), le32_to_cpu(csa->status));
 	rxon->channel = csa->channel;
 	priv->staging_rxon.channel = csa->channel;
 }
 static void iwl_rx_pm_sleep_notif(struct iwl_priv *priv,
 				      struct iwl_rx_mem_buffer *rxb)
 {
 #ifdef CONFIG_IWLWIFI_DEBUG
 	struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
 	struct iwl_sleep_notification *sleep = &(pkt->u.sleep_notif);
 	IWL_DEBUG_RX("sleep mode: %d, src: %d\n",
 		     sleep->pm_sleep_mode, sleep->pm_wakeup_src);
 #endif
 }
 static void iwl_rx_pm_debug_statistics_notif(struct iwl_priv *priv,
 					     struct iwl_rx_mem_buffer *rxb)
 {
 	struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
 	IWL_DEBUG_RADIO("Dumping %d bytes of unhandled "
 			"notification for %s:\n",
 			le32_to_cpu(pkt->len), get_cmd_string(pkt->hdr.cmd));
 	iwl_print_hex_dump(priv, IWL_DL_RADIO, pkt->u.raw, le32_to_cpu(pkt->len));
 }
 static void iwl_bg_beacon_update(struct work_struct *work)
 {
 	struct iwl_priv *priv =
 		container_of(work, struct iwl_priv, beacon_update);
 	struct sk_buff *beacon;
 	/* Pull updated AP beacon from mac80211. will fail if not in AP mode */
 	beacon = ieee80211_beacon_get(priv->hw, priv->vif);
 	if (!beacon) {
 		IWL_ERROR("update beacon failed\n");
 		return;
 	}
 	mutex_lock(&priv->mutex);
 	/* new beacon skb is allocated every time; dispose previous.*/
 	if (priv->ibss_beacon)
 		dev_kfree_skb(priv->ibss_beacon);
 	priv->ibss_beacon = beacon;
 	mutex_unlock(&priv->mutex);
 	iwl_send_beacon_cmd(priv);
 }
 /**
  * iwl_bg_statistics_periodic - Timer callback to queue statistics
  *
  * This callback is provided in order to send a statistics request.
  *
  * This timer function is continually reset to execute within
  * REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION
  * was received.  We need to ensure we receive the statistics in order
  * to update the temperature used for calibrating the TXPOWER.
  */
 static void iwl_bg_statistics_periodic(unsigned long data)
 {
 	struct iwl_priv *priv = (struct iwl_priv *)data;
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 		return;
 	/* dont send host command if rf-kill is on */
 	if (!iwl_is_ready_rf(priv))
 		return;
 	iwl_send_statistics_request(priv, CMD_ASYNC);
 }
 static void iwl_rx_beacon_notif(struct iwl_priv *priv,
 				struct iwl_rx_mem_buffer *rxb)
 {
 #ifdef CONFIG_IWLWIFI_DEBUG
 	struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
 	struct iwl4965_beacon_notif *beacon =
 		(struct iwl4965_beacon_notif *)pkt->u.raw;
 	u8 rate = iwl_hw_get_rate(beacon->beacon_notify_hdr.rate_n_flags);
 	IWL_DEBUG_RX("beacon status %x retries %d iss %d "
 		"tsf %d %d rate %d\n",
 		le32_to_cpu(beacon->beacon_notify_hdr.u.status) & TX_STATUS_MSK,
 		beacon->beacon_notify_hdr.failure_frame,
 		le32_to_cpu(beacon->ibss_mgr_status),
 		le32_to_cpu(beacon->high_tsf),
 		le32_to_cpu(beacon->low_tsf), rate);
 #endif
 	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
 	    (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
 		queue_work(priv->workqueue, &priv->beacon_update);
 }
 /* Handle notification from uCode that card's power state is changing
  * due to software, hardware, or critical temperature RFKILL */
 static void iwl_rx_card_state_notif(struct iwl_priv *priv,
 				    struct iwl_rx_mem_buffer *rxb)
 {
 	struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
 	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
 	unsigned long status = priv->status;
 	IWL_DEBUG_RF_KILL("Card state received: HW:%s SW:%s\n",
 			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
 			  (flags & SW_CARD_DISABLED) ? "Kill" : "On");
 	if (flags & (SW_CARD_DISABLED | HW_CARD_DISABLED |
 		     RF_CARD_DISABLED)) {
 		iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
 			    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
 		if (!iwl_grab_nic_access(priv)) {
 			iwl_write_direct32(
 				priv, HBUS_TARG_MBX_C,
 				HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
 			iwl_release_nic_access(priv);
 		}
 		if (!(flags & RXON_CARD_DISABLED)) {
 			iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
 				    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
 			if (!iwl_grab_nic_access(priv)) {
 				iwl_write_direct32(
 					priv, HBUS_TARG_MBX_C,
 					HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
 				iwl_release_nic_access(priv);
 			}
 		}
 		if (flags & RF_CARD_DISABLED) {
 			iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
 				    CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
 			iwl_read32(priv, CSR_UCODE_DRV_GP1);
 			if (!iwl_grab_nic_access(priv))
 				iwl_release_nic_access(priv);
 		}
 	}
 	if (flags & HW_CARD_DISABLED)
 		set_bit(STATUS_RF_KILL_HW, &priv->status);
 	else
 		clear_bit(STATUS_RF_KILL_HW, &priv->status);
 	if (flags & SW_CARD_DISABLED)
 		set_bit(STATUS_RF_KILL_SW, &priv->status);
 	else
 		clear_bit(STATUS_RF_KILL_SW, &priv->status);
 	if (!(flags & RXON_CARD_DISABLED))
 		iwl_scan_cancel(priv);
 	if ((test_bit(STATUS_RF_KILL_HW, &status) !=
 	     test_bit(STATUS_RF_KILL_HW, &priv->status)) ||
 	    (test_bit(STATUS_RF_KILL_SW, &status) !=
 	     test_bit(STATUS_RF_KILL_SW, &priv->status)))
 		queue_work(priv->workqueue, &priv->rf_kill);
 	else
 		wake_up_interruptible(&priv->wait_command_queue);
 }
 int iwl_set_pwr_src(struct iwl_priv *priv, enum iwl_pwr_src src)
 {
 	int ret;
 	unsigned long flags;
 	spin_lock_irqsave(&priv->lock, flags);
 	ret = iwl_grab_nic_access(priv);
 	if (ret)
 		goto err;
 	if (src == IWL_PWR_SRC_VAUX) {
 		u32 val;
 		ret = pci_read_config_dword(priv->pci_dev, PCI_CFG_POWER_SOURCE,
 					    &val);
 		if (val & PCI_CFG_PMC_PME_FROM_D3COLD_SUPPORT)
 			iwl_set_bits_mask_prph(priv, APMG_PS_CTRL_REG,
 					       APMG_PS_CTRL_VAL_PWR_SRC_VAUX,
 					       ~APMG_PS_CTRL_MSK_PWR_SRC);
 	} else {
 		iwl_set_bits_mask_prph(priv, APMG_PS_CTRL_REG,
 				       APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
 				       ~APMG_PS_CTRL_MSK_PWR_SRC);
 	}
 	iwl_release_nic_access(priv);
 err:
 	spin_unlock_irqrestore(&priv->lock, flags);
 	return ret;
 }
 /**
  * iwl_setup_rx_handlers - Initialize Rx handler callbacks
  *
  * Setup the RX handlers for each of the reply types sent from the uCode
  * to the host.
  *
  * This function chains into the hardware specific files for them to setup
  * any hardware specific handlers as well.
  */
 static void iwl_setup_rx_handlers(struct iwl_priv *priv)
 {
 	priv->rx_handlers[REPLY_ALIVE] = iwl_rx_reply_alive;
 	priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
 	priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
 	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
 	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
 	    iwl_rx_pm_debug_statistics_notif;
 	priv->rx_handlers[BEACON_NOTIFICATION] = iwl_rx_beacon_notif;
 	/*
 	 * The same handler is used for both the REPLY to a discrete
 	 * statistics request from the host as well as for the periodic
 	 * statistics notifications (after received beacons) from the uCode.
 	 */
 	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl_rx_statistics;
 	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl_rx_statistics;
 	iwl_setup_spectrum_handlers(priv);
 	iwl_setup_rx_scan_handlers(priv);
 	/* status change handler */
 	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl_rx_card_state_notif;
 	priv->rx_handlers[MISSED_BEACONS_NOTIFICATION] =
 	    iwl_rx_missed_beacon_notif;
 	/* Rx handlers */
 	priv->rx_handlers[REPLY_RX_PHY_CMD] = iwl_rx_reply_rx_phy;
 	priv->rx_handlers[REPLY_RX_MPDU_CMD] = iwl_rx_reply_rx;
 	/* block ack */
 	priv->rx_handlers[REPLY_COMPRESSED_BA] = iwl_rx_reply_compressed_ba;
 	/* Set up hardware specific Rx handlers */
 	priv->cfg->ops->lib->rx_handler_setup(priv);
 }
 /*
  * this should be called while priv->lock is locked
 */
 static void __iwl_rx_replenish(struct iwl_priv *priv)
 {
 	iwl_rx_allocate(priv);
 	iwl_rx_queue_restock(priv);
 }
 /**
  * iwl_rx_handle - Main entry function for receiving responses from uCode
  *
  * Uses the priv->rx_handlers callback function array to invoke
  * the appropriate handlers, including command responses,
  * frame-received notifications, and other notifications.
  */
 void iwl_rx_handle(struct iwl_priv *priv)
 {
 	struct iwl_rx_mem_buffer *rxb;
 	struct iwl_rx_packet *pkt;
 	struct iwl_rx_queue *rxq = &priv->rxq;
 	u32 r, i;
 	int reclaim;
 	unsigned long flags;
 	u8 fill_rx = 0;
 	u32 count = 8;
 	/* uCode's read index (stored in shared DRAM) indicates the last Rx
 	 * buffer that the driver may process (last buffer filled by ucode). */
 	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
 	i = rxq->read;
 	/* Rx interrupt, but nothing sent from uCode */
 	if (i == r)
 		IWL_DEBUG(IWL_DL_RX, "r = %d, i = %d\n", r, i);
 	if (iwl_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
 		fill_rx = 1;
 	while (i != r) {
 		rxb = rxq->queue[i];
 		/* If an RXB doesn't have a Rx queue slot associated with it,
 		 * then a bug has been introduced in the queue refilling
 		 * routines -- catch it here */
 		BUG_ON(rxb == NULL);
 		rxq->queue[i] = NULL;
 		dma_sync_single_range_for_cpu(
 				&priv->pci_dev->dev, rxb->real_dma_addr,
 				rxb->aligned_dma_addr - rxb->real_dma_addr,
 				priv->hw_params.rx_buf_size,
 				PCI_DMA_FROMDEVICE);
 		pkt = (struct iwl_rx_packet *)rxb->skb->data;
 		/* Reclaim a command buffer only if this packet is a response
 		 *   to a (driver-originated) command.
 		 * If the packet (e.g. Rx frame) originated from uCode,
 		 *   there is no command buffer to reclaim.
 		 * Ucode should set SEQ_RX_FRAME bit if ucode-originated,
 		 *   but apparently a few don't get set; catch them here. */
 		reclaim = !(pkt->hdr.sequence & SEQ_RX_FRAME) &&
 			(pkt->hdr.cmd != REPLY_RX_PHY_CMD) &&
 			(pkt->hdr.cmd != REPLY_RX) &&
 			(pkt->hdr.cmd != REPLY_RX_MPDU_CMD) &&
 			(pkt->hdr.cmd != REPLY_COMPRESSED_BA) &&
 			(pkt->hdr.cmd != STATISTICS_NOTIFICATION) &&
 			(pkt->hdr.cmd != REPLY_TX);
 		/* Based on type of command response or notification,
 		 *   handle those that need handling via function in
 		 *   rx_handlers table.  See iwl_setup_rx_handlers() */
 		if (priv->rx_handlers[pkt->hdr.cmd]) {
 			IWL_DEBUG(IWL_DL_RX, "r = %d, i = %d, %s, 0x%02x\n", r,
 				i, get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
 			priv->rx_handlers[pkt->hdr.cmd] (priv, rxb);
 		} else {
 			/* No handling needed */
 			IWL_DEBUG(IWL_DL_RX,
 				"r %d i %d No handler needed for %s, 0x%02x\n",
 				r, i, get_cmd_string(pkt->hdr.cmd),
 				pkt->hdr.cmd);
 		}
 		if (reclaim) {
 			/* Invoke any callbacks, transfer the skb to caller, and
 			 * fire off the (possibly) blocking iwl_send_cmd()
 			 * as we reclaim the driver command queue */
 			if (rxb && rxb->skb)
 				iwl_tx_cmd_complete(priv, rxb);
 			else
 				IWL_WARNING("Claim null rxb?\n");
 		}
 		/* For now we just don't re-use anything.  We can tweak this
 		 * later to try and re-use notification packets and SKBs that
 		 * fail to Rx correctly */
 		if (rxb->skb != NULL) {
 			priv->alloc_rxb_skb--;
 			dev_kfree_skb_any(rxb->skb);
 			rxb->skb = NULL;
 		}
 		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
 				 priv->hw_params.rx_buf_size + 256,
 				 PCI_DMA_FROMDEVICE);
 		spin_lock_irqsave(&rxq->lock, flags);
 		list_add_tail(&rxb->list, &priv->rxq.rx_used);
 		spin_unlock_irqrestore(&rxq->lock, flags);
 		i = (i + 1) & RX_QUEUE_MASK;
 		/* If there are a lot of unused frames,
 		 * restock the Rx queue so ucode wont assert. */
 		if (fill_rx) {
 			count++;
 			if (count >= 8) {
 				priv->rxq.read = i;
 				__iwl_rx_replenish(priv);
 				count = 0;
 			}
 		}
 	}
 	/* Backtrack one entry */
 	priv->rxq.read = i;
 	iwl_rx_queue_restock(priv);
 }
 #ifdef CONFIG_IWLWIFI_DEBUG
 static void iwl_print_rx_config_cmd(struct iwl_priv *priv)
 {
 	struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
 	IWL_DEBUG_RADIO("RX CONFIG:\n");
 	iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
 	IWL_DEBUG_RADIO("u16 channel: 0x%x\n", le16_to_cpu(rxon->channel));
 	IWL_DEBUG_RADIO("u32 flags: 0x%08X\n", le32_to_cpu(rxon->flags));
 	IWL_DEBUG_RADIO("u32 filter_flags: 0x%08x\n",
 			le32_to_cpu(rxon->filter_flags));
 	IWL_DEBUG_RADIO("u8 dev_type: 0x%x\n", rxon->dev_type);
 	IWL_DEBUG_RADIO("u8 ofdm_basic_rates: 0x%02x\n",
 			rxon->ofdm_basic_rates);
 	IWL_DEBUG_RADIO("u8 cck_basic_rates: 0x%02x\n", rxon->cck_basic_rates);
 	IWL_DEBUG_RADIO("u8[6] node_addr: %pM\n", rxon->node_addr);
 	IWL_DEBUG_RADIO("u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
 	IWL_DEBUG_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
 }
 #endif
 /* call this function to flush any scheduled tasklet */
 static inline void iwl_synchronize_irq(struct iwl_priv *priv)
 {
 	/* wait to make sure we flush pending tasklet*/
 	synchronize_irq(priv->pci_dev->irq);
 	tasklet_kill(&priv->irq_tasklet);
 }
 /**
  * iwl_irq_handle_error - called for HW or SW error interrupt from card
  */
 static void iwl_irq_handle_error(struct iwl_priv *priv)
 {
 	/* Set the FW error flag -- cleared on iwl_down */
 	set_bit(STATUS_FW_ERROR, &priv->status);
 	/* Cancel currently queued command. */
 	clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
 #ifdef CONFIG_IWLWIFI_DEBUG
 	if (priv->debug_level & IWL_DL_FW_ERRORS) {
 		iwl_dump_nic_error_log(priv);
 		iwl_dump_nic_event_log(priv);
 		iwl_print_rx_config_cmd(priv);
 	}
 #endif
 	wake_up_interruptible(&priv->wait_command_queue);
 	/* Keep the restart process from trying to send host
 	 * commands by clearing the INIT status bit */
 	clear_bit(STATUS_READY, &priv->status);
 	if (!test_bit(STATUS_EXIT_PENDING, &priv->status)) {
 		IWL_DEBUG(IWL_DL_FW_ERRORS,
 			  "Restarting adapter due to uCode error.\n");
 		if (iwl_is_associated(priv)) {
 			memcpy(&priv->recovery_rxon, &priv->active_rxon,
 			       sizeof(priv->recovery_rxon));
 			priv->error_recovering = 1;
 		}
 		if (priv->cfg->mod_params->restart_fw)
 			queue_work(priv->workqueue, &priv->restart);
 	}
 }
 static void iwl_error_recovery(struct iwl_priv *priv)
 {
 	unsigned long flags;
 	memcpy(&priv->staging_rxon, &priv->recovery_rxon,
 	       sizeof(priv->staging_rxon));
 	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 	iwl_commit_rxon(priv);
 	iwl_rxon_add_station(priv, priv->bssid, 1);
 	spin_lock_irqsave(&priv->lock, flags);
 	priv->assoc_id = le16_to_cpu(priv->staging_rxon.assoc_id);
 	priv->error_recovering = 0;
 	spin_unlock_irqrestore(&priv->lock, flags);
 }
 static void iwl_irq_tasklet(struct iwl_priv *priv)
 {
 	u32 inta, handled = 0;
 	u32 inta_fh;
 	unsigned long flags;
 #ifdef CONFIG_IWLWIFI_DEBUG
 	u32 inta_mask;
 #endif
 	spin_lock_irqsave(&priv->lock, flags);
 	/* Ack/clear/reset pending uCode interrupts.
 	 * Note:  Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
 	 *  and will clear only when CSR_FH_INT_STATUS gets cleared. */
 	inta = iwl_read32(priv, CSR_INT);
 	iwl_write32(priv, CSR_INT, inta);
 	/* Ack/clear/reset pending flow-handler (DMA) interrupts.
 	 * Any new interrupts that happen after this, either while we're
 	 * in this tasklet, or later, will show up in next ISR/tasklet. */
 	inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
 	iwl_write32(priv, CSR_FH_INT_STATUS, inta_fh);
 #ifdef CONFIG_IWLWIFI_DEBUG
 	if (priv->debug_level & IWL_DL_ISR) {
 		/* just for debug */
 		inta_mask = iwl_read32(priv, CSR_INT_MASK);
 		IWL_DEBUG_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
 			      inta, inta_mask, inta_fh);
 	}
 #endif
 	/* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
 	 * atomic, make sure that inta covers all the interrupts that
 	 * we've discovered, even if FH interrupt came in just after
 	 * reading CSR_INT. */
 	if (inta_fh & CSR49_FH_INT_RX_MASK)
 		inta |= CSR_INT_BIT_FH_RX;
 	if (inta_fh & CSR49_FH_INT_TX_MASK)
 		inta |= CSR_INT_BIT_FH_TX;
 	/* Now service all interrupt bits discovered above. */
 	if (inta & CSR_INT_BIT_HW_ERR) {
 		IWL_ERROR("Microcode HW error detected.  Restarting.\n");
 		/* Tell the device to stop sending interrupts */
 		iwl_disable_interrupts(priv);
 		iwl_irq_handle_error(priv);
 		handled |= CSR_INT_BIT_HW_ERR;
 		spin_unlock_irqrestore(&priv->lock, flags);
 		return;
 	}
 #ifdef CONFIG_IWLWIFI_DEBUG
 	if (priv->debug_level & (IWL_DL_ISR)) {
 		/* NIC fires this, but we don't use it, redundant with WAKEUP */
 		if (inta & CSR_INT_BIT_SCD)
 			IWL_DEBUG_ISR("Scheduler finished to transmit "
 				      "the frame/frames.\n");
 		/* Alive notification via Rx interrupt will do the real work */
 		if (inta & CSR_INT_BIT_ALIVE)
 			IWL_DEBUG_ISR("Alive interrupt\n");
 	}
 #endif
 	/* Safely ignore these bits for debug checks below */
 	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
 	/* HW RF KILL switch toggled */
 	if (inta & CSR_INT_BIT_RF_KILL) {
 		int hw_rf_kill = 0;
 		if (!(iwl_read32(priv, CSR_GP_CNTRL) &
 				CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
 			hw_rf_kill = 1;
 		IWL_DEBUG(IWL_DL_RF_KILL, "RF_KILL bit toggled to %s.\n",
 				hw_rf_kill ? "disable radio" : "enable radio");
 		/* driver only loads ucode once setting the interface up.
 		 * the driver as well won't allow loading if RFKILL is set
 		 * therefore no need to restart the driver from this handler
 		 */
 		if (!hw_rf_kill && !test_bit(STATUS_ALIVE, &priv->status)) {
 			clear_bit(STATUS_RF_KILL_HW, &priv->status);
 			if (priv->is_open && !iwl_is_rfkill(priv))
 				queue_work(priv->workqueue, &priv->up);
 		}
 		handled |= CSR_INT_BIT_RF_KILL;
 	}
 	/* Chip got too hot and stopped itself */
 	if (inta & CSR_INT_BIT_CT_KILL) {
 		IWL_ERROR("Microcode CT kill error detected.\n");
 		handled |= CSR_INT_BIT_CT_KILL;
 	}
 	/* Error detected by uCode */
 	if (inta & CSR_INT_BIT_SW_ERR) {
 		IWL_ERROR("Microcode SW error detected.  Restarting 0x%X.\n",
 			  inta);
 		iwl_irq_handle_error(priv);
 		handled |= CSR_INT_BIT_SW_ERR;
 	}
 	/* uCode wakes up after power-down sleep */
 	if (inta & CSR_INT_BIT_WAKEUP) {
 		IWL_DEBUG_ISR("Wakeup interrupt\n");
 		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
 		iwl_txq_update_write_ptr(priv, &priv->txq[0]);
 		iwl_txq_update_write_ptr(priv, &priv->txq[1]);
 		iwl_txq_update_write_ptr(priv, &priv->txq[2]);
 		iwl_txq_update_write_ptr(priv, &priv->txq[3]);
 		iwl_txq_update_write_ptr(priv, &priv->txq[4]);
 		iwl_txq_update_write_ptr(priv, &priv->txq[5]);
 		handled |= CSR_INT_BIT_WAKEUP;
 	}
 	/* All uCode command responses, including Tx command responses,
 	 * Rx "responses" (frame-received notification), and other
 	 * notifications from uCode come through here*/
 	if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
 		iwl_rx_handle(priv);
 		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
 	}
 	if (inta & CSR_INT_BIT_FH_TX) {
 		IWL_DEBUG_ISR("Tx interrupt\n");
 		handled |= CSR_INT_BIT_FH_TX;
 		/* FH finished to write, send event */
 		priv->ucode_write_complete = 1;
 		wake_up_interruptible(&priv->wait_command_queue);
 	}
 	if (inta & ~handled)
 		IWL_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
 	if (inta & ~CSR_INI_SET_MASK) {
 		IWL_WARNING("Disabled INTA bits 0x%08x were pending\n",
 			 inta & ~CSR_INI_SET_MASK);
 		IWL_WARNING("   with FH_INT = 0x%08x\n", inta_fh);
 	}
 	/* Re-enable all interrupts */
 	/* only Re-enable if diabled by irq */
 	if (test_bit(STATUS_INT_ENABLED, &priv->status))
 		iwl_enable_interrupts(priv);
 #ifdef CONFIG_IWLWIFI_DEBUG
 	if (priv->debug_level & (IWL_DL_ISR)) {
 		inta = iwl_read32(priv, CSR_INT);
 		inta_mask = iwl_read32(priv, CSR_INT_MASK);
 		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
 		IWL_DEBUG_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
 			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
 	}
 #endif
 	spin_unlock_irqrestore(&priv->lock, flags);
 }
 static irqreturn_t iwl_isr(int irq, void *data)
 {
 	struct iwl_priv *priv = data;
 	u32 inta, inta_mask;
 	u32 inta_fh;
 	if (!priv)
 		return IRQ_NONE;
 	spin_lock(&priv->lock);
 	/* Disable (but don't clear!) interrupts here to avoid
 	 *    back-to-back ISRs and sporadic interrupts from our NIC.
 	 * If we have something to service, the tasklet will re-enable ints.
 	 * If we *don't* have something, we'll re-enable before leaving here. */
 	inta_mask = iwl_read32(priv, CSR_INT_MASK);  /* just for debug */
 	iwl_write32(priv, CSR_INT_MASK, 0x00000000);
 	/* Discover which interrupts are active/pending */
 	inta = iwl_read32(priv, CSR_INT);
 	inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
 	/* Ignore interrupt if there's nothing in NIC to service.
 	 * This may be due to IRQ shared with another device,
 	 * or due to sporadic interrupts thrown from our NIC. */
 	if (!inta && !inta_fh) {
 		IWL_DEBUG_ISR("Ignore interrupt, inta == 0, inta_fh == 0\n");
 		goto none;
 	}
 	if ((inta == 0xFFFFFFFF) || ((inta & 0xFFFFFFF0) == 0xa5a5a5a0)) {
 		/* Hardware disappeared. It might have already raised
 		 * an interrupt */
 		IWL_WARNING("HARDWARE GONE?? INTA == 0x%08x\n", inta);
 		goto unplugged;
 	}
 	IWL_DEBUG_ISR("ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
 		      inta, inta_mask, inta_fh);
 	inta &= ~CSR_INT_BIT_SCD;
 	/* iwl_irq_tasklet() will service interrupts and re-enable them */
 	if (likely(inta || inta_fh))
 		tasklet_schedule(&priv->irq_tasklet);
  unplugged:
 	spin_unlock(&priv->lock);
 	return IRQ_HANDLED;
  none:
 	/* re-enable interrupts here since we don't have anything to service. */
 	/* only Re-enable if diabled by irq */
 	if (test_bit(STATUS_INT_ENABLED, &priv->status))
 		iwl_enable_interrupts(priv);
 	spin_unlock(&priv->lock);
 	return IRQ_NONE;
 }
 /******************************************************************************
  *
  * uCode download functions
  *
  ******************************************************************************/
 static void iwl_dealloc_ucode_pci(struct iwl_priv *priv)
 {
 	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_code);
 	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_data);
 	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
 	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_init);
 	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_init_data);
 	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_boot);
 }
 static void iwl_nic_start(struct iwl_priv *priv)
 {
 	/* Remove all resets to allow NIC to operate */
 	iwl_write32(priv, CSR_RESET, 0);
 }
 /**
  * iwl_read_ucode - Read uCode images from disk file.
  *
  * Copy into buffers for card to fetch via bus-mastering
  */
 static int iwl_read_ucode(struct iwl_priv *priv)
 {
 	struct iwl_ucode *ucode;
 	int ret = -EINVAL, index;
 	const struct firmware *ucode_raw;
 	const char *name_pre = priv->cfg->fw_name_pre;
 	const unsigned int api_max = priv->cfg->ucode_api_max;
 	const unsigned int api_min = priv->cfg->ucode_api_min;
 	char buf[25];
 	u8 *src;
 	size_t len;
 	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
 	/* Ask kernel firmware_class module to get the boot firmware off disk.
 	 * request_firmware() is synchronous, file is in memory on return. */
 	for (index = api_max; index >= api_min; index--) {
 		sprintf(buf, "%s%d%s", name_pre, index, ".ucode");
 		ret = request_firmware(&ucode_raw, buf, &priv->pci_dev->dev);
 		if (ret < 0) {
 			IWL_ERROR("%s firmware file req failed: Reason %d\n",
 				  buf, ret);
 			if (ret == -ENOENT)
 				continue;
 			else
 				goto error;
 		} else {
 			if (index < api_max)
 				IWL_ERROR("Loaded firmware %s, which is deprecated. Please use API v%u instead.\n",
 					  buf, api_max);
 			IWL_DEBUG_INFO("Got firmware '%s' file (%zd bytes) from disk\n",
 				       buf, ucode_raw->size);
 			break;
 		}
 	}
 	if (ret < 0)
 		goto error;
 	/* Make sure that we got at least our header! */
 	if (ucode_raw->size < sizeof(*ucode)) {
 		IWL_ERROR("File size way too small!\n");
 		ret = -EINVAL;
 		goto err_release;
 	}
 	/* Data from ucode file:  header followed by uCode images */
 	ucode = (void *)ucode_raw->data;
 	priv->ucode_ver = le32_to_cpu(ucode->ver);
 	api_ver = IWL_UCODE_API(priv->ucode_ver);
 	inst_size = le32_to_cpu(ucode->inst_size);
 	data_size = le32_to_cpu(ucode->data_size);
 	init_size = le32_to_cpu(ucode->init_size);
 	init_data_size = le32_to_cpu(ucode->init_data_size);
 	boot_size = le32_to_cpu(ucode->boot_size);
 	/* api_ver should match the api version forming part of the
 	 * firmware filename ... but we don't check for that and only rely
 	 * on the API version read from firware header from here on forward */
 	if (api_ver < api_min || api_ver > api_max) {
 		IWL_ERROR("Driver unable to support your firmware API. "
 			  "Driver supports v%u, firmware is v%u.\n",
 			  api_max, api_ver);
 		priv->ucode_ver = 0;
 		ret = -EINVAL;
 		goto err_release;
 	}
 	if (api_ver != api_max)
 		IWL_ERROR("Firmware has old API version. Expected v%u, "
 			  "got v%u. New firmware can be obtained "
 			  "from http://www.intellinuxwireless.org.\n",
 			  api_max, api_ver);
 	printk(KERN_INFO DRV_NAME " loaded firmware version %u.%u.%u.%u\n",
 		       IWL_UCODE_MAJOR(priv->ucode_ver),
 		       IWL_UCODE_MINOR(priv->ucode_ver),
 		       IWL_UCODE_API(priv->ucode_ver),
 		       IWL_UCODE_SERIAL(priv->ucode_ver));
 	IWL_DEBUG_INFO("f/w package hdr ucode version raw = 0x%x\n",
 		       priv->ucode_ver);
 	IWL_DEBUG_INFO("f/w package hdr runtime inst size = %u\n",
 		       inst_size);
 	IWL_DEBUG_INFO("f/w package hdr runtime data size = %u\n",
 		       data_size);
 	IWL_DEBUG_INFO("f/w package hdr init inst size = %u\n",
 		       init_size);
 	IWL_DEBUG_INFO("f/w package hdr init data size = %u\n",
 		       init_data_size);
 	IWL_DEBUG_INFO("f/w package hdr boot inst size = %u\n",
 		       boot_size);
 	/* Verify size of file vs. image size info in file's header */
 	if (ucode_raw->size < sizeof(*ucode) +
 		inst_size + data_size + init_size +
 		init_data_size + boot_size) {
 		IWL_DEBUG_INFO("uCode file size %d too small\n",
 			       (int)ucode_raw->size);
 		ret = -EINVAL;
 		goto err_release;
 	}
 	/* Verify that uCode images will fit in card's SRAM */
 	if (inst_size > priv->hw_params.max_inst_size) {
 		IWL_DEBUG_INFO("uCode instr len %d too large to fit in\n",
 			       inst_size);
 		ret = -EINVAL;
 		goto err_release;
 	}
 	if (data_size > priv->hw_params.max_data_size) {
 		IWL_DEBUG_INFO("uCode data len %d too large to fit in\n",
 				data_size);
 		ret = -EINVAL;
 		goto err_release;
 	}
 	if (init_size > priv->hw_params.max_inst_size) {
 		IWL_DEBUG_INFO
 		    ("uCode init instr len %d too large to fit in\n",
 		      init_size);
 		ret = -EINVAL;
 		goto err_release;
 	}
 	if (init_data_size > priv->hw_params.max_data_size) {
 		IWL_DEBUG_INFO
 		    ("uCode init data len %d too large to fit in\n",
 		      init_data_size);
 		ret = -EINVAL;
 		goto err_release;
 	}
 	if (boot_size > priv->hw_params.max_bsm_size) {
 		IWL_DEBUG_INFO
 		    ("uCode boot instr len %d too large to fit in\n",
 		      boot_size);
 		ret = -EINVAL;
 		goto err_release;
 	}
 	/* Allocate ucode buffers for card's bus-master loading ... */
 	/* Runtime instructions and 2 copies of data:
 	 * 1) unmodified from disk
 	 * 2) backup cache for save/restore during power-downs */
 	priv->ucode_code.len = inst_size;
 	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
 	priv->ucode_data.len = data_size;
 	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
 	priv->ucode_data_backup.len = data_size;
 	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
 	/* Initialization instructions and data */
 	if (init_size && init_data_size) {
 		priv->ucode_init.len = init_size;
 		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
 		priv->ucode_init_data.len = init_data_size;
 		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
 		if (!priv->ucode_init.v_addr || !priv->ucode_init_data.v_addr)
 			goto err_pci_alloc;
 	}
 	/* Bootstrap (instructions only, no data) */
 	if (boot_size) {
 		priv->ucode_boot.len = boot_size;
 		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
 		if (!priv->ucode_boot.v_addr)
 			goto err_pci_alloc;
 	}
 	/* Copy images into buffers for card's bus-master reads ... */
 	/* Runtime instructions (first block of data in file) */
 	src = &ucode->data[0];
 	len = priv->ucode_code.len;
 	IWL_DEBUG_INFO("Copying (but not loading) uCode instr len %Zd\n", len);
 	memcpy(priv->ucode_code.v_addr, src, len);
 	IWL_DEBUG_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
 		priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);
 	/* Runtime data (2nd block)
 	 * NOTE:  Copy into backup buffer will be done in iwl_up()  */
 	src = &ucode->data[inst_size];
 	len = priv->ucode_data.len;
 	IWL_DEBUG_INFO("Copying (but not loading) uCode data len %Zd\n", len);
 	memcpy(priv->ucode_data.v_addr, src, len);
 	memcpy(priv->ucode_data_backup.v_addr, src, len);
 	/* Initialization instructions (3rd block) */
 	if (init_size) {
 		src = &ucode->data[inst_size + data_size];
 		len = priv->ucode_init.len;
 		IWL_DEBUG_INFO("Copying (but not loading) init instr len %Zd\n",
 				len);
 		memcpy(priv->ucode_init.v_addr, src, len);
 	}
 	/* Initialization data (4th block) */
 	if (init_data_size) {
 		src = &ucode->data[inst_size + data_size + init_size];
 		len = priv->ucode_init_data.len;
 		IWL_DEBUG_INFO("Copying (but not loading) init data len %Zd\n",
 			       len);
 		memcpy(priv->ucode_init_data.v_addr, src, len);
 	}
 	/* Bootstrap instructions (5th block) */
 	src = &ucode->data[inst_size + data_size + init_size + init_data_size];
 	len = priv->ucode_boot.len;
 	IWL_DEBUG_INFO("Copying (but not loading) boot instr len %Zd\n", len);
 	memcpy(priv->ucode_boot.v_addr, src, len);
 	/* We have our copies now, allow OS release its copies */
 	release_firmware(ucode_raw);
 	return 0;
  err_pci_alloc:
 	IWL_ERROR("failed to allocate pci memory\n");
 	ret = -ENOMEM;
 	iwl_dealloc_ucode_pci(priv);
  err_release:
 	release_firmware(ucode_raw);
  error:
 	return ret;
 }
 /* temporary */
 static int iwl_mac_beacon_update(struct ieee80211_hw *hw,
 				 struct sk_buff *skb);
 /**
  * iwl_alive_start - called after REPLY_ALIVE notification received
  *                   from protocol/runtime uCode (initialization uCode's
  *                   Alive gets handled by iwl_init_alive_start()).
  */
 static void iwl_alive_start(struct iwl_priv *priv)
 {
 	int ret = 0;
 	IWL_DEBUG_INFO("Runtime Alive received.\n");
 	if (priv->card_alive.is_valid != UCODE_VALID_OK) {
 		/* We had an error bringing up the hardware, so take it
 		 * all the way back down so we can try again */
 		IWL_DEBUG_INFO("Alive failed.\n");
 		goto restart;
 	}
 	/* Initialize uCode has loaded Runtime uCode ... verify inst image.
 	 * This is a paranoid check, because we would not have gotten the
 	 * "runtime" alive if code weren't properly loaded.  */
 	if (iwl_verify_ucode(priv)) {
 		/* Runtime instruction load was bad;
 		 * take it all the way back down so we can try again */
 		IWL_DEBUG_INFO("Bad runtime uCode load.\n");
 		goto restart;
 	}
 	iwl_clear_stations_table(priv);
 	ret = priv->cfg->ops->lib->alive_notify(priv);
 	if (ret) {
 		IWL_WARNING("Could not complete ALIVE transition [ntf]: %d\n",
 			    ret);
 		goto restart;
 	}
 	/* After the ALIVE response, we can send host commands to the uCode */
 	set_bit(STATUS_ALIVE, &priv->status);
 	if (iwl_is_rfkill(priv))
 		return;
 	ieee80211_wake_queues(priv->hw);
 	priv->active_rate = priv->rates_mask;
 	priv->active_rate_basic = priv->rates_mask & IWL_BASIC_RATES_MASK;
 	if (iwl_is_associated(priv)) {
 		struct iwl_rxon_cmd *active_rxon =
 				(struct iwl_rxon_cmd *)&priv->active_rxon;
 		memcpy(&priv->staging_rxon, &priv->active_rxon,
 		       sizeof(priv->staging_rxon));
 		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 	} else {
 		/* Initialize our rx_config data */
 		iwl_connection_init_rx_config(priv, priv->iw_mode);
 		memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
 	}
 	/* Configure Bluetooth device coexistence support */
 	iwl_send_bt_config(priv);
 	iwl_reset_run_time_calib(priv);
 	/* Configure the adapter for unassociated operation */
 	iwl_commit_rxon(priv);
 	/* At this point, the NIC is initialized and operational */
 	iwl_rf_kill_ct_config(priv);
 	iwl_leds_register(priv);
 	IWL_DEBUG_INFO("ALIVE processing complete.\n");
 	set_bit(STATUS_READY, &priv->status);
 	wake_up_interruptible(&priv->wait_command_queue);
 	if (priv->error_recovering)
 		iwl_error_recovery(priv);
 	iwl_power_update_mode(priv, 1);
 	/* reassociate for ADHOC mode */
 	if (priv->vif && (priv->iw_mode == NL80211_IFTYPE_ADHOC)) {
 		struct sk_buff *beacon = ieee80211_beacon_get(priv->hw,
 								priv->vif);
 		if (beacon)
 			iwl_mac_beacon_update(priv->hw, beacon);
 	}
 	if (test_and_clear_bit(STATUS_MODE_PENDING, &priv->status))
 		iwl_set_mode(priv, priv->iw_mode);
 	return;
  restart:
 	queue_work(priv->workqueue, &priv->restart);
 }
 static void iwl_cancel_deferred_work(struct iwl_priv *priv);
 static void __iwl_down(struct iwl_priv *priv)
 {
 	unsigned long flags;
 	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
 	IWL_DEBUG_INFO(DRV_NAME " is going down\n");
 	if (!exit_pending)
 		set_bit(STATUS_EXIT_PENDING, &priv->status);
 	iwl_leds_unregister(priv);
 	iwl_clear_stations_table(priv);
 	/* Unblock any waiting calls */
 	wake_up_interruptible_all(&priv->wait_command_queue);
 	/* Wipe out the EXIT_PENDING status bit if we are not actually
 	 * exiting the module */
 	if (!exit_pending)
 		clear_bit(STATUS_EXIT_PENDING, &priv->status);
 	/* stop and reset the on-board processor */
 	iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
 	/* tell the device to stop sending interrupts */
 	spin_lock_irqsave(&priv->lock, flags);
 	iwl_disable_interrupts(priv);
 	spin_unlock_irqrestore(&priv->lock, flags);
 	iwl_synchronize_irq(priv);
 	if (priv->mac80211_registered)
 		ieee80211_stop_queues(priv->hw);
 	/* If we have not previously called iwl_init() then
 	 * clear all bits but the RF Kill and SUSPEND bits and return */
 	if (!iwl_is_init(priv)) {
 		priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
 					STATUS_RF_KILL_HW |
 			       test_bit(STATUS_RF_KILL_SW, &priv->status) <<
 					STATUS_RF_KILL_SW |
 			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
 					STATUS_GEO_CONFIGURED |
 			       test_bit(STATUS_IN_SUSPEND, &priv->status) <<
 					STATUS_IN_SUSPEND |
 			       test_bit(STATUS_EXIT_PENDING, &priv->status) <<
 					STATUS_EXIT_PENDING;
 		goto exit;
 	}
 	/* ...otherwise clear out all the status bits but the RF Kill and
 	 * SUSPEND bits and continue taking the NIC down. */
 	priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
 				STATUS_RF_KILL_HW |
 			test_bit(STATUS_RF_KILL_SW, &priv->status) <<
 				STATUS_RF_KILL_SW |
 			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
 				STATUS_GEO_CONFIGURED |
 			test_bit(STATUS_IN_SUSPEND, &priv->status) <<
 				STATUS_IN_SUSPEND |
 			test_bit(STATUS_FW_ERROR, &priv->status) <<
 				STATUS_FW_ERROR |
 		       test_bit(STATUS_EXIT_PENDING, &priv->status) <<
 				STATUS_EXIT_PENDING;
 	spin_lock_irqsave(&priv->lock, flags);
 	iwl_clear_bit(priv, CSR_GP_CNTRL,
 			 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
 	spin_unlock_irqrestore(&priv->lock, flags);
 	iwl_txq_ctx_stop(priv);
 	iwl_rxq_stop(priv);
 	spin_lock_irqsave(&priv->lock, flags);
 	if (!iwl_grab_nic_access(priv)) {
 		iwl_write_prph(priv, APMG_CLK_DIS_REG,
 					 APMG_CLK_VAL_DMA_CLK_RQT);
 		iwl_release_nic_access(priv);
 	}
 	spin_unlock_irqrestore(&priv->lock, flags);
 	udelay(5);
 	/* FIXME: apm_ops.suspend(priv) */
 	if (exit_pending || test_bit(STATUS_IN_SUSPEND, &priv->status))
 		priv->cfg->ops->lib->apm_ops.stop(priv);
 	else
 		priv->cfg->ops->lib->apm_ops.reset(priv);
  exit:
 	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
 	if (priv->ibss_beacon)
 		dev_kfree_skb(priv->ibss_beacon);
 	priv->ibss_beacon = NULL;
 	/* clear out any free frames */
 	iwl_clear_free_frames(priv);
 }
 static void iwl_down(struct iwl_priv *priv)
 {
 	mutex_lock(&priv->mutex);
 	__iwl_down(priv);
 	mutex_unlock(&priv->mutex);
 	iwl_cancel_deferred_work(priv);
 }
 #define MAX_HW_RESTARTS 5
 static int __iwl_up(struct iwl_priv *priv)
 {
 	int i;
 	int ret;
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
 		IWL_WARNING("Exit pending; will not bring the NIC up\n");
 		return -EIO;
 	}
 	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
 		IWL_ERROR("ucode not available for device bringup\n");
 		return -EIO;
 	}
 	/* If platform's RF_KILL switch is NOT set to KILL */
 	if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
 		clear_bit(STATUS_RF_KILL_HW, &priv->status);
 	else
 		set_bit(STATUS_RF_KILL_HW, &priv->status);
 	if (iwl_is_rfkill(priv)) {
 		iwl_enable_interrupts(priv);
 		IWL_WARNING("Radio disabled by %s RF Kill switch\n",
 		    test_bit(STATUS_RF_KILL_HW, &priv->status) ? "HW" : "SW");
 		return 0;
 	}
 	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
 	ret = iwl_hw_nic_init(priv);
 	if (ret) {
 		IWL_ERROR("Unable to init nic\n");
 		return ret;
 	}
 	/* make sure rfkill handshake bits are cleared */
 	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
 	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
 		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
 	/* clear (again), then enable host interrupts */
 	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
 	iwl_enable_interrupts(priv);
 	/* really make sure rfkill handshake bits are cleared */
 	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
 	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
 	/* Copy original ucode data image from disk into backup cache.
 	 * This will be used to initialize the on-board processor's
 	 * data SRAM for a clean start when the runtime program first loads. */
 	memcpy(priv->ucode_data_backup.v_addr, priv->ucode_data.v_addr,
 	       priv->ucode_data.len);
 	for (i = 0; i < MAX_HW_RESTARTS; i++) {
 		iwl_clear_stations_table(priv);
 		/* load bootstrap state machine,
 		 * load bootstrap program into processor's memory,
 		 * prepare to load the "initialize" uCode */
 		ret = priv->cfg->ops->lib->load_ucode(priv);
 		if (ret) {
 			IWL_ERROR("Unable to set up bootstrap uCode: %d\n", ret);
 			continue;
 		}
 		/* Clear out the uCode error bit if it is set */
 		clear_bit(STATUS_FW_ERROR, &priv->status);
 		/* start card; "initialize" will load runtime ucode */
 		iwl_nic_start(priv);
 		IWL_DEBUG_INFO(DRV_NAME " is coming up\n");
 		return 0;
 	}
 	set_bit(STATUS_EXIT_PENDING, &priv->status);
 	__iwl_down(priv);
 	clear_bit(STATUS_EXIT_PENDING, &priv->status);
 	/* tried to restart and config the device for as long as our
 	 * patience could withstand */
 	IWL_ERROR("Unable to initialize device after %d attempts.\n", i);
 	return -EIO;
 }
 /*****************************************************************************
  *
  * Workqueue callbacks
  *
  *****************************************************************************/
 static void iwl_bg_init_alive_start(struct work_struct *data)
 {
 	struct iwl_priv *priv =
 	    container_of(data, struct iwl_priv, init_alive_start.work);
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 		return;
 	mutex_lock(&priv->mutex);
 	priv->cfg->ops->lib->init_alive_start(priv);
 	mutex_unlock(&priv->mutex);
 }
 static void iwl_bg_alive_start(struct work_struct *data)
 {
 	struct iwl_priv *priv =
 	    container_of(data, struct iwl_priv, alive_start.work);
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 		return;
 	mutex_lock(&priv->mutex);
 	iwl_alive_start(priv);
 	mutex_unlock(&priv->mutex);
 }
 static void iwl_bg_rf_kill(struct work_struct *work)
 {
 	struct iwl_priv *priv = container_of(work, struct iwl_priv, rf_kill);
 	wake_up_interruptible(&priv->wait_command_queue);
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 		return;
 	mutex_lock(&priv->mutex);
 	if (!iwl_is_rfkill(priv)) {
 		IWL_DEBUG(IWL_DL_RF_KILL,
 			  "HW and/or SW RF Kill no longer active, restarting "
 			  "device\n");
 		if (!test_bit(STATUS_EXIT_PENDING, &priv->status))
 			queue_work(priv->workqueue, &priv->restart);
 	} else {
 		/* make sure mac80211 stop sending Tx frame */
 		if (priv->mac80211_registered)
 			ieee80211_stop_queues(priv->hw);
 		if (!test_bit(STATUS_RF_KILL_HW, &priv->status))
 			IWL_DEBUG_RF_KILL("Can not turn radio back on - "
 					  "disabled by SW switch\n");
 		else
 			IWL_WARNING("Radio Frequency Kill Switch is On:\n"
 				    "Kill switch must be turned off for "
 				    "wireless networking to work.\n");
 	}
 	mutex_unlock(&priv->mutex);
 	iwl_rfkill_set_hw_state(priv);
 }
 static void iwl_bg_run_time_calib_work(struct work_struct *work)
 {
 	struct iwl_priv *priv = container_of(work, struct iwl_priv,
 			run_time_calib_work);
 	mutex_lock(&priv->mutex);
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
 	    test_bit(STATUS_SCANNING, &priv->status)) {
 		mutex_unlock(&priv->mutex);
 		return;
 	}
 	if (priv->start_calib) {
 		iwl_chain_noise_calibration(priv, &priv->statistics);
 		iwl_sensitivity_calibration(priv, &priv->statistics);
 	}
 	mutex_unlock(&priv->mutex);
 	return;
 }
 static void iwl_bg_up(struct work_struct *data)
 {
 	struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 		return;
 	mutex_lock(&priv->mutex);
 	__iwl_up(priv);
 	mutex_unlock(&priv->mutex);
 	iwl_rfkill_set_hw_state(priv);
 }
 static void iwl_bg_restart(struct work_struct *data)
 {
 	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 		return;
 	iwl_down(priv);
 	queue_work(priv->workqueue, &priv->up);
 }
 static void iwl_bg_rx_replenish(struct work_struct *data)
 {
 	struct iwl_priv *priv =
 	    container_of(data, struct iwl_priv, rx_replenish);
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 		return;
 	mutex_lock(&priv->mutex);
 	iwl_rx_replenish(priv);
 	mutex_unlock(&priv->mutex);
 }
 #define IWL_DELAY_NEXT_SCAN (HZ*2)
 static void iwl_post_associate(struct iwl_priv *priv)
 {
 	struct ieee80211_conf *conf = NULL;
 	int ret = 0;
 	unsigned long flags;
 	if (priv->iw_mode == NL80211_IFTYPE_AP) {
 		IWL_ERROR("%s Should not be called in AP mode\n", __func__);
 		return;
 	}
 	IWL_DEBUG_ASSOC("Associated as %d to: %pM\n",
 			priv->assoc_id, priv->active_rxon.bssid_addr);
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 		return;
 	if (!priv->vif || !priv->is_open)
 		return;
 	iwl_power_cancel_timeout(priv);
 	iwl_scan_cancel_timeout(priv, 200);
 	conf = ieee80211_get_hw_conf(priv->hw);
 	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 	iwl_commit_rxon(priv);
 	iwl_setup_rxon_timing(priv);
 	ret = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
 			      sizeof(priv->rxon_timing), &priv->rxon_timing);
 	if (ret)
 		IWL_WARNING("REPLY_RXON_TIMING failed - "
 			    "Attempting to continue.\n");
 	priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
 	iwl_set_rxon_ht(priv, &priv->current_ht_config);
 	iwl_set_rxon_chain(priv);
 	priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
 	IWL_DEBUG_ASSOC("assoc id %d beacon interval %d\n",
 			priv->assoc_id, priv->beacon_int);
 	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
 		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
 	else
 		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
 	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
 		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
 			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
 		else
 			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
 		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
 			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
 	}
 	iwl_commit_rxon(priv);
 	switch (priv->iw_mode) {
 	case NL80211_IFTYPE_STATION:
 		break;
 	case NL80211_IFTYPE_ADHOC:
 		/* assume default assoc id */
 		priv->assoc_id = 1;
 		iwl_rxon_add_station(priv, priv->bssid, 0);
 		iwl_send_beacon_cmd(priv);
 		break;
 	default:
 		IWL_ERROR("%s Should not be called in %d mode\n",
 			  __func__, priv->iw_mode);
 		break;
 	}
 	if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
 		priv->assoc_station_added = 1;
 	spin_lock_irqsave(&priv->lock, flags);
 	iwl_activate_qos(priv, 0);
 	spin_unlock_irqrestore(&priv->lock, flags);
 	/* the chain noise calibration will enabled PM upon completion
 	 * If chain noise has already been run, then we need to enable
 	 * power management here */
 	if (priv->chain_noise_data.state == IWL_CHAIN_NOISE_DONE)
 		iwl_power_enable_management(priv);
 	/* Enable Rx differential gain and sensitivity calibrations */
 	iwl_chain_noise_reset(priv);
 	priv->start_calib = 1;
 }
 /*****************************************************************************
  *
  * mac80211 entry point functions
  *
  *****************************************************************************/
 #define UCODE_READY_TIMEOUT	(4 * HZ)
 static int iwl_mac_start(struct ieee80211_hw *hw)
 {
 	struct iwl_priv *priv = hw->priv;
 	int ret;
 	u16 pci_cmd;
 	IWL_DEBUG_MAC80211("enter\n");
 	if (pci_enable_device(priv->pci_dev)) {
 		IWL_ERROR("Fail to pci_enable_device\n");
 		return -ENODEV;
 	}
 	pci_restore_state(priv->pci_dev);
 	pci_enable_msi(priv->pci_dev);
 	/* enable interrupts if needed: hw bug w/a */
 	pci_read_config_word(priv->pci_dev, PCI_COMMAND, &pci_cmd);
 	if (pci_cmd & PCI_COMMAND_INTX_DISABLE) {
 		pci_cmd &= ~PCI_COMMAND_INTX_DISABLE;
 		pci_write_config_word(priv->pci_dev, PCI_COMMAND, pci_cmd);
 	}
 	ret = request_irq(priv->pci_dev->irq, iwl_isr, IRQF_SHARED,
 			  DRV_NAME, priv);
 	if (ret) {
 		IWL_ERROR("Error allocating IRQ %d\n", priv->pci_dev->irq);
 		goto out_disable_msi;
 	}
 	/* we should be verifying the device is ready to be opened */
 	mutex_lock(&priv->mutex);
 	memset(&priv->staging_rxon, 0, sizeof(struct iwl_rxon_cmd));
 	/* fetch ucode file from disk, alloc and copy to bus-master buffers ...
 	 * ucode filename and max sizes are card-specific. */
 	if (!priv->ucode_code.len) {
 		ret = iwl_read_ucode(priv);
 		if (ret) {
 			IWL_ERROR("Could not read microcode: %d\n", ret);
 			mutex_unlock(&priv->mutex);
 			goto out_release_irq;
 		}
 	}
 	ret = __iwl_up(priv);
 	mutex_unlock(&priv->mutex);
 	iwl_rfkill_set_hw_state(priv);
 	if (ret)
 		goto out_release_irq;
 	if (iwl_is_rfkill(priv))
 		goto out;
 	IWL_DEBUG_INFO("Start UP work done.\n");
 	if (test_bit(STATUS_IN_SUSPEND, &priv->status))
 		return 0;
 	/* Wait for START_ALIVE from Run Time ucode. Otherwise callbacks from
 	 * mac80211 will not be run successfully. */
 	ret = wait_event_interruptible_timeout(priv->wait_command_queue,
 			test_bit(STATUS_READY, &priv->status),
 			UCODE_READY_TIMEOUT);
 	if (!ret) {
 		if (!test_bit(STATUS_READY, &priv->status)) {
 			IWL_ERROR("START_ALIVE timeout after %dms.\n",
 				jiffies_to_msecs(UCODE_READY_TIMEOUT));
 			ret = -ETIMEDOUT;
 			goto out_release_irq;
 		}
 	}
 out:
 	priv->is_open = 1;
 	IWL_DEBUG_MAC80211("leave\n");
 	return 0;
 out_release_irq:
 	free_irq(priv->pci_dev->irq, priv);
 out_disable_msi:
 	pci_disable_msi(priv->pci_dev);
 	pci_disable_device(priv->pci_dev);
 	priv->is_open = 0;
 	IWL_DEBUG_MAC80211("leave - failed\n");
 	return ret;
 }
 static void iwl_mac_stop(struct ieee80211_hw *hw)
 {
 	struct iwl_priv *priv = hw->priv;
 	IWL_DEBUG_MAC80211("enter\n");
 	if (!priv->is_open) {
 		IWL_DEBUG_MAC80211("leave - skip\n");
 		return;
 	}
 	priv->is_open = 0;
 	if (iwl_is_ready_rf(priv)) {
 		/* stop mac, cancel any scan request and clear
 		 * RXON_FILTER_ASSOC_MSK BIT
 		 */
 		mutex_lock(&priv->mutex);
 		iwl_scan_cancel_timeout(priv, 100);
 		mutex_unlock(&priv->mutex);
 	}
 	iwl_down(priv);
 	flush_workqueue(priv->workqueue);
 	free_irq(priv->pci_dev->irq, priv);
 	pci_disable_msi(priv->pci_dev);
 	pci_save_state(priv->pci_dev);
 	pci_disable_device(priv->pci_dev);
 	IWL_DEBUG_MAC80211("leave\n");
 }
 static int iwl_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 {
 	struct iwl_priv *priv = hw->priv;
 	IWL_DEBUG_MACDUMP("enter\n");
 	IWL_DEBUG_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
 		     ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
 	if (iwl_tx_skb(priv, skb))
 		dev_kfree_skb_any(skb);
 	IWL_DEBUG_MACDUMP("leave\n");
 	return 0;
 }
 static int iwl_mac_add_interface(struct ieee80211_hw *hw,
 				 struct ieee80211_if_init_conf *conf)
 {
 	struct iwl_priv *priv = hw->priv;
 	unsigned long flags;
 	IWL_DEBUG_MAC80211("enter: type %d\n", conf->type);
 	if (priv->vif) {
 		IWL_DEBUG_MAC80211("leave - vif != NULL\n");
 		return -EOPNOTSUPP;
 	}
 	spin_lock_irqsave(&priv->lock, flags);
 	priv->vif = conf->vif;
 	priv->iw_mode = conf->type;
 	spin_unlock_irqrestore(&priv->lock, flags);
 	mutex_lock(&priv->mutex);
 	if (conf->mac_addr) {
 		IWL_DEBUG_MAC80211("Set %pM\n", conf->mac_addr);
 		memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
 	}
 	if (iwl_set_mode(priv, conf->type) == -EAGAIN)
 		/* we are not ready, will run again when ready */
 		set_bit(STATUS_MODE_PENDING, &priv->status);
 	mutex_unlock(&priv->mutex);
 	IWL_DEBUG_MAC80211("leave\n");
 	return 0;
 }
 /**
  * iwl_mac_config - mac80211 config callback
  *
  * We ignore conf->flags & IEEE80211_CONF_SHORT_SLOT_TIME since it seems to
  * be set inappropriately and the driver currently sets the hardware up to
  * use it whenever needed.
  */
 static int iwl_mac_config(struct ieee80211_hw *hw, u32 changed)
 {
 	struct iwl_priv *priv = hw->priv;
 	const struct iwl_channel_info *ch_info;
 	struct ieee80211_conf *conf = &hw->conf;
 	unsigned long flags;
 	int ret = 0;
 	u16 channel;
 	mutex_lock(&priv->mutex);
 	IWL_DEBUG_MAC80211("enter to channel %d\n", conf->channel->hw_value);
 	priv->current_ht_config.is_ht = conf->ht.enabled;
 	if (conf->radio_enabled && iwl_radio_kill_sw_enable_radio(priv)) {
 		IWL_DEBUG_MAC80211("leave - RF-KILL - waiting for uCode\n");
 		goto out;
 	}
 	if (!conf->radio_enabled)
 		iwl_radio_kill_sw_disable_radio(priv);
 	if (!iwl_is_ready(priv)) {
 		IWL_DEBUG_MAC80211("leave - not ready\n");
 		ret = -EIO;
 		goto out;
 	}
 	if (unlikely(!priv->cfg->mod_params->disable_hw_scan &&
 		     test_bit(STATUS_SCANNING, &priv->status))) {
 		IWL_DEBUG_MAC80211("leave - scanning\n");
 		mutex_unlock(&priv->mutex);
 		return 0;
 	}
 	channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
 	ch_info = iwl_get_channel_info(priv, conf->channel->band, channel);
 	if (!is_channel_valid(ch_info)) {
 		IWL_DEBUG_MAC80211("leave - invalid channel\n");
 		ret = -EINVAL;
 		goto out;
 	}
 	if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
 	    !is_channel_ibss(ch_info)) {
 		IWL_ERROR("channel %d in band %d not IBSS channel\n",
 			conf->channel->hw_value, conf->channel->band);
 		ret = -EINVAL;
 		goto out;
 	}
 	spin_lock_irqsave(&priv->lock, flags);
 	/* if we are switching from ht to 2.4 clear flags
 	 * from any ht related info since 2.4 does not
 	 * support ht */
 	if ((le16_to_cpu(priv->staging_rxon.channel) != channel)
 #ifdef IEEE80211_CONF_CHANNEL_SWITCH
 	    && !(conf->flags & IEEE80211_CONF_CHANNEL_SWITCH)
 #endif
 	)
 		priv->staging_rxon.flags = 0;
 	iwl_set_rxon_channel(priv, conf->channel);
 	iwl_set_flags_for_band(priv, conf->channel->band);
 	/* The list of supported rates and rate mask can be different
 	 * for each band; since the band may have changed, reset
 	 * the rate mask to what mac80211 lists */
 	iwl_set_rate(priv);
 	spin_unlock_irqrestore(&priv->lock, flags);
 #ifdef IEEE80211_CONF_CHANNEL_SWITCH
 	if (conf->flags & IEEE80211_CONF_CHANNEL_SWITCH) {
 		iwl_hw_channel_switch(priv, conf->channel);
 		goto out;
 	}
 #endif
 	if (!conf->radio_enabled) {
 		IWL_DEBUG_MAC80211("leave - radio disabled\n");
 		goto out;
 	}
 	if (iwl_is_rfkill(priv)) {
 		IWL_DEBUG_MAC80211("leave - RF kill\n");
 		ret = -EIO;
 		goto out;
 	}
 	if (conf->flags & IEEE80211_CONF_PS)
 		ret = iwl_power_set_user_mode(priv, IWL_POWER_INDEX_3);
 	else
 		ret = iwl_power_set_user_mode(priv, IWL_POWER_MODE_CAM);
 	if (ret)
 		IWL_DEBUG_MAC80211("Error setting power level\n");
 	IWL_DEBUG_MAC80211("TX Power old=%d new=%d\n",
 			   priv->tx_power_user_lmt, conf->power_level);
 	iwl_set_tx_power(priv, conf->power_level, false);
 	iwl_set_rate(priv);
 	if (memcmp(&priv->active_rxon,
 		   &priv->staging_rxon, sizeof(priv->staging_rxon)))
 		iwl_commit_rxon(priv);
 	else
 		IWL_DEBUG_INFO("No re-sending same RXON configuration.\n");
 	IWL_DEBUG_MAC80211("leave\n");
 out:
 	mutex_unlock(&priv->mutex);
 	return ret;
 }
 static void iwl_config_ap(struct iwl_priv *priv)
 {
 	int ret = 0;
 	unsigned long flags;
 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
 		return;
 	/* The following should be done only at AP bring up */
 	if (!iwl_is_associated(priv)) {
 		/* RXON - unassoc (to set timing command) */
 		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 		iwl_commit_rxon(priv);
 		/* RXON Timing */
 		iwl_setup_rxon_timing(priv);
 		ret = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
 				sizeof(priv->rxon_timing), &priv->rxon_timing);
 		if (ret)
 			IWL_WARNING("REPLY_RXON_TIMING failed - "
 					"Attempting to continue.\n");
 		iwl_set_rxon_chain(priv);
 		/* FIXME: what should be the assoc_id for AP? */
 		priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
 		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
 			priv->staging_rxon.flags |=
 				RXON_FLG_SHORT_PREAMBLE_MSK;
 		else
 			priv->staging_rxon.flags &=
 				~RXON_FLG_SHORT_PREAMBLE_MSK;
 		if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
 			if (priv->assoc_capability &
 				WLAN_CAPABILITY_SHORT_SLOT_TIME)
 				priv->staging_rxon.flags |=
 					RXON_FLG_SHORT_SLOT_MSK;
 			else
 				priv->staging_rxon.flags &=
 					~RXON_FLG_SHORT_SLOT_MSK;
 			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
 				priv->staging_rxon.flags &=
 					~RXON_FLG_SHORT_SLOT_MSK;
 		}
 		/* restore RXON assoc */
 		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
 		iwl_commit_rxon(priv);
 		spin_lock_irqsave(&priv->lock, flags);
 		iwl_activate_qos(priv, 1);
 		spin_unlock_irqrestore(&priv->lock, flags);
 		iwl_rxon_add_station(priv, iwl_bcast_addr, 0);
 	}
 	iwl_send_beacon_cmd(priv);
 	/* FIXME - we need to add code here to detect a totally new
 	 * configuration, reset the AP, unassoc, rxon timing, assoc,
 	 * clear sta table, add BCAST sta... */
 }
 static int iwl_mac_config_interface(struct ieee80211_hw *hw,
 					struct ieee80211_vif *vif,
 				    struct ieee80211_if_conf *conf)
 {
 	struct iwl_priv *priv = hw->priv;
 	int rc;
 	if (conf == NULL)
 		return -EIO;
 	if (priv->vif != vif) {
 		IWL_DEBUG_MAC80211("leave - priv->vif != vif\n");
 		return 0;
 	}
 	if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
 	    conf->changed & IEEE80211_IFCC_BEACON) {
 		struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
 		if (!beacon)
 			return -ENOMEM;
 		mutex_lock(&priv->mutex);
 		rc = iwl_mac_beacon_update(hw, beacon);
 		mutex_unlock(&priv->mutex);
 		if (rc)
 			return rc;
 	}
 	if (!iwl_is_alive(priv))
 		return -EAGAIN;
 	mutex_lock(&priv->mutex);
 	if (conf->bssid)
 		IWL_DEBUG_MAC80211("bssid: %pM\n", conf->bssid);
 /*
  * very dubious code was here; the probe filtering flag is never set:
  *
 	if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
 	    !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
  */
 	if (priv->iw_mode == NL80211_IFTYPE_AP) {
 		if (!conf->bssid) {
 			conf->bssid = priv->mac_addr;
 			memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
 			IWL_DEBUG_MAC80211("bssid was set to: %pM\n",
 					   conf->bssid);
 		}
 		if (priv->ibss_beacon)
 			dev_kfree_skb(priv->ibss_beacon);
 		priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
 	}
 	if (iwl_is_rfkill(priv))
 		goto done;
 	if (conf->bssid && !is_zero_ether_addr(conf->bssid) &&
 	    !is_multicast_ether_addr(conf->bssid)) {
 		/* If there is currently a HW scan going on in the background
 		 * then we need to cancel it else the RXON below will fail. */
 		if (iwl_scan_cancel_timeout(priv, 100)) {
 			IWL_WARNING("Aborted scan still in progress "
 				    "after 100ms\n");
 			IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
 			mutex_unlock(&priv->mutex);
 			return -EAGAIN;
 		}
 		memcpy(priv->staging_rxon.bssid_addr, conf->bssid, ETH_ALEN);
 		/* TODO: Audit driver for usage of these members and see
 		 * if mac80211 deprecates them (priv->bssid looks like it
 		 * shouldn't be there, but I haven't scanned the IBSS code
 		 * to verify) - jpk */
 		memcpy(priv->bssid, conf->bssid, ETH_ALEN);
 		if (priv->iw_mode == NL80211_IFTYPE_AP)
 			iwl_config_ap(priv);
 		else {
 			rc = iwl_commit_rxon(priv);
 			if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
 				iwl_rxon_add_station(
 					priv, priv->active_rxon.bssid_addr, 1);
 		}
 	} else {
 		iwl_scan_cancel_timeout(priv, 100);
 		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 		iwl_commit_rxon(priv);
 	}
  done:
 	IWL_DEBUG_MAC80211("leave\n");
 	mutex_unlock(&priv->mutex);
 	return 0;
 }
 static void iwl_configure_filter(struct ieee80211_hw *hw,
 				 unsigned int changed_flags,
 				 unsigned int *total_flags,
 				 int mc_count, struct dev_addr_list *mc_list)
 {
 	struct iwl_priv *priv = hw->priv;
 	__le32 *filter_flags = &priv->staging_rxon.filter_flags;
 	IWL_DEBUG_MAC80211("Enter: changed: 0x%x, total: 0x%x\n",
 			changed_flags, *total_flags);
 	if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) {
 		if (*total_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))
 			*filter_flags |= RXON_FILTER_PROMISC_MSK;
 		else
 			*filter_flags &= ~RXON_FILTER_PROMISC_MSK;
 	}
 	if (changed_flags & FIF_ALLMULTI) {
 		if (*total_flags & FIF_ALLMULTI)
 			*filter_flags |= RXON_FILTER_ACCEPT_GRP_MSK;
 		else
 			*filter_flags &= ~RXON_FILTER_ACCEPT_GRP_MSK;
 	}
 	if (changed_flags & FIF_CONTROL) {
 		if (*total_flags & FIF_CONTROL)
 			*filter_flags |= RXON_FILTER_CTL2HOST_MSK;
 		else
 			*filter_flags &= ~RXON_FILTER_CTL2HOST_MSK;
 	}
 	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
 		if (*total_flags & FIF_BCN_PRBRESP_PROMISC)
 			*filter_flags |= RXON_FILTER_BCON_AWARE_MSK;
 		else
 			*filter_flags &= ~RXON_FILTER_BCON_AWARE_MSK;
 	}
 	/* We avoid iwl_commit_rxon here to commit the new filter flags
 	 * since mac80211 will call ieee80211_hw_config immediately.
 	 * (mc_list is not supported at this time). Otherwise, we need to
 	 * queue a background iwl_commit_rxon work.
 	 */
 	*total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
 			FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
 }
 static void iwl_mac_remove_interface(struct ieee80211_hw *hw,
 				     struct ieee80211_if_init_conf *conf)
 {
 	struct iwl_priv *priv = hw->priv;
 	IWL_DEBUG_MAC80211("enter\n");
 	mutex_lock(&priv->mutex);
 	if (iwl_is_ready_rf(priv)) {
 		iwl_scan_cancel_timeout(priv, 100);
 		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 		iwl_commit_rxon(priv);
 	}
 	if (priv->vif == conf->vif) {
 		priv->vif = NULL;
 		memset(priv->bssid, 0, ETH_ALEN);
 	}
 	mutex_unlock(&priv->mutex);
 	IWL_DEBUG_MAC80211("leave\n");
 }
 #define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)
 static void iwl_bss_info_changed(struct ieee80211_hw *hw,
 				     struct ieee80211_vif *vif,
 				     struct ieee80211_bss_conf *bss_conf,
 				     u32 changes)
 {
 	struct iwl_priv *priv = hw->priv;
 	IWL_DEBUG_MAC80211("changes = 0x%X\n", changes);
 	if (changes & BSS_CHANGED_ERP_PREAMBLE) {
 		IWL_DEBUG_MAC80211("ERP_PREAMBLE %d\n",
 				   bss_conf->use_short_preamble);
 		if (bss_conf->use_short_preamble)
 			priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
 		else
 			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
 	}
 	if (changes & BSS_CHANGED_ERP_CTS_PROT) {
 		IWL_DEBUG_MAC80211("ERP_CTS %d\n", bss_conf->use_cts_prot);
 		if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
 			priv->staging_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
 		else
 			priv->staging_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
 	}
 	if (changes & BSS_CHANGED_HT) {
 		iwl_ht_conf(priv, bss_conf);
 		iwl_set_rxon_chain(priv);
 	}
 	if (changes & BSS_CHANGED_ASSOC) {
 		IWL_DEBUG_MAC80211("ASSOC %d\n", bss_conf->assoc);
 		/* This should never happen as this function should
 		 * never be called from interrupt context. */
 		if (WARN_ON_ONCE(in_interrupt()))
 			return;
 		if (bss_conf->assoc) {
 			priv->assoc_id = bss_conf->aid;
 			priv->beacon_int = bss_conf->beacon_int;
 			priv->power_data.dtim_period = bss_conf->dtim_period;
 			priv->timestamp = bss_conf->timestamp;
 			priv->assoc_capability = bss_conf->assoc_capability;
 			/* we have just associated, don't start scan too early
 			 * leave time for EAPOL exchange to complete
 			 */
 			priv->next_scan_jiffies = jiffies +
 					IWL_DELAY_NEXT_SCAN_AFTER_ASSOC;
 			mutex_lock(&priv->mutex);
 			iwl_post_associate(priv);
 			mutex_unlock(&priv->mutex);
 		} else {
 			priv->assoc_id = 0;
 			IWL_DEBUG_MAC80211("DISASSOC %d\n", bss_conf->assoc);
 		}
 	} else if (changes && iwl_is_associated(priv) && priv->assoc_id) {
 			IWL_DEBUG_MAC80211("Associated Changes %d\n", changes);
 			iwl_send_rxon_assoc(priv);
 	}
 }
 static int iwl_mac_hw_scan(struct ieee80211_hw *hw, u8 *ssid, size_t ssid_len)
 {
 	unsigned long flags;
 	struct iwl_priv *priv = hw->priv;
 	int ret;
 	IWL_DEBUG_MAC80211("enter\n");
 	mutex_lock(&priv->mutex);
 	spin_lock_irqsave(&priv->lock, flags);
 	if (!iwl_is_ready_rf(priv)) {
 		ret = -EIO;
 		IWL_DEBUG_MAC80211("leave - not ready or exit pending\n");
 		goto out_unlock;
 	}
 	/* We don't schedule scan within next_scan_jiffies period.
 	 * Avoid scanning during possible EAPOL exchange, return
 	 * success immediately.
 	 */
 	if (priv->next_scan_jiffies &&
 	    time_after(priv->next_scan_jiffies, jiffies)) {
 		IWL_DEBUG_SCAN("scan rejected: within next scan period\n");
 		queue_work(priv->workqueue, &priv->scan_completed);
 		ret = 0;
 		goto out_unlock;
 	}
 	/* if we just finished scan ask for delay */
 	if (iwl_is_associated(priv) && priv->last_scan_jiffies &&
 	    time_after(priv->last_scan_jiffies + IWL_DELAY_NEXT_SCAN, jiffies)) {
 		IWL_DEBUG_SCAN("scan rejected: within previous scan period\n");
 		queue_work(priv->workqueue, &priv->scan_completed);
 		ret = 0;
 		goto out_unlock;
 	}
 	if (ssid_len) {
 		priv->one_direct_scan = 1;
 		priv->direct_ssid_len =  min_t(u8, ssid_len, IW_ESSID_MAX_SIZE);
 		memcpy(priv->direct_ssid, ssid, priv->direct_ssid_len);
 	} else {
 		priv->one_direct_scan = 0;
 	}
 	ret = iwl_scan_initiate(priv);
 	IWL_DEBUG_MAC80211("leave\n");
 out_unlock:
 	spin_unlock_irqrestore(&priv->lock, flags);
 	mutex_unlock(&priv->mutex);
 	return ret;
 }
 static void iwl_mac_update_tkip_key(struct ieee80211_hw *hw,
 			struct ieee80211_key_conf *keyconf, const u8 *addr,
 			u32 iv32, u16 *phase1key)
 {
 	struct iwl_priv *priv = hw->priv;
 	IWL_DEBUG_MAC80211("enter\n");
 	iwl_update_tkip_key(priv, keyconf, addr, iv32, phase1key);
 	IWL_DEBUG_MAC80211("leave\n");
 }
 static int iwl_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
 			   const u8 *local_addr, const u8 *addr,
 			   struct ieee80211_key_conf *key)
 {
 	struct iwl_priv *priv = hw->priv;
 	int ret = 0;
 	u8 sta_id = IWL_INVALID_STATION;
 	u8 is_default_wep_key = 0;
 	IWL_DEBUG_MAC80211("enter\n");
 	if (priv->hw_params.sw_crypto) {
 		IWL_DEBUG_MAC80211("leave - hwcrypto disabled\n");
 		return -EOPNOTSUPP;
 	}
 	if (is_zero_ether_addr(addr))
 		/* only support pairwise keys */
 		return -EOPNOTSUPP;
 	sta_id = iwl_find_station(priv, addr);
 	if (sta_id == IWL_INVALID_STATION) {
 		IWL_DEBUG_MAC80211("leave - %pM not in station map.\n",
 				   addr);
 		return -EINVAL;
 	}
 	mutex_lock(&priv->mutex);
 	iwl_scan_cancel_timeout(priv, 100);
 	mutex_unlock(&priv->mutex);
 	/* If we are getting WEP group key and we didn't receive any key mapping
 	 * so far, we are in legacy wep mode (group key only), otherwise we are
 	 * in 1X mode.
 	 * In legacy wep mode, we use another host command to the uCode */
 	if (key->alg == ALG_WEP && sta_id == priv->hw_params.bcast_sta_id &&
 		priv->iw_mode != NL80211_IFTYPE_AP) {
 		if (cmd == SET_KEY)
 			is_default_wep_key = !priv->key_mapping_key;
 		else
 			is_default_wep_key =
 					(key->hw_key_idx == HW_KEY_DEFAULT);
 	}
 	switch (cmd) {
 	case SET_KEY:
 		if (is_default_wep_key)
 			ret = iwl_set_default_wep_key(priv, key);
 		else
 			ret = iwl_set_dynamic_key(priv, key, sta_id);
 		IWL_DEBUG_MAC80211("enable hwcrypto key\n");
 		break;
 	case DISABLE_KEY:
 		if (is_default_wep_key)
 			ret = iwl_remove_default_wep_key(priv, key);
 		else
 			ret = iwl_remove_dynamic_key(priv, key, sta_id);
 		IWL_DEBUG_MAC80211("disable hwcrypto key\n");
 		break;
 	default:
 		ret = -EINVAL;
 	}
 	IWL_DEBUG_MAC80211("leave\n");
 	return ret;
 }
 static int iwl_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
 			   const struct ieee80211_tx_queue_params *params)
 {
 	struct iwl_priv *priv = hw->priv;
 	unsigned long flags;
 	int q;
 	IWL_DEBUG_MAC80211("enter\n");
 	if (!iwl_is_ready_rf(priv)) {
 		IWL_DEBUG_MAC80211("leave - RF not ready\n");
 		return -EIO;
 	}
 	if (queue >= AC_NUM) {
 		IWL_DEBUG_MAC80211("leave - queue >= AC_NUM %d\n", queue);
 		return 0;
 	}
 	q = AC_NUM - 1 - queue;
 	spin_lock_irqsave(&priv->lock, flags);
 	priv->qos_data.def_qos_parm.ac[q].cw_min = cpu_to_le16(params->cw_min);
 	priv->qos_data.def_qos_parm.ac[q].cw_max = cpu_to_le16(params->cw_max);
 	priv->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
 	priv->qos_data.def_qos_parm.ac[q].edca_txop =
 			cpu_to_le16((params->txop * 32));
 	priv->qos_data.def_qos_parm.ac[q].reserved1 = 0;
 	priv->qos_data.qos_active = 1;
 	if (priv->iw_mode == NL80211_IFTYPE_AP)
 		iwl_activate_qos(priv, 1);
 	else if (priv->assoc_id && iwl_is_associated(priv))
 		iwl_activate_qos(priv, 0);
 	spin_unlock_irqrestore(&priv->lock, flags);
 	IWL_DEBUG_MAC80211("leave\n");
 	return 0;
 }
 static int iwl_mac_ampdu_action(struct ieee80211_hw *hw,
 			     enum ieee80211_ampdu_mlme_action action,
 			     struct ieee80211_sta *sta, u16 tid, u16 *ssn)
 {
 	struct iwl_priv *priv = hw->priv;
 	IWL_DEBUG_HT("A-MPDU action on addr %pM tid %d\n",
 		     sta->addr, tid);
 	if (!(priv->cfg->sku & IWL_SKU_N))
 		return -EACCES;
 	switch (action) {
 	case IEEE80211_AMPDU_RX_START:
 		IWL_DEBUG_HT("start Rx\n");
 		return iwl_sta_rx_agg_start(priv, sta->addr, tid, *ssn);
 	case IEEE80211_AMPDU_RX_STOP:
 		IWL_DEBUG_HT("stop Rx\n");
 		return iwl_sta_rx_agg_stop(priv, sta->addr, tid);
 	case IEEE80211_AMPDU_TX_START:
 		IWL_DEBUG_HT("start Tx\n");
 		return iwl_tx_agg_start(priv, sta->addr, tid, ssn);
 	case IEEE80211_AMPDU_TX_STOP:
 		IWL_DEBUG_HT("stop Tx\n");
 		return iwl_tx_agg_stop(priv, sta->addr, tid);
 	default:
 		IWL_DEBUG_HT("unknown\n");
 		return -EINVAL;
 		break;
 	}
 	return 0;
 }
 static int iwl_mac_get_tx_stats(struct ieee80211_hw *hw,
 				struct ieee80211_tx_queue_stats *stats)
 {
 	struct iwl_priv *priv = hw->priv;
 	int i, avail;
 	struct iwl_tx_queue *txq;
 	struct iwl_queue *q;
 	unsigned long flags;
 	IWL_DEBUG_MAC80211("enter\n");
 	if (!iwl_is_ready_rf(priv)) {
 		IWL_DEBUG_MAC80211("leave - RF not ready\n");
 		return -EIO;
 	}
 	spin_lock_irqsave(&priv->lock, flags);
 	for (i = 0; i < AC_NUM; i++) {
 		txq = &priv->txq[i];
 		q = &txq->q;
 		avail = iwl_queue_space(q);
 		stats[i].len = q->n_window - avail;
 		stats[i].limit = q->n_window - q->high_mark;
 		stats[i].count = q->n_window;
 	}
 	spin_unlock_irqrestore(&priv->lock, flags);
 	IWL_DEBUG_MAC80211("leave\n");
 	return 0;
 }
 static int iwl_mac_get_stats(struct ieee80211_hw *hw,
 			     struct ieee80211_low_level_stats *stats)
 {
 	struct iwl_priv *priv = hw->priv;
 	priv = hw->priv;
 	IWL_DEBUG_MAC80211("enter\n");
 	IWL_DEBUG_MAC80211("leave\n");
 	return 0;
 }
 static void iwl_mac_reset_tsf(struct ieee80211_hw *hw)
 {
 	struct iwl_priv *priv = hw->priv;
 	unsigned long flags;
 	mutex_lock(&priv->mutex);
 	IWL_DEBUG_MAC80211("enter\n");
 	spin_lock_irqsave(&priv->lock, flags);
 	memset(&priv->current_ht_config, 0, sizeof(struct iwl_ht_info));
 	spin_unlock_irqrestore(&priv->lock, flags);
 	iwl_reset_qos(priv);
 	spin_lock_irqsave(&priv->lock, flags);
 	priv->assoc_id = 0;
 	priv->assoc_capability = 0;
 	priv->assoc_station_added = 0;
 	/* new association get rid of ibss beacon skb */
 	if (priv->ibss_beacon)
 		dev_kfree_skb(priv->ibss_beacon);
 	priv->ibss_beacon = NULL;
 	priv->beacon_int = priv->hw->conf.beacon_int;
 	priv->timestamp = 0;
 	if ((priv->iw_mode == NL80211_IFTYPE_STATION))
 		priv->beacon_int = 0;
 	spin_unlock_irqrestore(&priv->lock, flags);
 	if (!iwl_is_ready_rf(priv)) {
 		IWL_DEBUG_MAC80211("leave - not ready\n");
 		mutex_unlock(&priv->mutex);
 		return;
 	}
 	/* we are restarting association process
 	 * clear RXON_FILTER_ASSOC_MSK bit
 	 */
 	if (priv->iw_mode != NL80211_IFTYPE_AP) {
 		iwl_scan_cancel_timeout(priv, 100);
 		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
 		iwl_commit_rxon(priv);
 	}
 	iwl_power_update_mode(priv, 0);
 	/* Per mac80211.h: This is only used in IBSS mode... */
 	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
 		/* switch to CAM during association period.
 		 * the ucode will block any association/authentication
 		 * frome during assiciation period if it can not hear
 		 * the AP because of PM. the timer enable PM back is
 		 * association do not complete
 		 */
 		if (priv->hw->conf.channel->flags & (IEEE80211_CHAN_PASSIVE_SCAN |
 						     IEEE80211_CHAN_RADAR))
 				iwl_power_disable_management(priv, 3000);
 		IWL_DEBUG_MAC80211("leave - not in IBSS\n");
 		mutex_unlock(&priv->mutex);
 		return;
 	}
 	iwl_set_rate(priv);
 	mutex_unlock(&priv->mutex);
 	IWL_DEBUG_MAC80211("leave\n");
 }
 static int iwl_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
 {
 	struct iwl_priv *priv = hw->priv;
 	unsigned long flags;
 	__le64 timestamp;
 	IWL_DEBUG_MAC80211("enter\n");
 	if (!iwl_is_ready_rf(priv)) {
 		IWL_DEBUG_MAC80211("leave - RF not ready\n");
 		return -EIO;
 	}
 	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
 		IWL_DEBUG_MAC80211("leave - not IBSS\n");
 		return -EIO;
 	}
 	spin_lock_irqsave(&priv->lock, flags);
 	if (priv->ibss_beacon)
 		dev_kfree_skb(priv->ibss_beacon);
 	priv->ibss_beacon = skb;
 	priv->assoc_id = 0;
 	timestamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
 	priv->timestamp = le64_to_cpu(timestamp);
 	IWL_DEBUG_MAC80211("leave\n");
 	spin_unlock_irqrestore(&priv->lock, flags);
 	iwl_reset_qos(priv);
 	iwl_post_associate(priv);
 	return 0;
 }
 /*****************************************************************************
  *
  * sysfs attributes
  *
  *****************************************************************************/
 #ifdef CONFIG_IWLWIFI_DEBUG
 /*
  * The following adds a new attribute to the sysfs representation
  * of this device driver (i.e. a new file in /sys/bus/pci/drivers/iwl/)
  * used for controlling the debug level.
  *
  * See the level definitions in iwl for details.
  */
 static ssize_t show_debug_level(struct device *d,
 				struct device_attribute *attr, char *buf)
 {
 	struct iwl_priv *priv = d->driver_data;
 	return sprintf(buf, "0x%08X\n", priv->debug_level);
 }
 static ssize_t store_debug_level(struct device *d,
 				struct device_attribute *attr,
 				 const char *buf, size_t count)
 {
 	struct iwl_priv *priv = d->driver_data;
 	unsigned long val;
 	int ret;
 	ret = strict_strtoul(buf, 0, &val);
 	if (ret)
 		printk(KERN_INFO DRV_NAME
 		       ": %s is not in hex or decimal form.\n", buf);
 	else
 		priv->debug_level = val;
 	return strnlen(buf, count);
 }
 static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
 			show_debug_level, store_debug_level);
 #endif /* CONFIG_IWLWIFI_DEBUG */
 static ssize_t show_version(struct device *d,
 				struct device_attribute *attr, char *buf)
 {
 	struct iwl_priv *priv = d->driver_data;
 	struct iwl_alive_resp *palive = &priv->card_alive;
 	ssize_t pos = 0;
 	u16 eeprom_ver;
 	if (palive->is_valid)
 		pos += sprintf(buf + pos,
 				"fw version: 0x%01X.0x%01X.0x%01X.0x%01X\n"
 				"fw type: 0x%01X 0x%01X\n",
 				palive->ucode_major, palive->ucode_minor,
 				palive->sw_rev[0], palive->sw_rev[1],
 				palive->ver_type, palive->ver_subtype);
 	else
 		pos += sprintf(buf + pos, "fw not loaded\n");
 	if (priv->eeprom) {
 		eeprom_ver = iwl_eeprom_query16(priv, EEPROM_VERSION);
 		pos += sprintf(buf + pos, "EEPROM version: 0x%x\n",
 				 eeprom_ver);
 	} else {
 		pos += sprintf(buf + pos, "EEPROM not initialzed\n");
 	}
 	return pos;
 }
 static DEVICE_ATTR(version, S_IWUSR | S_IRUGO, show_version, NULL);
 static ssize_t show_temperature(struct device *d,
 				struct device_attribute *attr, char *buf)
 {
 	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
 	if (!iwl_is_alive(priv))
 		return -EAGAIN;
 	return sprintf(buf, "%d\n", priv->temperature);
 }
 static DEVICE_ATTR(temperature, S_IRUGO, show_temperature, NULL);
 static ssize_t show_tx_power(struct device *d,
 			     struct device_attribute *attr, char *buf)
 {
 	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
 	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
 }
 static ssize_t store_tx_power(struct device *d,
 			      struct device_attribute *attr,
 			      const char *buf, size_t count)
 {
 	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
 	unsigned long val;
 	int ret;
 	ret = strict_strtoul(buf, 10, &val);
 	if (ret)
 		printk(KERN_INFO DRV_NAME
 		       ": %s is not in decimal form.\n", buf);
 	else
 		iwl_set_tx_power(priv, val, false);
 	return count;
 }
 static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, show_tx_power, store_tx_power);
 static ssize_t show_flags(struct device *d,
 			  struct device_attribute *attr, char *buf)
 {
 	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
 	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
 }
 static ssize_t store_flags(struct device *d,
 			   struct device_attribute *attr,
 			   const char *buf, size_t count)
 {
 	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
 	unsigned long val;
 	u32 flags;
 	int ret = strict_strtoul(buf, 0, &val);
 	if (ret)
 		return ret;
 	flags = (u32)val;
 	mutex_lock(&priv->mutex);
 	if (le32_to_cpu(priv->staging_rxon.flags) != flags) {
 		/* Cancel any currently running scans... */
 		if (iwl_scan_cancel_timeout(priv, 100))
 			IWL_WARNING("Could not cancel scan.\n");
 		else {
 			IWL_DEBUG_INFO("Commit rxon.flags = 0x%04X\n", flags);
 			priv->staging_rxon.flags = cpu_to_le32(flags);
 			iwl_commit_rxon(priv);
 		}
 	}
 	mutex_unlock(&priv->mutex);
 	return count;
 }
 static DEVICE_ATTR(flags, S_IWUSR | S_IRUGO, show_flags, store_flags);
 static ssize_t show_filter_flags(struct device *d,
 				 struct device_attribute *attr, char *buf)
 {
 	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
 	return sprintf(buf, "0x%04X\n",
 		le32_to_cpu(priv->active_rxon.filter_flags));
 }
 static ssize_t store_filter_flags(struct device *d,
 				  struct device_attribute *attr,
 				  const char *buf, size_t count)
 {
 	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
 	unsigned long val;
 	u32 filter_flags;
 	int ret = strict_strtoul(buf, 0, &val);
 	if (ret)
 		return ret;
 	filter_flags = (u32)val;
 	mutex_lock(&priv->mutex);
 	if (le32_to_cpu(priv->staging_rxon.filter_flags) != filter_flags) {
 		/* Cancel any currently running scans... */
 		if (iwl_scan_cancel_timeout(priv, 100))
 			IWL_WARNING("Could not cancel scan.\n");
 		else {
 			IWL_DEBUG_INFO("Committing rxon.filter_flags = "
 				       "0x%04X\n", filter_flags);
 			priv->staging_rxon.filter_flags =
 				cpu_to_le32(filter_flags);
 			iwl_commit_rxon(priv);
 		}
 	}
 	mutex_unlock(&priv->mutex);
 	return count;
 }
 static DEVICE_ATTR(filter_flags, S_IWUSR | S_IRUGO, show_filter_flags,
 		   store_filter_flags);
 static ssize_t store_retry_rate(struct device *d,
 				struct device_attribute *attr,
 				const char *buf, size_t count)
 {
 	struct iwl_priv *priv = dev_get_drvdata(d);
 	long val;
 	int ret  = strict_strtol(buf, 10, &val);
 	if (!ret)
 		return ret;
 	priv->retry_rate = (val > 0) ? val : 1;
 	return count;
 }
 static ssize_t show_retry_rate(struct device *d,
 			       struct device_attribute *attr, char *buf)
 {
 	struct iwl_priv *priv = dev_get_drvdata(d);
 	return sprintf(buf, "%d", priv->retry_rate);
 }
 static DEVICE_ATTR(retry_rate, S_IWUSR | S_IRUSR, show_retry_rate,
 		   store_retry_rate);
 static ssize_t store_power_level(struct device *d,
 				 struct device_attribute *attr,
 				 const char *buf, size_t count)
 {
 	struct iwl_priv *priv = dev_get_drvdata(d);
 	int ret;
 	unsigned long mode;
 	mutex_lock(&priv->mutex);
 	if (!iwl_is_ready(priv)) {
 		ret = -EAGAIN;
 		goto out;
 	}
 	ret = strict_strtoul(buf, 10, &mode);
 	if (ret)
 		goto out;
 	ret = iwl_power_set_user_mode(priv, mode);
 	if (ret) {
 		IWL_DEBUG_MAC80211("failed setting power mode.\n");
 		goto out;
 	}
 	ret = count;
  out:
 	mutex_unlock(&priv->mutex);
 	return ret;
 }
 static ssize_t show_power_level(struct device *d,
 				struct device_attribute *attr, char *buf)
 {
 	struct iwl_priv *priv = dev_get_drvdata(d);
 	int mode = priv->power_data.user_power_setting;
 	int system = priv->power_data.system_power_setting;
 	int level = priv->power_data.power_mode;
 	char *p = buf;
 	switch (system) {
 	case IWL_POWER_SYS_AUTO:
 		p += sprintf(p, "SYSTEM:auto");
 		break;
 	case IWL_POWER_SYS_AC:
 		p += sprintf(p, "SYSTEM:ac");
 		break;
 	case IWL_POWER_SYS_BATTERY:
 		p += sprintf(p, "SYSTEM:battery");
 		break;
 	}
 	p += sprintf(p, "\tMODE:%s", (mode < IWL_POWER_AUTO) ?
 			"fixed" : "auto");
 	p += sprintf(p, "\tINDEX:%d", level);
 	p += sprintf(p, "\n");
 	return p - buf + 1;
 }
 static DEVICE_ATTR(power_level, S_IWUSR | S_IRUSR, show_power_level,
 		   store_power_level);
 static ssize_t show_statistics(struct device *d,
 			       struct device_attribute *attr, char *buf)
 {
 	struct iwl_priv *priv = dev_get_drvdata(d);
 	u32 size = sizeof(struct iwl_notif_statistics);
 	u32 len = 0, ofs = 0;
 	u8 *data = (u8 *)&priv->statistics;
 	int rc = 0;
 	if (!iwl_is_alive(priv))
 		return -EAGAIN;
 	mutex_lock(&priv->mutex);
 	rc = iwl_send_statistics_request(priv, 0);
 	mutex_unlock(&priv->mutex);
 	if (rc) {
 		len = sprintf(buf,
 			      "Error sending statistics request: 0x%08X\n", rc);
 		return len;
 	}
 	while (size && (PAGE_SIZE - len)) {
 		hex_dump_to_buffer(data + ofs, size, 16, 1, buf + len,
 				   PAGE_SIZE - len, 1);
 		len = strlen(buf);
 		if (PAGE_SIZE - len)
 			buf[len++] = '\n';
 		ofs += 16;
 		size -= min(size, 16U);
 	}
 	return len;
 }
 static DEVICE_ATTR(statistics, S_IRUGO, show_statistics, NULL);
 static ssize_t show_status(struct device *d,
 			   struct device_attribute *attr, char *buf)
 {
 	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
 	if (!iwl_is_alive(priv))
 		return -EAGAIN;
 	return sprintf(buf, "0x%08x\n", (int)priv->status);
 }
 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
 /*****************************************************************************
  *
  * driver setup and teardown
  *
  *****************************************************************************/
 static void iwl_setup_deferred_work(struct iwl_priv *priv)
 {
 	priv->workqueue = create_workqueue(DRV_NAME);
 	init_waitqueue_head(&priv->wait_command_queue);
 	INIT_WORK(&priv->up, iwl_bg_up);
 	INIT_WORK(&priv->restart, iwl_bg_restart);
 	INIT_WORK(&priv->rx_replenish, iwl_bg_rx_replenish);
 	INIT_WORK(&priv->rf_kill, iwl_bg_rf_kill);
 	INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
 	INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
 	INIT_DELAYED_WORK(&priv->init_alive_start, iwl_bg_init_alive_start);
 	INIT_DELAYED_WORK(&priv->alive_start, iwl_bg_alive_start);
 	iwl_setup_scan_deferred_work(priv);
 	iwl_setup_power_deferred_work(priv);
 	if (priv->cfg->ops->lib->setup_deferred_work)
 		priv->cfg->ops->lib->setup_deferred_work(priv);
 	init_timer(&priv->statistics_periodic);
 	priv->statistics_periodic.data = (unsigned long)priv;
 	priv->statistics_periodic.function = iwl_bg_statistics_periodic;
 	tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
 		     iwl_irq_tasklet, (unsigned long)priv);
 }
 static void iwl_cancel_deferred_work(struct iwl_priv *priv)
 {
 	if (priv->cfg->ops->lib->cancel_deferred_work)
 		priv->cfg->ops->lib->cancel_deferred_work(priv);
 	cancel_delayed_work_sync(&priv->init_alive_start);
 	cancel_delayed_work(&priv->scan_check);
 	cancel_delayed_work_sync(&priv->set_power_save);
 	cancel_delayed_work(&priv->alive_start);
 	cancel_work_sync(&priv->beacon_update);
 	del_timer_sync(&priv->statistics_periodic);
 }
 static struct attribute *iwl_sysfs_entries[] = {
 	&dev_attr_flags.attr,
 	&dev_attr_filter_flags.attr,
 	&dev_attr_power_level.attr,
 	&dev_attr_retry_rate.attr,
 	&dev_attr_statistics.attr,
 	&dev_attr_status.attr,
 	&dev_attr_temperature.attr,
 	&dev_attr_tx_power.attr,
 #ifdef CONFIG_IWLWIFI_DEBUG
 	&dev_attr_debug_level.attr,
 #endif
 	&dev_attr_version.attr,
 	NULL
 };
 static struct attribute_group iwl_attribute_group = {
 	.name = NULL,		/* put in device directory */
 	.attrs = iwl_sysfs_entries,
 };
 static struct ieee80211_ops iwl_hw_ops = {
 	.tx = iwl_mac_tx,
 	.start = iwl_mac_start,
 	.stop = iwl_mac_stop,
 	.add_interface = iwl_mac_add_interface,
 	.remove_interface = iwl_mac_remove_interface,
 	.config = iwl_mac_config,
 	.config_interface = iwl_mac_config_interface,
 	.configure_filter = iwl_configure_filter,
 	.set_key = iwl_mac_set_key,
 	.update_tkip_key = iwl_mac_update_tkip_key,
 	.get_stats = iwl_mac_get_stats,
 	.get_tx_stats = iwl_mac_get_tx_stats,
 	.conf_tx = iwl_mac_conf_tx,
 	.reset_tsf = iwl_mac_reset_tsf,
 	.bss_info_changed = iwl_bss_info_changed,
 	.ampdu_action = iwl_mac_ampdu_action,
 	.hw_scan = iwl_mac_hw_scan
 };
 static int iwl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
 	int err = 0;
 	struct iwl_priv *priv;
 	struct ieee80211_hw *hw;
 	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
 	unsigned long flags;
 	/************************
 	 * 1. Allocating HW data
 	 ************************/
 	/* Disabling hardware scan means that mac80211 will perform scans
 	 * "the hard way", rather than using device's scan. */
 	if (cfg->mod_params->disable_hw_scan) {
 		if (cfg->mod_params->debug & IWL_DL_INFO)
 			dev_printk(KERN_DEBUG, &(pdev->dev),
 				   "Disabling hw_scan\n");
 		iwl_hw_ops.hw_scan = NULL;
 	}
 	hw = iwl_alloc_all(cfg, &iwl_hw_ops);
 	if (!hw) {
 		err = -ENOMEM;
 		goto out;
 	}
 	priv = hw->priv;
 	/* At this point both hw and priv are allocated. */
 	SET_IEEE80211_DEV(hw, &pdev->dev);
 	IWL_DEBUG_INFO("*** LOAD DRIVER ***\n");
 	priv->cfg = cfg;
 	priv->pci_dev = pdev;
 #ifdef CONFIG_IWLWIFI_DEBUG
 	priv->debug_level = priv->cfg->mod_params->debug;
 	atomic_set(&priv->restrict_refcnt, 0);
 #endif
 	/**************************
 	 * 2. Initializing PCI bus
 	 **************************/
 	if (pci_enable_device(pdev)) {
 		err = -ENODEV;
 		goto out_ieee80211_free_hw;
 	}
 	pci_set_master(pdev);
 	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36));
 	if (!err)
 		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(36));
 	if (err) {
 		err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
 		if (!err)
 			err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
 		/* both attempts failed: */
 		if (err) {
 			printk(KERN_WARNING "%s: No suitable DMA available.\n",
 				DRV_NAME);
 			goto out_pci_disable_device;
 		}
 	}
 	err = pci_request_regions(pdev, DRV_NAME);
 	if (err)
 		goto out_pci_disable_device;
 	pci_set_drvdata(pdev, priv);
 	/***********************
 	 * 3. Read REV register
 	 ***********************/
 	priv->hw_base = pci_iomap(pdev, 0, 0);
 	if (!priv->hw_base) {
 		err = -ENODEV;
 		goto out_pci_release_regions;
 	}
 	IWL_DEBUG_INFO("pci_resource_len = 0x%08llx\n",
 		(unsigned long long) pci_resource_len(pdev, 0));
 	IWL_DEBUG_INFO("pci_resource_base = %p\n", priv->hw_base);
 	iwl_hw_detect(priv);
 	printk(KERN_INFO DRV_NAME
 		": Detected Intel Wireless WiFi Link %s REV=0x%X\n",
 		priv->cfg->name, priv->hw_rev);
 	/* We disable the RETRY_TIMEOUT register (0x41) to keep
 	 * PCI Tx retries from interfering with C3 CPU state */
 	pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);
 	/* amp init */
 	err = priv->cfg->ops->lib->apm_ops.init(priv);
 	if (err < 0) {
 		IWL_DEBUG_INFO("Failed to init APMG\n");
 		goto out_iounmap;
 	}
 	/*****************
 	 * 4. Read EEPROM
 	 *****************/
 	/* Read the EEPROM */
 	err = iwl_eeprom_init(priv);
 	if (err) {
 		IWL_ERROR("Unable to init EEPROM\n");
 		goto out_iounmap;
 	}
 	err = iwl_eeprom_check_version(priv);
 	if (err)
 		goto out_iounmap;
 	/* extract MAC Address */
 	iwl_eeprom_get_mac(priv, priv->mac_addr);
 	IWL_DEBUG_INFO("MAC address: %pM\n", priv->mac_addr);
 	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
 	/************************
 	 * 5. Setup HW constants
 	 ************************/
 	if (iwl_set_hw_params(priv)) {
 		IWL_ERROR("failed to set hw parameters\n");
 		goto out_free_eeprom;
 	}
 	/*******************
 	 * 6. Setup priv
 	 *******************/
 	err = iwl_init_drv(priv);
 	if (err)
 		goto out_free_eeprom;
 	/* At this point both hw and priv are initialized. */
 	/**********************************
 	 * 7. Initialize module parameters
 	 **********************************/
 	/* Disable radio (SW RF KILL) via parameter when loading driver */
 	if (priv->cfg->mod_params->disable) {
 		set_bit(STATUS_RF_KILL_SW, &priv->status);
 		IWL_DEBUG_INFO("Radio disabled.\n");
 	}
 	/********************
 	 * 8. Setup services
 	 ********************/
 	spin_lock_irqsave(&priv->lock, flags);
 	iwl_disable_interrupts(priv);
 	spin_unlock_irqrestore(&priv->lock, flags);
 	err = sysfs_create_group(&pdev->dev.kobj, &iwl_attribute_group);
 	if (err) {
 		IWL_ERROR("failed to create sysfs device attributes\n");
 		goto out_uninit_drv;
 	}
 	iwl_setup_deferred_work(priv);
 	iwl_setup_rx_handlers(priv);
 	/********************
 	 * 9. Conclude
 	 ********************/
 	pci_save_state(pdev);
 	pci_disable_device(pdev);
 	/**********************************
 	 * 10. Setup and register mac80211
 	 **********************************/
 	err = iwl_setup_mac(priv);
 	if (err)
 		goto out_remove_sysfs;
 	err = iwl_dbgfs_register(priv, DRV_NAME);
 	if (err)
 		IWL_ERROR("failed to create debugfs files\n");
 	err = iwl_rfkill_init(priv);
 	if (err)
 		IWL_ERROR("Unable to initialize RFKILL system. "
 				  "Ignoring error: %d\n", err);
 	iwl_power_initialize(priv);
 	return 0;
  out_remove_sysfs:
 	sysfs_remove_group(&pdev->dev.kobj, &iwl_attribute_group);
  out_uninit_drv:
 	iwl_uninit_drv(priv);
  out_free_eeprom:
 	iwl_eeprom_free(priv);
  out_iounmap:
 	pci_iounmap(pdev, priv->hw_base);
  out_pci_release_regions:
 	pci_release_regions(pdev);
 	pci_set_drvdata(pdev, NULL);
  out_pci_disable_device:
 	pci_disable_device(pdev);
  out_ieee80211_free_hw:
 	ieee80211_free_hw(priv->hw);
  out:
 	return err;
 }
 static void __devexit iwl_pci_remove(struct pci_dev *pdev)
 {
 	struct iwl_priv *priv = pci_get_drvdata(pdev);
 	unsigned long flags;
 	if (!priv)
 		return;
 	IWL_DEBUG_INFO("*** UNLOAD DRIVER ***\n");
 	iwl_dbgfs_unregister(priv);
 	sysfs_remove_group(&pdev->dev.kobj, &iwl_attribute_group);
 	/* ieee80211_unregister_hw call wil cause iwl_mac_stop to
 	 * to be called and iwl_down since we are removing the device
 	 * we need to set STATUS_EXIT_PENDING bit.
 	 */
 	set_bit(STATUS_EXIT_PENDING, &priv->status);
 	if (priv->mac80211_registered) {
 		ieee80211_unregister_hw(priv->hw);
 		priv->mac80211_registered = 0;
 	} else {
 		iwl_down(priv);
 	}
 	/* make sure we flush any pending irq or
 	 * tasklet for the driver
 	 */
 	spin_lock_irqsave(&priv->lock, flags);
 	iwl_disable_interrupts(priv);
 	spin_unlock_irqrestore(&priv->lock, flags);
 	iwl_synchronize_irq(priv);
 	iwl_rfkill_unregister(priv);
 	iwl_dealloc_ucode_pci(priv);
 	if (priv->rxq.bd)
 		iwl_rx_queue_free(priv, &priv->rxq);
 	iwl_hw_txq_ctx_free(priv);
 	iwl_clear_stations_table(priv);
 	iwl_eeprom_free(priv);
 	/*netif_stop_queue(dev); */
 	flush_workqueue(priv->workqueue);
 	/* ieee80211_unregister_hw calls iwl_mac_stop, which flushes
 	 * priv->workqueue... so we can't take down the workqueue
 	 * until now... */
 	destroy_workqueue(priv->workqueue);
 	priv->workqueue = NULL;
 	pci_iounmap(pdev, priv->hw_base);
 	pci_release_regions(pdev);
 	pci_disable_device(pdev);
 	pci_set_drvdata(pdev, NULL);
 	iwl_uninit_drv(priv);
 	if (priv->ibss_beacon)
 		dev_kfree_skb(priv->ibss_beacon);
 	ieee80211_free_hw(priv->hw);
 }
 #ifdef CONFIG_PM
 static int iwl_pci_suspend(struct pci_dev *pdev, pm_message_t state)
 {
 	struct iwl_priv *priv = pci_get_drvdata(pdev);
 	if (priv->is_open) {
 		set_bit(STATUS_IN_SUSPEND, &priv->status);
 		iwl_mac_stop(priv->hw);
 		priv->is_open = 1;
 	}
 	pci_set_power_state(pdev, PCI_D3hot);
 	return 0;
 }
 static int iwl_pci_resume(struct pci_dev *pdev)
 {
 	struct iwl_priv *priv = pci_get_drvdata(pdev);
 	pci_set_power_state(pdev, PCI_D0);
 	if (priv->is_open)
 		iwl_mac_start(priv->hw);
 	clear_bit(STATUS_IN_SUSPEND, &priv->status);
 	return 0;
 }
 #endif /* CONFIG_PM */
 /*****************************************************************************
  *
  * driver and module entry point
  *
  *****************************************************************************/
 /* Hardware specific file defines the PCI IDs table for that hardware module */
 static struct pci_device_id iwl_hw_card_ids[] = {
 #ifdef CONFIG_IWL4965
 	{IWL_PCI_DEVICE(0x4229, PCI_ANY_ID, iwl4965_agn_cfg)},
 	{IWL_PCI_DEVICE(0x4230, PCI_ANY_ID, iwl4965_agn_cfg)},
 #endif /* CONFIG_IWL4965 */
 #ifdef CONFIG_IWL5000
 	{IWL_PCI_DEVICE(0x4232, 0x1205, iwl5100_bg_cfg)},
 	{IWL_PCI_DEVICE(0x4232, 0x1305, iwl5100_bg_cfg)},
 	{IWL_PCI_DEVICE(0x4232, 0x1206, iwl5100_abg_cfg)},
 	{IWL_PCI_DEVICE(0x4232, 0x1306, iwl5100_abg_cfg)},
 	{IWL_PCI_DEVICE(0x4232, 0x1326, iwl5100_abg_cfg)},
 	{IWL_PCI_DEVICE(0x4237, 0x1216, iwl5100_abg_cfg)},
 	{IWL_PCI_DEVICE(0x4232, PCI_ANY_ID, iwl5100_agn_cfg)},
 	{IWL_PCI_DEVICE(0x4235, PCI_ANY_ID, iwl5300_agn_cfg)},
 	{IWL_PCI_DEVICE(0x4236, PCI_ANY_ID, iwl5300_agn_cfg)},
 	{IWL_PCI_DEVICE(0x4237, PCI_ANY_ID, iwl5100_agn_cfg)},
 /* 5350 WiFi/WiMax */
 	{IWL_PCI_DEVICE(0x423A, 0x1001, iwl5350_agn_cfg)},
 	{IWL_PCI_DEVICE(0x423A, 0x1021, iwl5350_agn_cfg)},
 	{IWL_PCI_DEVICE(0x423B, 0x1011, iwl5350_agn_cfg)},
 /* 5150 Wifi/WiMax */
 	{IWL_PCI_DEVICE(0x423C, PCI_ANY_ID, iwl5150_agn_cfg)},
 	{IWL_PCI_DEVICE(0x423D, PCI_ANY_ID, iwl5150_agn_cfg)},
 #endif /* CONFIG_IWL5000 */
 	{0}
 };
 MODULE_DEVICE_TABLE(pci, iwl_hw_card_ids);
 static struct pci_driver iwl_driver = {
 	.name = DRV_NAME,
 	.id_table = iwl_hw_card_ids,
 	.probe = iwl_pci_probe,
 	.remove = __devexit_p(iwl_pci_remove),
 #ifdef CONFIG_PM
 	.suspend = iwl_pci_suspend,
 	.resume = iwl_pci_resume,
 #endif
 };
 static int __init iwl_init(void)
 {
 	int ret;
 	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
 	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
 	ret = iwlagn_rate_control_register();
 	if (ret) {
 		IWL_ERROR("Unable to register rate control algorithm: %d\n", ret);
 		return ret;
 	}
 	ret = pci_register_driver(&iwl_driver);
 	if (ret) {
 		IWL_ERROR("Unable to initialize PCI module\n");
 		goto error_register;
 	}
 	return ret;
 error_register:
 	iwlagn_rate_control_unregister();
 	return ret;
 }
 static void __exit iwl_exit(void)
 {
 	pci_unregister_driver(&iwl_driver);
 	iwlagn_rate_control_unregister();
 }
 module_exit(iwl_exit);

drivers/net/wireless/mac80211_hwsim.c

Diff comments View file @ 094d05d

 /*
  * mac80211_hwsim - software simulator of 802.11 radio(s) for mac80211
  * Copyright (c) 2008, Jouni Malinen <j@w1.fi>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 /*
  * TODO:
  * - IBSS mode simulation (Beacon transmission with competition for "air time")
  * - IEEE 802.11a and 802.11n modes
  * - RX filtering based on filter configuration (data->rx_filter)
  */
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <net/mac80211.h>
 #include <net/ieee80211_radiotap.h>
 #include <linux/if_arp.h>
 #include <linux/rtnetlink.h>
 #include <linux/etherdevice.h>
 #include <linux/debugfs.h>
 MODULE_AUTHOR("Jouni Malinen");
 MODULE_DESCRIPTION("Software simulator of 802.11 radio(s) for mac80211");
 MODULE_LICENSE("GPL");
 static int radios = 2;
 module_param(radios, int, 0444);
 MODULE_PARM_DESC(radios, "Number of simulated radios");
 struct hwsim_vif_priv {
 	u32 magic;
 	u8 bssid[ETH_ALEN];
 	bool assoc;
 	u16 aid;
 };
 #define HWSIM_VIF_MAGIC	0x69537748
 static inline void hwsim_check_magic(struct ieee80211_vif *vif)
 {
 	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 	WARN_ON(vp->magic != HWSIM_VIF_MAGIC);
 }
 static inline void hwsim_set_magic(struct ieee80211_vif *vif)
 {
 	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 	vp->magic = HWSIM_VIF_MAGIC;
 }
 static inline void hwsim_clear_magic(struct ieee80211_vif *vif)
 {
 	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 	vp->magic = 0;
 }
 struct hwsim_sta_priv {
 	u32 magic;
 };
 #define HWSIM_STA_MAGIC	0x6d537748
 static inline void hwsim_check_sta_magic(struct ieee80211_sta *sta)
 {
 	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
 	WARN_ON(sp->magic != HWSIM_STA_MAGIC);
 }
 static inline void hwsim_set_sta_magic(struct ieee80211_sta *sta)
 {
 	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
 	sp->magic = HWSIM_STA_MAGIC;
 }
 static inline void hwsim_clear_sta_magic(struct ieee80211_sta *sta)
 {
 	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
 	sp->magic = 0;
 }
 static struct class *hwsim_class;
 static struct net_device *hwsim_mon; /* global monitor netdev */
 static const struct ieee80211_channel hwsim_channels[] = {
 	{ .center_freq = 2412 },
 	{ .center_freq = 2417 },
 	{ .center_freq = 2422 },
 	{ .center_freq = 2427 },
 	{ .center_freq = 2432 },
 	{ .center_freq = 2437 },
 	{ .center_freq = 2442 },
 	{ .center_freq = 2447 },
 	{ .center_freq = 2452 },
 	{ .center_freq = 2457 },
 	{ .center_freq = 2462 },
 	{ .center_freq = 2467 },
 	{ .center_freq = 2472 },
 	{ .center_freq = 2484 },
 };
 static const struct ieee80211_rate hwsim_rates[] = {
 	{ .bitrate = 10 },
 	{ .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 	{ .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 	{ .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 	{ .bitrate = 60 },
 	{ .bitrate = 90 },
 	{ .bitrate = 120 },
 	{ .bitrate = 180 },
 	{ .bitrate = 240 },
 	{ .bitrate = 360 },
 	{ .bitrate = 480 },
 	{ .bitrate = 540 }
 };
 static spinlock_t hwsim_radio_lock;
 static struct list_head hwsim_radios;
 struct mac80211_hwsim_data {
 	struct list_head list;
 	struct ieee80211_hw *hw;
 	struct device *dev;
 	struct ieee80211_supported_band band;
 	struct ieee80211_channel channels[ARRAY_SIZE(hwsim_channels)];
 	struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];
 	struct ieee80211_channel *channel;
 	int radio_enabled;
 	unsigned long beacon_int; /* in jiffies unit */
 	unsigned int rx_filter;
 	int started;
 	struct timer_list beacon_timer;
 	enum ps_mode {
 		PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL
 	} ps;
 	bool ps_poll_pending;
 	struct dentry *debugfs;
 	struct dentry *debugfs_ps;
 };
 struct hwsim_radiotap_hdr {
 	struct ieee80211_radiotap_header hdr;
 	u8 rt_flags;
 	u8 rt_rate;
 	__le16 rt_channel;
 	__le16 rt_chbitmask;
 } __attribute__ ((packed));
 static int hwsim_mon_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	/* TODO: allow packet injection */
 	dev_kfree_skb(skb);
 	return 0;
 }
 static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
 				      struct sk_buff *tx_skb)
 {
 	struct mac80211_hwsim_data *data = hw->priv;
 	struct sk_buff *skb;
 	struct hwsim_radiotap_hdr *hdr;
 	u16 flags;
 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_skb);
 	struct ieee80211_rate *txrate = ieee80211_get_tx_rate(hw, info);
 	if (!netif_running(hwsim_mon))
 		return;
 	skb = skb_copy_expand(tx_skb, sizeof(*hdr), 0, GFP_ATOMIC);
 	if (skb == NULL)
 		return;
 	hdr = (struct hwsim_radiotap_hdr *) skb_push(skb, sizeof(*hdr));
 	hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
 	hdr->hdr.it_pad = 0;
 	hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
 	hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
 					  (1 << IEEE80211_RADIOTAP_RATE) |
 					  (1 << IEEE80211_RADIOTAP_CHANNEL));
 	hdr->rt_flags = 0;
 	hdr->rt_rate = txrate->bitrate / 5;
 	hdr->rt_channel = cpu_to_le16(data->channel->center_freq);
 	flags = IEEE80211_CHAN_2GHZ;
 	if (txrate->flags & IEEE80211_RATE_ERP_G)
 		flags |= IEEE80211_CHAN_OFDM;
 	else
 		flags |= IEEE80211_CHAN_CCK;
 	hdr->rt_chbitmask = cpu_to_le16(flags);
 	skb->dev = hwsim_mon;
 	skb_set_mac_header(skb, 0);
 	skb->ip_summed = CHECKSUM_UNNECESSARY;
 	skb->pkt_type = PACKET_OTHERHOST;
 	skb->protocol = htons(ETH_P_802_2);
 	memset(skb->cb, 0, sizeof(skb->cb));
 	netif_rx(skb);
 }
 static bool hwsim_ps_rx_ok(struct mac80211_hwsim_data *data,
 			   struct sk_buff *skb)
 {
 	switch (data->ps) {
 	case PS_DISABLED:
 		return true;
 	case PS_ENABLED:
 		return false;
 	case PS_AUTO_POLL:
 		/* TODO: accept (some) Beacons by default and other frames only
 		 * if pending PS-Poll has been sent */
 		return true;
 	case PS_MANUAL_POLL:
 		/* Allow unicast frames to own address if there is a pending
 		 * PS-Poll */
 		if (data->ps_poll_pending &&
 		    memcmp(data->hw->wiphy->perm_addr, skb->data + 4,
 			   ETH_ALEN) == 0) {
 			data->ps_poll_pending = false;
 			return true;
 		}
 		return false;
 	}
 	return true;
 }
 static bool mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
 				    struct sk_buff *skb)
 {
 	struct mac80211_hwsim_data *data = hw->priv, *data2;
 	bool ack = false;
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 	struct ieee80211_rx_status rx_status;
 	memset(&rx_status, 0, sizeof(rx_status));
 	/* TODO: set mactime */
 	rx_status.freq = data->channel->center_freq;
 	rx_status.band = data->channel->band;
 	rx_status.rate_idx = info->control.rates[0].idx;
 	/* TODO: simulate signal strength (and optional packet drop) */
 	if (data->ps != PS_DISABLED)
 		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
 	/* Copy skb to all enabled radios that are on the current frequency */
 	spin_lock(&hwsim_radio_lock);
 	list_for_each_entry(data2, &hwsim_radios, list) {
 		struct sk_buff *nskb;
 		if (data == data2)
 			continue;
 		if (!data2->started || !data2->radio_enabled ||
 		    !hwsim_ps_rx_ok(data2, skb) ||
 		    data->channel->center_freq != data2->channel->center_freq)
 			continue;
 		nskb = skb_copy(skb, GFP_ATOMIC);
 		if (nskb == NULL)
 			continue;
 		if (memcmp(hdr->addr1, data2->hw->wiphy->perm_addr,
 			   ETH_ALEN) == 0)
 			ack = true;
 		ieee80211_rx_irqsafe(data2->hw, nskb, &rx_status);
 	}
 	spin_unlock(&hwsim_radio_lock);
 	return ack;
 }
 static int mac80211_hwsim_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 {
 	struct mac80211_hwsim_data *data = hw->priv;
 	bool ack;
 	struct ieee80211_tx_info *txi;
 	mac80211_hwsim_monitor_rx(hw, skb);
 	if (skb->len < 10) {
 		/* Should not happen; just a sanity check for addr1 use */
 		dev_kfree_skb(skb);
 		return NETDEV_TX_OK;
 	}
 	if (!data->radio_enabled) {
 		printk(KERN_DEBUG "%s: dropped TX frame since radio "
 		       "disabled\n", wiphy_name(hw->wiphy));
 		dev_kfree_skb(skb);
 		return NETDEV_TX_OK;
 	}
 	ack = mac80211_hwsim_tx_frame(hw, skb);
 	txi = IEEE80211_SKB_CB(skb);
 	if (txi->control.vif)
 		hwsim_check_magic(txi->control.vif);
 	if (txi->control.sta)
 		hwsim_check_sta_magic(txi->control.sta);
 	ieee80211_tx_info_clear_status(txi);
 	if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
 		txi->flags |= IEEE80211_TX_STAT_ACK;
 	ieee80211_tx_status_irqsafe(hw, skb);
 	return NETDEV_TX_OK;
 }
 static int mac80211_hwsim_start(struct ieee80211_hw *hw)
 {
 	struct mac80211_hwsim_data *data = hw->priv;
 	printk(KERN_DEBUG "%s:%s\n", wiphy_name(hw->wiphy), __func__);
 	data->started = 1;
 	return 0;
 }
 static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
 {
 	struct mac80211_hwsim_data *data = hw->priv;
 	data->started = 0;
 	del_timer(&data->beacon_timer);
 	printk(KERN_DEBUG "%s:%s\n", wiphy_name(hw->wiphy), __func__);
 }
 static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
 					struct ieee80211_if_init_conf *conf)
 {
 	printk(KERN_DEBUG "%s:%s (type=%d mac_addr=%pM)\n",
 	       wiphy_name(hw->wiphy), __func__, conf->type,
 	       conf->mac_addr);
 	hwsim_set_magic(conf->vif);
 	return 0;
 }
 static void mac80211_hwsim_remove_interface(
 	struct ieee80211_hw *hw, struct ieee80211_if_init_conf *conf)
 {
 	printk(KERN_DEBUG "%s:%s (type=%d mac_addr=%pM)\n",
 	       wiphy_name(hw->wiphy), __func__, conf->type,
 	       conf->mac_addr);
 	hwsim_check_magic(conf->vif);
 	hwsim_clear_magic(conf->vif);
 }
 static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
 				     struct ieee80211_vif *vif)
 {
 	struct ieee80211_hw *hw = arg;
 	struct sk_buff *skb;
 	struct ieee80211_tx_info *info;
 	hwsim_check_magic(vif);
 	if (vif->type != NL80211_IFTYPE_AP &&
 	    vif->type != NL80211_IFTYPE_MESH_POINT)
 		return;
 	skb = ieee80211_beacon_get(hw, vif);
 	if (skb == NULL)
 		return;
 	info = IEEE80211_SKB_CB(skb);
 	mac80211_hwsim_monitor_rx(hw, skb);
 	mac80211_hwsim_tx_frame(hw, skb);
 	dev_kfree_skb(skb);
 }
 static void mac80211_hwsim_beacon(unsigned long arg)
 {
 	struct ieee80211_hw *hw = (struct ieee80211_hw *) arg;
 	struct mac80211_hwsim_data *data = hw->priv;
 	if (!data->started || !data->radio_enabled)
 		return;
 	ieee80211_iterate_active_interfaces_atomic(
 		hw, mac80211_hwsim_beacon_tx, hw);
 	data->beacon_timer.expires = jiffies + data->beacon_int;
 	add_timer(&data->beacon_timer);
 }
 static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
 {
 	struct mac80211_hwsim_data *data = hw->priv;
 	struct ieee80211_conf *conf = &hw->conf;
 	printk(KERN_DEBUG "%s:%s (freq=%d radio_enabled=%d beacon_int=%d)\n",
 	       wiphy_name(hw->wiphy), __func__,
 	       conf->channel->center_freq, conf->radio_enabled,
 	       conf->beacon_int);
 	data->channel = conf->channel;
 	data->radio_enabled = conf->radio_enabled;
 	data->beacon_int = 1024 * conf->beacon_int / 1000 * HZ / 1000;
 	if (data->beacon_int < 1)
 		data->beacon_int = 1;
 	if (!data->started || !data->radio_enabled)
 		del_timer(&data->beacon_timer);
 	else
 		mod_timer(&data->beacon_timer, jiffies + data->beacon_int);
 	return 0;
 }
 static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
 					    unsigned int changed_flags,
 					    unsigned int *total_flags,
 					    int mc_count,
 					    struct dev_addr_list *mc_list)
 {
 	struct mac80211_hwsim_data *data = hw->priv;
 	printk(KERN_DEBUG "%s:%s\n", wiphy_name(hw->wiphy), __func__);
 	data->rx_filter = 0;
 	if (*total_flags & FIF_PROMISC_IN_BSS)
 		data->rx_filter |= FIF_PROMISC_IN_BSS;
 	if (*total_flags & FIF_ALLMULTI)
 		data->rx_filter |= FIF_ALLMULTI;
 	*total_flags = data->rx_filter;
 }
 static int mac80211_hwsim_config_interface(struct ieee80211_hw *hw,
 					   struct ieee80211_vif *vif,
 					   struct ieee80211_if_conf *conf)
 {
 	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 	hwsim_check_magic(vif);
 	if (conf->changed & IEEE80211_IFCC_BSSID) {
 		DECLARE_MAC_BUF(mac);
 		printk(KERN_DEBUG "%s:%s: BSSID changed: %pM\n",
 		       wiphy_name(hw->wiphy), __func__,
 		       conf->bssid);
 		memcpy(vp->bssid, conf->bssid, ETH_ALEN);
 	}
 	return 0;
 }
 static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
 					    struct ieee80211_vif *vif,
 					    struct ieee80211_bss_conf *info,
 					    u32 changed)
 {
 	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 	hwsim_check_magic(vif);
 	printk(KERN_DEBUG "%s:%s(changed=0x%x)\n",
 	       wiphy_name(hw->wiphy), __func__, changed);
 	if (changed & BSS_CHANGED_ASSOC) {
 		printk(KERN_DEBUG "  %s: ASSOC: assoc=%d aid=%d\n",
 		       wiphy_name(hw->wiphy), info->assoc, info->aid);
 		vp->assoc = info->assoc;
 		vp->aid = info->aid;
 	}
 	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
 		printk(KERN_DEBUG "  %s: ERP_CTS_PROT: %d\n",
 		       wiphy_name(hw->wiphy), info->use_cts_prot);
 	}
 	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
 		printk(KERN_DEBUG "  %s: ERP_PREAMBLE: %d\n",
 		       wiphy_name(hw->wiphy), info->use_short_preamble);
 	}
 	if (changed & BSS_CHANGED_ERP_SLOT) {
 		printk(KERN_DEBUG "  %s: ERP_SLOT: %d\n",
 		       wiphy_name(hw->wiphy), info->use_short_slot);
 	}
 	if (changed & BSS_CHANGED_HT) {
-		printk(KERN_DEBUG "  %s: HT: sec_ch_offs=%d width_40_ok=%d "
+		printk(KERN_DEBUG "  %s: HT: op_mode=0x%x\n",
-		       "op_mode=%d\n",
 		       wiphy_name(hw->wiphy),
-		       info->ht.secondary_channel_offset,
+		       info->ht.operation_mode);
-		       info->ht.width_40_ok, info->ht.operation_mode);
 	}
 	if (changed & BSS_CHANGED_BASIC_RATES) {
 		printk(KERN_DEBUG "  %s: BASIC_RATES: 0x%llx\n",
 		       wiphy_name(hw->wiphy),
 		       (unsigned long long) info->basic_rates);
 	}
 }
 static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw,
 				      struct ieee80211_vif *vif,
 				      enum sta_notify_cmd cmd,
 				      struct ieee80211_sta *sta)
 {
 	hwsim_check_magic(vif);
 	switch (cmd) {
 	case STA_NOTIFY_ADD:
 		hwsim_set_sta_magic(sta);
 		break;
 	case STA_NOTIFY_REMOVE:
 		hwsim_clear_sta_magic(sta);
 		break;
 	case STA_NOTIFY_SLEEP:
 	case STA_NOTIFY_AWAKE:
 		/* TODO: make good use of these flags */
 		break;
 	}
 }
 static int mac80211_hwsim_set_tim(struct ieee80211_hw *hw,
 				  struct ieee80211_sta *sta,
 				  bool set)
 {
 	hwsim_check_sta_magic(sta);
 	return 0;
 }
 static int mac80211_hwsim_conf_tx(
 	struct ieee80211_hw *hw, u16 queue,
 	const struct ieee80211_tx_queue_params *params)
 {
 	printk(KERN_DEBUG "%s:%s (queue=%d txop=%d cw_min=%d cw_max=%d "
 	       "aifs=%d)\n",
 	       wiphy_name(hw->wiphy), __func__, queue,
 	       params->txop, params->cw_min, params->cw_max, params->aifs);
 	return 0;
 }
 static const struct ieee80211_ops mac80211_hwsim_ops =
 {
 	.tx = mac80211_hwsim_tx,
 	.start = mac80211_hwsim_start,
 	.stop = mac80211_hwsim_stop,
 	.add_interface = mac80211_hwsim_add_interface,
 	.remove_interface = mac80211_hwsim_remove_interface,
 	.config = mac80211_hwsim_config,
 	.configure_filter = mac80211_hwsim_configure_filter,
 	.config_interface = mac80211_hwsim_config_interface,
 	.bss_info_changed = mac80211_hwsim_bss_info_changed,
 	.sta_notify = mac80211_hwsim_sta_notify,
 	.set_tim = mac80211_hwsim_set_tim,
 	.conf_tx = mac80211_hwsim_conf_tx,
 };
 static void mac80211_hwsim_free(void)
 {
 	struct list_head tmplist, *i, *tmp;
 	struct mac80211_hwsim_data *data;
 	INIT_LIST_HEAD(&tmplist);
 	spin_lock_bh(&hwsim_radio_lock);
 	list_for_each_safe(i, tmp, &hwsim_radios)
 		list_move(i, &tmplist);
 	spin_unlock_bh(&hwsim_radio_lock);
 	list_for_each_entry(data, &tmplist, list) {
 		debugfs_remove(data->debugfs_ps);
 		debugfs_remove(data->debugfs);
 		ieee80211_unregister_hw(data->hw);
 		device_unregister(data->dev);
 		ieee80211_free_hw(data->hw);
 	}
 	class_destroy(hwsim_class);
 }
 static struct device_driver mac80211_hwsim_driver = {
 	.name = "mac80211_hwsim"
 };
 static void hwsim_mon_setup(struct net_device *dev)
 {
 	dev->hard_start_xmit = hwsim_mon_xmit;
 	dev->destructor = free_netdev;
 	ether_setup(dev);
 	dev->tx_queue_len = 0;
 	dev->type = ARPHRD_IEEE80211_RADIOTAP;
 	memset(dev->dev_addr, 0, ETH_ALEN);
 	dev->dev_addr[0] = 0x12;
 }
 static void hwsim_send_ps_poll(void *dat, u8 *mac, struct ieee80211_vif *vif)
 {
 	struct mac80211_hwsim_data *data = dat;
 	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 	DECLARE_MAC_BUF(buf);
 	struct sk_buff *skb;
 	struct ieee80211_pspoll *pspoll;
 	if (!vp->assoc)
 		return;
 	printk(KERN_DEBUG "%s:%s: send PS-Poll to %pM for aid %d\n",
 	       wiphy_name(data->hw->wiphy), __func__, vp->bssid, vp->aid);
 	skb = dev_alloc_skb(sizeof(*pspoll));
 	if (!skb)
 		return;
 	pspoll = (void *) skb_put(skb, sizeof(*pspoll));
 	pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
 					    IEEE80211_STYPE_PSPOLL |
 					    IEEE80211_FCTL_PM);
 	pspoll->aid = cpu_to_le16(0xc000 | vp->aid);
 	memcpy(pspoll->bssid, vp->bssid, ETH_ALEN);
 	memcpy(pspoll->ta, mac, ETH_ALEN);
 	if (data->radio_enabled &&
 	    !mac80211_hwsim_tx_frame(data->hw, skb))
 		printk(KERN_DEBUG "%s: PS-Poll frame not ack'ed\n", __func__);
 	dev_kfree_skb(skb);
 }
 static void hwsim_send_nullfunc(struct mac80211_hwsim_data *data, u8 *mac,
 				struct ieee80211_vif *vif, int ps)
 {
 	struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 	DECLARE_MAC_BUF(buf);
 	struct sk_buff *skb;
 	struct ieee80211_hdr *hdr;
 	if (!vp->assoc)
 		return;
 	printk(KERN_DEBUG "%s:%s: send data::nullfunc to %pM ps=%d\n",
 	       wiphy_name(data->hw->wiphy), __func__, vp->bssid, ps);
 	skb = dev_alloc_skb(sizeof(*hdr));
 	if (!skb)
 		return;
 	hdr = (void *) skb_put(skb, sizeof(*hdr) - ETH_ALEN);
 	hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
 					 IEEE80211_STYPE_NULLFUNC |
 					 (ps ? IEEE80211_FCTL_PM : 0));
 	hdr->duration_id = cpu_to_le16(0);
 	memcpy(hdr->addr1, vp->bssid, ETH_ALEN);
 	memcpy(hdr->addr2, mac, ETH_ALEN);
 	memcpy(hdr->addr3, vp->bssid, ETH_ALEN);
 	if (data->radio_enabled &&
 	    !mac80211_hwsim_tx_frame(data->hw, skb))
 		printk(KERN_DEBUG "%s: nullfunc frame not ack'ed\n", __func__);
 	dev_kfree_skb(skb);
 }
 static void hwsim_send_nullfunc_ps(void *dat, u8 *mac,
 				   struct ieee80211_vif *vif)
 {
 	struct mac80211_hwsim_data *data = dat;
 	hwsim_send_nullfunc(data, mac, vif, 1);
 }
 static void hwsim_send_nullfunc_no_ps(void *dat, u8 *mac,
 				      struct ieee80211_vif *vif)
 {
 	struct mac80211_hwsim_data *data = dat;
 	hwsim_send_nullfunc(data, mac, vif, 0);
 }
 static int hwsim_fops_ps_read(void *dat, u64 *val)
 {
 	struct mac80211_hwsim_data *data = dat;
 	*val = data->ps;
 	return 0;
 }
 static int hwsim_fops_ps_write(void *dat, u64 val)
 {
 	struct mac80211_hwsim_data *data = dat;
 	enum ps_mode old_ps;
 	if (val != PS_DISABLED && val != PS_ENABLED && val != PS_AUTO_POLL &&
 	    val != PS_MANUAL_POLL)
 		return -EINVAL;
 	old_ps = data->ps;
 	data->ps = val;
 	if (val == PS_MANUAL_POLL) {
 		ieee80211_iterate_active_interfaces(data->hw,
 						    hwsim_send_ps_poll, data);
 		data->ps_poll_pending = true;
 	} else if (old_ps == PS_DISABLED && val != PS_DISABLED) {
 		ieee80211_iterate_active_interfaces(data->hw,
 						    hwsim_send_nullfunc_ps,
 						    data);
 	} else if (old_ps != PS_DISABLED && val == PS_DISABLED) {
 		ieee80211_iterate_active_interfaces(data->hw,
 						    hwsim_send_nullfunc_no_ps,
 						    data);
 	}
 	return 0;
 }
 DEFINE_SIMPLE_ATTRIBUTE(hwsim_fops_ps, hwsim_fops_ps_read, hwsim_fops_ps_write,
 			"%llu\n");
 static int __init init_mac80211_hwsim(void)
 {
 	int i, err = 0;
 	u8 addr[ETH_ALEN];
 	struct mac80211_hwsim_data *data;
 	struct ieee80211_hw *hw;
 	if (radios < 1 || radios > 100)
 		return -EINVAL;
 	spin_lock_init(&hwsim_radio_lock);
 	INIT_LIST_HEAD(&hwsim_radios);
 	hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim");
 	if (IS_ERR(hwsim_class))
 		return PTR_ERR(hwsim_class);
 	memset(addr, 0, ETH_ALEN);
 	addr[0] = 0x02;
 	for (i = 0; i < radios; i++) {
 		printk(KERN_DEBUG "mac80211_hwsim: Initializing radio %d\n",
 		       i);
 		hw = ieee80211_alloc_hw(sizeof(*data), &mac80211_hwsim_ops);
 		if (!hw) {
 			printk(KERN_DEBUG "mac80211_hwsim: ieee80211_alloc_hw "
 			       "failed\n");
 			err = -ENOMEM;
 			goto failed;
 		}
 		data = hw->priv;
 		data->hw = hw;
 		data->dev = device_create(hwsim_class, NULL, 0, hw,
 					  "hwsim%d", i);
 		if (IS_ERR(data->dev)) {
 			printk(KERN_DEBUG
 			       "mac80211_hwsim: device_create "
 			       "failed (%ld)\n", PTR_ERR(data->dev));
 			err = -ENOMEM;
 			goto failed_drvdata;
 		}
 		data->dev->driver = &mac80211_hwsim_driver;
 		SET_IEEE80211_DEV(hw, data->dev);
 		addr[3] = i >> 8;
 		addr[4] = i;
 		SET_IEEE80211_PERM_ADDR(hw, addr);
 		hw->channel_change_time = 1;
 		hw->queues = 4;
 		hw->wiphy->interface_modes =
 			BIT(NL80211_IFTYPE_STATION) |
 			BIT(NL80211_IFTYPE_AP) |
 			BIT(NL80211_IFTYPE_MESH_POINT);
 		hw->ampdu_queues = 1;
 		/* ask mac80211 to reserve space for magic */
 		hw->vif_data_size = sizeof(struct hwsim_vif_priv);
 		hw->sta_data_size = sizeof(struct hwsim_sta_priv);
 		memcpy(data->channels, hwsim_channels, sizeof(hwsim_channels));
 		memcpy(data->rates, hwsim_rates, sizeof(hwsim_rates));
 		data->band.channels = data->channels;
 		data->band.n_channels = ARRAY_SIZE(hwsim_channels);
 		data->band.bitrates = data->rates;
 		data->band.n_bitrates = ARRAY_SIZE(hwsim_rates);
 		data->band.ht_cap.ht_supported = true;
 		data->band.ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
 			IEEE80211_HT_CAP_GRN_FLD |
 			IEEE80211_HT_CAP_SGI_40 |
 			IEEE80211_HT_CAP_DSSSCCK40;
 		data->band.ht_cap.ampdu_factor = 0x3;
 		data->band.ht_cap.ampdu_density = 0x6;
 		memset(&data->band.ht_cap.mcs, 0,
 		       sizeof(data->band.ht_cap.mcs));
 		data->band.ht_cap.mcs.rx_mask[0] = 0xff;
 		data->band.ht_cap.mcs.rx_mask[1] = 0xff;
 		data->band.ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
 		hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &data->band;
 		err = ieee80211_register_hw(hw);
 		if (err < 0) {
 			printk(KERN_DEBUG "mac80211_hwsim: "
 			       "ieee80211_register_hw failed (%d)\n", err);
 			goto failed_hw;
 		}
 		printk(KERN_DEBUG "%s: hwaddr %pM registered\n",
 		       wiphy_name(hw->wiphy),
 		       hw->wiphy->perm_addr);
 		data->debugfs = debugfs_create_dir("hwsim",
 						   hw->wiphy->debugfsdir);
 		data->debugfs_ps = debugfs_create_file("ps", 0666,
 						       data->debugfs, data,
 						       &hwsim_fops_ps);
 		setup_timer(&data->beacon_timer, mac80211_hwsim_beacon,
 			    (unsigned long) hw);
 		list_add_tail(&data->list, &hwsim_radios);
 	}
 	hwsim_mon = alloc_netdev(0, "hwsim%d", hwsim_mon_setup);
 	if (hwsim_mon == NULL)
 		goto failed;
 	rtnl_lock();
 	err = dev_alloc_name(hwsim_mon, hwsim_mon->name);
 	if (err < 0)
 		goto failed_mon;
 	err = register_netdevice(hwsim_mon);
 	if (err < 0)
 		goto failed_mon;
 	rtnl_unlock();
 	return 0;
 failed_mon:
 	rtnl_unlock();
 	free_netdev(hwsim_mon);
 	mac80211_hwsim_free();
 	return err;
 failed_hw:
 	device_unregister(data->dev);
 failed_drvdata:
 	ieee80211_free_hw(hw);
 failed:
 	mac80211_hwsim_free();
 	return err;
 }
 static void __exit exit_mac80211_hwsim(void)
 {
 	printk(KERN_DEBUG "mac80211_hwsim: unregister radios\n");
 	unregister_netdev(hwsim_mon);
 	mac80211_hwsim_free();
 }
 module_init(init_mac80211_hwsim);
 module_exit(exit_mac80211_hwsim);

include/linux/nl80211.h

Diff comments View file @ 094d05d

include/net/cfg80211.h

Diff comments View file @ 094d05d

1	#ifndef __NET_CFG80211_H	1	#ifndef __NET_CFG80211_H
2	#define __NET_CFG80211_H	2	#define __NET_CFG80211_H
3		3
4	#include <linux/netlink.h>	4	#include <linux/netlink.h>
5	#include <linux/skbuff.h>	5	#include <linux/skbuff.h>
6	#include <linux/nl80211.h>	6	#include <linux/nl80211.h>
7	#include <net/genetlink.h>	7	#include <net/genetlink.h>
8	/* remove once we remove the wext stuff */	8	/* remove once we remove the wext stuff */
9	#include <net/iw_handler.h>	9	#include <net/iw_handler.h>
10		10
11	/*	11	/*
12	* 802.11 configuration in-kernel interface	12	* 802.11 configuration in-kernel interface
13	*	13	*
14	* Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>	14	* Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>
15	*/	15	*/
16		16
17	/**	17	/**
18	* struct vif_params - describes virtual interface parameters	18	* struct vif_params - describes virtual interface parameters
19	* @mesh_id: mesh ID to use	19	* @mesh_id: mesh ID to use
20	* @mesh_id_len: length of the mesh ID	20	* @mesh_id_len: length of the mesh ID
21	*/	21	*/
22	struct vif_params {	22	struct vif_params {
23	u8 *mesh_id;	23	u8 *mesh_id;
24	int mesh_id_len;	24	int mesh_id_len;
25	};	25	};
26		26
27	/* Radiotap header iteration	27	/* Radiotap header iteration
28	* implemented in net/wireless/radiotap.c	28	* implemented in net/wireless/radiotap.c
29	* docs in Documentation/networking/radiotap-headers.txt	29	* docs in Documentation/networking/radiotap-headers.txt
30	*/	30	*/
31	/**	31	/**
32	* struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args	32	* struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args
33	* @rtheader: pointer to the radiotap header we are walking through	33	* @rtheader: pointer to the radiotap header we are walking through
34	* @max_length: length of radiotap header in cpu byte ordering	34	* @max_length: length of radiotap header in cpu byte ordering
35	* @this_arg_index: IEEE80211_RADIOTAP_... index of current arg	35	* @this_arg_index: IEEE80211_RADIOTAP_... index of current arg
36	* @this_arg: pointer to current radiotap arg	36	* @this_arg: pointer to current radiotap arg
37	* @arg_index: internal next argument index	37	* @arg_index: internal next argument index
38	* @arg: internal next argument pointer	38	* @arg: internal next argument pointer
39	* @next_bitmap: internal pointer to next present u32	39	* @next_bitmap: internal pointer to next present u32
40	* @bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present	40	* @bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present
41	*/	41	*/
42		42
43	struct ieee80211_radiotap_iterator {	43	struct ieee80211_radiotap_iterator {
44	struct ieee80211_radiotap_header *rtheader;	44	struct ieee80211_radiotap_header *rtheader;
45	int max_length;	45	int max_length;
46	int this_arg_index;	46	int this_arg_index;
47	u8 *this_arg;	47	u8 *this_arg;
48		48
49	int arg_index;	49	int arg_index;
50	u8 *arg;	50	u8 *arg;
51	__le32 *next_bitmap;	51	__le32 *next_bitmap;
52	u32 bitmap_shifter;	52	u32 bitmap_shifter;
53	};	53	};
54		54
55	extern int ieee80211_radiotap_iterator_init(	55	extern int ieee80211_radiotap_iterator_init(
56	struct ieee80211_radiotap_iterator *iterator,	56	struct ieee80211_radiotap_iterator *iterator,
57	struct ieee80211_radiotap_header *radiotap_header,	57	struct ieee80211_radiotap_header *radiotap_header,
58	int max_length);	58	int max_length);
59		59
60	extern int ieee80211_radiotap_iterator_next(	60	extern int ieee80211_radiotap_iterator_next(
61	struct ieee80211_radiotap_iterator *iterator);	61	struct ieee80211_radiotap_iterator *iterator);
62		62
63		63
64	/**	64	/**
65	* struct key_params - key information	65	* struct key_params - key information
66	*	66	*
67	* Information about a key	67	* Information about a key
68	*	68	*
69	* @key: key material	69	* @key: key material
70	* @key_len: length of key material	70	* @key_len: length of key material
71	* @cipher: cipher suite selector	71	* @cipher: cipher suite selector
72	* @seq: sequence counter (IV/PN) for TKIP and CCMP keys, only used	72	* @seq: sequence counter (IV/PN) for TKIP and CCMP keys, only used
73	* with the get_key() callback, must be in little endian,	73	* with the get_key() callback, must be in little endian,
74	* length given by @seq_len.	74	* length given by @seq_len.
75	*/	75	*/
76	struct key_params {	76	struct key_params {
77	u8 *key;	77	u8 *key;
78	u8 *seq;	78	u8 *seq;
79	int key_len;	79	int key_len;
80	int seq_len;	80	int seq_len;
81	u32 cipher;	81	u32 cipher;
82	};	82	};
83		83
84	/**	84	/**
85	* struct beacon_parameters - beacon parameters	85	* struct beacon_parameters - beacon parameters
86	*	86	*
87	* Used to configure the beacon for an interface.	87	* Used to configure the beacon for an interface.
88	*	88	*
89	* @head: head portion of beacon (before TIM IE)	89	* @head: head portion of beacon (before TIM IE)
90	* or %NULL if not changed	90	* or %NULL if not changed
91	* @tail: tail portion of beacon (after TIM IE)	91	* @tail: tail portion of beacon (after TIM IE)
92	* or %NULL if not changed	92	* or %NULL if not changed
93	* @interval: beacon interval or zero if not changed	93	* @interval: beacon interval or zero if not changed
94	* @dtim_period: DTIM period or zero if not changed	94	* @dtim_period: DTIM period or zero if not changed
95	* @head_len: length of @head	95	* @head_len: length of @head
96	* @tail_len: length of @tail	96	* @tail_len: length of @tail
97	*/	97	*/
98	struct beacon_parameters {	98	struct beacon_parameters {
99	u8 head, tail;	99	u8 head, tail;
100	int interval, dtim_period;	100	int interval, dtim_period;
101	int head_len, tail_len;	101	int head_len, tail_len;
102	};	102	};
103		103
104	/**	104	/**
105	* enum station_flags - station flags	105	* enum station_flags - station flags
106	*	106	*
107	* Station capability flags. Note that these must be the bits	107	* Station capability flags. Note that these must be the bits
108	* according to the nl80211 flags.	108	* according to the nl80211 flags.
109	*	109	*
110	* @STATION_FLAG_CHANGED: station flags were changed	110	* @STATION_FLAG_CHANGED: station flags were changed
111	* @STATION_FLAG_AUTHORIZED: station is authorized to send frames (802.1X)	111	* @STATION_FLAG_AUTHORIZED: station is authorized to send frames (802.1X)
112	* @STATION_FLAG_SHORT_PREAMBLE: station is capable of receiving frames	112	* @STATION_FLAG_SHORT_PREAMBLE: station is capable of receiving frames
113	* with short preambles	113	* with short preambles
114	* @STATION_FLAG_WME: station is WME/QoS capable	114	* @STATION_FLAG_WME: station is WME/QoS capable
115	*/	115	*/
116	enum station_flags {	116	enum station_flags {
117	STATION_FLAG_CHANGED = 1<<0,	117	STATION_FLAG_CHANGED = 1<<0,
118	STATION_FLAG_AUTHORIZED = 1<<NL80211_STA_FLAG_AUTHORIZED,	118	STATION_FLAG_AUTHORIZED = 1<<NL80211_STA_FLAG_AUTHORIZED,
119	STATION_FLAG_SHORT_PREAMBLE = 1<<NL80211_STA_FLAG_SHORT_PREAMBLE,	119	STATION_FLAG_SHORT_PREAMBLE = 1<<NL80211_STA_FLAG_SHORT_PREAMBLE,
120	STATION_FLAG_WME = 1<<NL80211_STA_FLAG_WME,	120	STATION_FLAG_WME = 1<<NL80211_STA_FLAG_WME,
121	};	121	};
122		122
123	/**	123	/**
124	* enum plink_action - actions to perform in mesh peers	124	* enum plink_action - actions to perform in mesh peers
125	*	125	*
126	* @PLINK_ACTION_INVALID: action 0 is reserved	126	* @PLINK_ACTION_INVALID: action 0 is reserved
127	* @PLINK_ACTION_OPEN: start mesh peer link establishment	127	* @PLINK_ACTION_OPEN: start mesh peer link establishment
128	* @PLINK_ACTION_BLOCL: block traffic from this mesh peer	128	* @PLINK_ACTION_BLOCL: block traffic from this mesh peer
129	*/	129	*/
130	enum plink_actions {	130	enum plink_actions {
131	PLINK_ACTION_INVALID,	131	PLINK_ACTION_INVALID,
132	PLINK_ACTION_OPEN,	132	PLINK_ACTION_OPEN,
133	PLINK_ACTION_BLOCK,	133	PLINK_ACTION_BLOCK,
134	};	134	};
135		135
136	/**	136	/**
137	* struct station_parameters - station parameters	137	* struct station_parameters - station parameters
138	*	138	*
139	* Used to change and create a new station.	139	* Used to change and create a new station.
140	*	140	*
141	* @vlan: vlan interface station should belong to	141	* @vlan: vlan interface station should belong to
142	* @supported_rates: supported rates in IEEE 802.11 format	142	* @supported_rates: supported rates in IEEE 802.11 format
143	* (or NULL for no change)	143	* (or NULL for no change)
144	* @supported_rates_len: number of supported rates	144	* @supported_rates_len: number of supported rates
145	* @station_flags: station flags (see &enum station_flags)	145	* @station_flags: station flags (see &enum station_flags)
146	* @listen_interval: listen interval or -1 for no change	146	* @listen_interval: listen interval or -1 for no change
147	* @aid: AID or zero for no change	147	* @aid: AID or zero for no change
148	*/	148	*/
149	struct station_parameters {	149	struct station_parameters {
150	u8 *supported_rates;	150	u8 *supported_rates;
151	struct net_device *vlan;	151	struct net_device *vlan;
152	u32 station_flags;	152	u32 station_flags;
153	int listen_interval;	153	int listen_interval;
154	u16 aid;	154	u16 aid;
155	u8 supported_rates_len;	155	u8 supported_rates_len;
156	u8 plink_action;	156	u8 plink_action;
157	struct ieee80211_ht_cap *ht_capa;	157	struct ieee80211_ht_cap *ht_capa;
158	};	158	};
159		159
160	/**	160	/**
161	* enum station_info_flags - station information flags	161	* enum station_info_flags - station information flags
162	*	162	*
163	* Used by the driver to indicate which info in &struct station_info	163	* Used by the driver to indicate which info in &struct station_info
164	* it has filled in during get_station() or dump_station().	164	* it has filled in during get_station() or dump_station().
165	*	165	*
166	* @STATION_INFO_INACTIVE_TIME: @inactive_time filled	166	* @STATION_INFO_INACTIVE_TIME: @inactive_time filled
167	* @STATION_INFO_RX_BYTES: @rx_bytes filled	167	* @STATION_INFO_RX_BYTES: @rx_bytes filled
168	* @STATION_INFO_TX_BYTES: @tx_bytes filled	168	* @STATION_INFO_TX_BYTES: @tx_bytes filled
169	* @STATION_INFO_LLID: @llid filled	169	* @STATION_INFO_LLID: @llid filled
170	* @STATION_INFO_PLID: @plid filled	170	* @STATION_INFO_PLID: @plid filled
171	* @STATION_INFO_PLINK_STATE: @plink_state filled	171	* @STATION_INFO_PLINK_STATE: @plink_state filled
172	* @STATION_INFO_SIGNAL: @signal filled	172	* @STATION_INFO_SIGNAL: @signal filled
173	* @STATION_INFO_TX_BITRATE: @tx_bitrate fields are filled	173	* @STATION_INFO_TX_BITRATE: @tx_bitrate fields are filled
174	* (tx_bitrate, tx_bitrate_flags and tx_bitrate_mcs)	174	* (tx_bitrate, tx_bitrate_flags and tx_bitrate_mcs)
175	*/	175	*/
176	enum station_info_flags {	176	enum station_info_flags {
177	STATION_INFO_INACTIVE_TIME = 1<<0,	177	STATION_INFO_INACTIVE_TIME = 1<<0,
178	STATION_INFO_RX_BYTES = 1<<1,	178	STATION_INFO_RX_BYTES = 1<<1,
179	STATION_INFO_TX_BYTES = 1<<2,	179	STATION_INFO_TX_BYTES = 1<<2,
180	STATION_INFO_LLID = 1<<3,	180	STATION_INFO_LLID = 1<<3,
181	STATION_INFO_PLID = 1<<4,	181	STATION_INFO_PLID = 1<<4,
182	STATION_INFO_PLINK_STATE = 1<<5,	182	STATION_INFO_PLINK_STATE = 1<<5,
183	STATION_INFO_SIGNAL = 1<<6,	183	STATION_INFO_SIGNAL = 1<<6,
184	STATION_INFO_TX_BITRATE = 1<<7,	184	STATION_INFO_TX_BITRATE = 1<<7,
185	};	185	};
186		186
187	/**	187	/**
188	* enum station_info_rate_flags - bitrate info flags	188	* enum station_info_rate_flags - bitrate info flags
189	*	189	*
190	* Used by the driver to indicate the specific rate transmission	190	* Used by the driver to indicate the specific rate transmission
191	* type for 802.11n transmissions.	191	* type for 802.11n transmissions.
192	*	192	*
193	* @RATE_INFO_FLAGS_MCS: @tx_bitrate_mcs filled	193	* @RATE_INFO_FLAGS_MCS: @tx_bitrate_mcs filled
194	* @RATE_INFO_FLAGS_40_MHZ_WIDTH: 40 Mhz width transmission	194	* @RATE_INFO_FLAGS_40_MHZ_WIDTH: 40 Mhz width transmission
195	* @RATE_INFO_FLAGS_SHORT_GI: 400ns guard interval	195	* @RATE_INFO_FLAGS_SHORT_GI: 400ns guard interval
196	*/	196	*/
197	enum rate_info_flags {	197	enum rate_info_flags {
198	RATE_INFO_FLAGS_MCS = 1<<0,	198	RATE_INFO_FLAGS_MCS = 1<<0,
199	RATE_INFO_FLAGS_40_MHZ_WIDTH = 1<<1,	199	RATE_INFO_FLAGS_40_MHZ_WIDTH = 1<<1,
200	RATE_INFO_FLAGS_SHORT_GI = 1<<2,	200	RATE_INFO_FLAGS_SHORT_GI = 1<<2,
201	};	201	};
202		202
203	/**	203	/**
204	* struct rate_info - bitrate information	204	* struct rate_info - bitrate information
205	*	205	*
206	* Information about a receiving or transmitting bitrate	206	* Information about a receiving or transmitting bitrate
207	*	207	*
208	* @flags: bitflag of flags from &enum rate_info_flags	208	* @flags: bitflag of flags from &enum rate_info_flags
209	* @mcs: mcs index if struct describes a 802.11n bitrate	209	* @mcs: mcs index if struct describes a 802.11n bitrate
210	* @legacy: bitrate in 100kbit/s for 802.11abg	210	* @legacy: bitrate in 100kbit/s for 802.11abg
211	*/	211	*/
212	struct rate_info {	212	struct rate_info {
213	u8 flags;	213	u8 flags;
214	u8 mcs;	214	u8 mcs;
215	u16 legacy;	215	u16 legacy;
216	};	216	};
217		217
218	/**	218	/**
219	* struct station_info - station information	219	* struct station_info - station information
220	*	220	*
221	* Station information filled by driver for get_station() and dump_station.	221	* Station information filled by driver for get_station() and dump_station.
222	*	222	*
223	* @filled: bitflag of flags from &enum station_info_flags	223	* @filled: bitflag of flags from &enum station_info_flags
224	* @inactive_time: time since last station activity (tx/rx) in milliseconds	224	* @inactive_time: time since last station activity (tx/rx) in milliseconds
225	* @rx_bytes: bytes received from this station	225	* @rx_bytes: bytes received from this station
226	* @tx_bytes: bytes transmitted to this station	226	* @tx_bytes: bytes transmitted to this station
227	* @llid: mesh local link id	227	* @llid: mesh local link id
228	* @plid: mesh peer link id	228	* @plid: mesh peer link id
229	* @plink_state: mesh peer link state	229	* @plink_state: mesh peer link state
230	* @signal: signal strength of last received packet in dBm	230	* @signal: signal strength of last received packet in dBm
231	* @txrate: current unicast bitrate to this station	231	* @txrate: current unicast bitrate to this station
232	*/	232	*/
233	struct station_info {	233	struct station_info {
234	u32 filled;	234	u32 filled;
235	u32 inactive_time;	235	u32 inactive_time;
236	u32 rx_bytes;	236	u32 rx_bytes;
237	u32 tx_bytes;	237	u32 tx_bytes;
238	u16 llid;	238	u16 llid;
239	u16 plid;	239	u16 plid;
240	u8 plink_state;	240	u8 plink_state;
241	s8 signal;	241	s8 signal;
242	struct rate_info txrate;	242	struct rate_info txrate;
243	};	243	};
244		244
245	/**	245	/**
246	* enum monitor_flags - monitor flags	246	* enum monitor_flags - monitor flags
247	*	247	*
248	* Monitor interface configuration flags. Note that these must be the bits	248	* Monitor interface configuration flags. Note that these must be the bits
249	* according to the nl80211 flags.	249	* according to the nl80211 flags.
250	*	250	*
251	* @MONITOR_FLAG_FCSFAIL: pass frames with bad FCS	251	* @MONITOR_FLAG_FCSFAIL: pass frames with bad FCS
252	* @MONITOR_FLAG_PLCPFAIL: pass frames with bad PLCP	252	* @MONITOR_FLAG_PLCPFAIL: pass frames with bad PLCP
253	* @MONITOR_FLAG_CONTROL: pass control frames	253	* @MONITOR_FLAG_CONTROL: pass control frames
254	* @MONITOR_FLAG_OTHER_BSS: disable BSSID filtering	254	* @MONITOR_FLAG_OTHER_BSS: disable BSSID filtering
255	* @MONITOR_FLAG_COOK_FRAMES: report frames after processing	255	* @MONITOR_FLAG_COOK_FRAMES: report frames after processing
256	*/	256	*/
257	enum monitor_flags {	257	enum monitor_flags {
258	MONITOR_FLAG_FCSFAIL = 1<<NL80211_MNTR_FLAG_FCSFAIL,	258	MONITOR_FLAG_FCSFAIL = 1<<NL80211_MNTR_FLAG_FCSFAIL,
259	MONITOR_FLAG_PLCPFAIL = 1<<NL80211_MNTR_FLAG_PLCPFAIL,	259	MONITOR_FLAG_PLCPFAIL = 1<<NL80211_MNTR_FLAG_PLCPFAIL,
260	MONITOR_FLAG_CONTROL = 1<<NL80211_MNTR_FLAG_CONTROL,	260	MONITOR_FLAG_CONTROL = 1<<NL80211_MNTR_FLAG_CONTROL,
261	MONITOR_FLAG_OTHER_BSS = 1<<NL80211_MNTR_FLAG_OTHER_BSS,	261	MONITOR_FLAG_OTHER_BSS = 1<<NL80211_MNTR_FLAG_OTHER_BSS,
262	MONITOR_FLAG_COOK_FRAMES = 1<<NL80211_MNTR_FLAG_COOK_FRAMES,	262	MONITOR_FLAG_COOK_FRAMES = 1<<NL80211_MNTR_FLAG_COOK_FRAMES,
263	};	263	};
264		264
265	/**	265	/**
266	* enum mpath_info_flags - mesh path information flags	266	* enum mpath_info_flags - mesh path information flags
267	*	267	*
268	* Used by the driver to indicate which info in &struct mpath_info it has filled	268	* Used by the driver to indicate which info in &struct mpath_info it has filled
269	* in during get_station() or dump_station().	269	* in during get_station() or dump_station().
270	*	270	*
271	* MPATH_INFO_FRAME_QLEN: @frame_qlen filled	271	* MPATH_INFO_FRAME_QLEN: @frame_qlen filled
272	* MPATH_INFO_DSN: @dsn filled	272	* MPATH_INFO_DSN: @dsn filled
273	* MPATH_INFO_METRIC: @metric filled	273	* MPATH_INFO_METRIC: @metric filled
274	* MPATH_INFO_EXPTIME: @exptime filled	274	* MPATH_INFO_EXPTIME: @exptime filled
275	* MPATH_INFO_DISCOVERY_TIMEOUT: @discovery_timeout filled	275	* MPATH_INFO_DISCOVERY_TIMEOUT: @discovery_timeout filled
276	* MPATH_INFO_DISCOVERY_RETRIES: @discovery_retries filled	276	* MPATH_INFO_DISCOVERY_RETRIES: @discovery_retries filled
277	* MPATH_INFO_FLAGS: @flags filled	277	* MPATH_INFO_FLAGS: @flags filled
278	*/	278	*/
279	enum mpath_info_flags {	279	enum mpath_info_flags {
280	MPATH_INFO_FRAME_QLEN = BIT(0),	280	MPATH_INFO_FRAME_QLEN = BIT(0),
281	MPATH_INFO_DSN = BIT(1),	281	MPATH_INFO_DSN = BIT(1),
282	MPATH_INFO_METRIC = BIT(2),	282	MPATH_INFO_METRIC = BIT(2),
283	MPATH_INFO_EXPTIME = BIT(3),	283	MPATH_INFO_EXPTIME = BIT(3),
284	MPATH_INFO_DISCOVERY_TIMEOUT = BIT(4),	284	MPATH_INFO_DISCOVERY_TIMEOUT = BIT(4),
285	MPATH_INFO_DISCOVERY_RETRIES = BIT(5),	285	MPATH_INFO_DISCOVERY_RETRIES = BIT(5),
286	MPATH_INFO_FLAGS = BIT(6),	286	MPATH_INFO_FLAGS = BIT(6),
287	};	287	};
288		288
289	/**	289	/**
290	* struct mpath_info - mesh path information	290	* struct mpath_info - mesh path information
291	*	291	*
292	* Mesh path information filled by driver for get_mpath() and dump_mpath().	292	* Mesh path information filled by driver for get_mpath() and dump_mpath().
293	*	293	*
294	* @filled: bitfield of flags from &enum mpath_info_flags	294	* @filled: bitfield of flags from &enum mpath_info_flags
295	* @frame_qlen: number of queued frames for this destination	295	* @frame_qlen: number of queued frames for this destination
296	* @dsn: destination sequence number	296	* @dsn: destination sequence number
297	* @metric: metric (cost) of this mesh path	297	* @metric: metric (cost) of this mesh path
298	* @exptime: expiration time for the mesh path from now, in msecs	298	* @exptime: expiration time for the mesh path from now, in msecs
299	* @flags: mesh path flags	299	* @flags: mesh path flags
300	* @discovery_timeout: total mesh path discovery timeout, in msecs	300	* @discovery_timeout: total mesh path discovery timeout, in msecs
301	* @discovery_retries: mesh path discovery retries	301	* @discovery_retries: mesh path discovery retries
302	*/	302	*/
303	struct mpath_info {	303	struct mpath_info {
304	u32 filled;	304	u32 filled;
305	u32 frame_qlen;	305	u32 frame_qlen;
306	u32 dsn;	306	u32 dsn;
307	u32 metric;	307	u32 metric;
308	u32 exptime;	308	u32 exptime;
309	u32 discovery_timeout;	309	u32 discovery_timeout;
310	u8 discovery_retries;	310	u8 discovery_retries;
311	u8 flags;	311	u8 flags;
312	};	312	};
313		313
314	/**	314	/**
315	* struct bss_parameters - BSS parameters	315	* struct bss_parameters - BSS parameters
316	*	316	*
317	* Used to change BSS parameters (mainly for AP mode).	317	* Used to change BSS parameters (mainly for AP mode).
318	*	318	*
319	* @use_cts_prot: Whether to use CTS protection	319	* @use_cts_prot: Whether to use CTS protection
320	* (0 = no, 1 = yes, -1 = do not change)	320	* (0 = no, 1 = yes, -1 = do not change)
321	* @use_short_preamble: Whether the use of short preambles is allowed	321	* @use_short_preamble: Whether the use of short preambles is allowed
322	* (0 = no, 1 = yes, -1 = do not change)	322	* (0 = no, 1 = yes, -1 = do not change)
323	* @use_short_slot_time: Whether the use of short slot time is allowed	323	* @use_short_slot_time: Whether the use of short slot time is allowed
324	* (0 = no, 1 = yes, -1 = do not change)	324	* (0 = no, 1 = yes, -1 = do not change)
325	* @basic_rates: basic rates in IEEE 802.11 format	325	* @basic_rates: basic rates in IEEE 802.11 format
326	* (or NULL for no change)	326	* (or NULL for no change)
327	* @basic_rates_len: number of basic rates	327	* @basic_rates_len: number of basic rates
328	*/	328	*/
329	struct bss_parameters {	329	struct bss_parameters {
330	int use_cts_prot;	330	int use_cts_prot;
331	int use_short_preamble;	331	int use_short_preamble;
332	int use_short_slot_time;	332	int use_short_slot_time;
333	u8 *basic_rates;	333	u8 *basic_rates;
334	u8 basic_rates_len;	334	u8 basic_rates_len;
335	};	335	};
336		336
337	/**	337	/**
338	* enum reg_set_by - Indicates who is trying to set the regulatory domain	338	* enum reg_set_by - Indicates who is trying to set the regulatory domain
339	* @REGDOM_SET_BY_INIT: regulatory domain was set by initialization. We will be	339	* @REGDOM_SET_BY_INIT: regulatory domain was set by initialization. We will be
340	* using a static world regulatory domain by default.	340	* using a static world regulatory domain by default.
341	* @REGDOM_SET_BY_CORE: Core queried CRDA for a dynamic world regulatory domain.	341	* @REGDOM_SET_BY_CORE: Core queried CRDA for a dynamic world regulatory domain.
342	* @REGDOM_SET_BY_USER: User asked the wireless core to set the	342	* @REGDOM_SET_BY_USER: User asked the wireless core to set the
343	* regulatory domain.	343	* regulatory domain.
344	* @REGDOM_SET_BY_DRIVER: a wireless drivers has hinted to the wireless core	344	* @REGDOM_SET_BY_DRIVER: a wireless drivers has hinted to the wireless core
345	* it thinks its knows the regulatory domain we should be in.	345	* it thinks its knows the regulatory domain we should be in.
346	* @REGDOM_SET_BY_COUNTRY_IE: the wireless core has received an 802.11 country	346	* @REGDOM_SET_BY_COUNTRY_IE: the wireless core has received an 802.11 country
347	* information element with regulatory information it thinks we	347	* information element with regulatory information it thinks we
348	* should consider.	348	* should consider.
349	*/	349	*/
350	enum reg_set_by {	350	enum reg_set_by {
351	REGDOM_SET_BY_INIT,	351	REGDOM_SET_BY_INIT,
352	REGDOM_SET_BY_CORE,	352	REGDOM_SET_BY_CORE,
353	REGDOM_SET_BY_USER,	353	REGDOM_SET_BY_USER,
354	REGDOM_SET_BY_DRIVER,	354	REGDOM_SET_BY_DRIVER,
355	REGDOM_SET_BY_COUNTRY_IE,	355	REGDOM_SET_BY_COUNTRY_IE,
356	};	356	};
357		357
358	struct ieee80211_freq_range {	358	struct ieee80211_freq_range {
359	u32 start_freq_khz;	359	u32 start_freq_khz;
360	u32 end_freq_khz;	360	u32 end_freq_khz;
361	u32 max_bandwidth_khz;	361	u32 max_bandwidth_khz;
362	};	362	};
363		363
364	struct ieee80211_power_rule {	364	struct ieee80211_power_rule {
365	u32 max_antenna_gain;	365	u32 max_antenna_gain;
366	u32 max_eirp;	366	u32 max_eirp;
367	};	367	};
368		368
369	struct ieee80211_reg_rule {	369	struct ieee80211_reg_rule {
370	struct ieee80211_freq_range freq_range;	370	struct ieee80211_freq_range freq_range;
371	struct ieee80211_power_rule power_rule;	371	struct ieee80211_power_rule power_rule;
372	u32 flags;	372	u32 flags;
373	};	373	};
374		374
375	struct ieee80211_regdomain {	375	struct ieee80211_regdomain {
376	u32 n_reg_rules;	376	u32 n_reg_rules;
377	char alpha2[2];	377	char alpha2[2];
378	struct ieee80211_reg_rule reg_rules[];	378	struct ieee80211_reg_rule reg_rules[];
379	};	379	};
380		380
381	#define MHZ_TO_KHZ(freq) ((freq) * 1000)	381	#define MHZ_TO_KHZ(freq) ((freq) * 1000)
382	#define KHZ_TO_MHZ(freq) ((freq) / 1000)	382	#define KHZ_TO_MHZ(freq) ((freq) / 1000)
383	#define DBI_TO_MBI(gain) ((gain) * 100)	383	#define DBI_TO_MBI(gain) ((gain) * 100)
384	#define MBI_TO_DBI(gain) ((gain) / 100)	384	#define MBI_TO_DBI(gain) ((gain) / 100)
385	#define DBM_TO_MBM(gain) ((gain) * 100)	385	#define DBM_TO_MBM(gain) ((gain) * 100)
386	#define MBM_TO_DBM(gain) ((gain) / 100)	386	#define MBM_TO_DBM(gain) ((gain) / 100)
387		387
388	#define REG_RULE(start, end, bw, gain, eirp, reg_flags) { \	388	#define REG_RULE(start, end, bw, gain, eirp, reg_flags) { \
389	.freq_range.start_freq_khz = MHZ_TO_KHZ(start), \	389	.freq_range.start_freq_khz = MHZ_TO_KHZ(start), \
390	.freq_range.end_freq_khz = MHZ_TO_KHZ(end), \	390	.freq_range.end_freq_khz = MHZ_TO_KHZ(end), \
391	.freq_range.max_bandwidth_khz = MHZ_TO_KHZ(bw), \	391	.freq_range.max_bandwidth_khz = MHZ_TO_KHZ(bw), \
392	.power_rule.max_antenna_gain = DBI_TO_MBI(gain), \	392	.power_rule.max_antenna_gain = DBI_TO_MBI(gain), \
393	.power_rule.max_eirp = DBM_TO_MBM(eirp), \	393	.power_rule.max_eirp = DBM_TO_MBM(eirp), \
394	.flags = reg_flags, \	394	.flags = reg_flags, \
395	}	395	}
396		396
397	struct mesh_config {	397	struct mesh_config {
398	/* Timeouts in ms */	398	/* Timeouts in ms */
399	/* Mesh plink management parameters */	399	/* Mesh plink management parameters */
400	u16 dot11MeshRetryTimeout;	400	u16 dot11MeshRetryTimeout;
401	u16 dot11MeshConfirmTimeout;	401	u16 dot11MeshConfirmTimeout;
402	u16 dot11MeshHoldingTimeout;	402	u16 dot11MeshHoldingTimeout;
403	u16 dot11MeshMaxPeerLinks;	403	u16 dot11MeshMaxPeerLinks;
404	u8 dot11MeshMaxRetries;	404	u8 dot11MeshMaxRetries;
405	u8 dot11MeshTTL;	405	u8 dot11MeshTTL;
406	bool auto_open_plinks;	406	bool auto_open_plinks;
407	/* HWMP parameters */	407	/* HWMP parameters */
408	u8 dot11MeshHWMPmaxPREQretries;	408	u8 dot11MeshHWMPmaxPREQretries;
409	u32 path_refresh_time;	409	u32 path_refresh_time;
410	u16 min_discovery_timeout;	410	u16 min_discovery_timeout;
411	u32 dot11MeshHWMPactivePathTimeout;	411	u32 dot11MeshHWMPactivePathTimeout;
412	u16 dot11MeshHWMPpreqMinInterval;	412	u16 dot11MeshHWMPpreqMinInterval;
413	u16 dot11MeshHWMPnetDiameterTraversalTime;	413	u16 dot11MeshHWMPnetDiameterTraversalTime;
414	};	414	};
415		415
416	/**	416	/**
417	* struct ieee80211_txq_params - TX queue parameters	417	* struct ieee80211_txq_params - TX queue parameters
418	* @queue: TX queue identifier (NL80211_TXQ_Q_*)	418	* @queue: TX queue identifier (NL80211_TXQ_Q_*)
419	* @txop: Maximum burst time in units of 32 usecs, 0 meaning disabled	419	* @txop: Maximum burst time in units of 32 usecs, 0 meaning disabled
420	* @cwmin: Minimum contention window [a value of the form 2^n-1 in the range	420	* @cwmin: Minimum contention window [a value of the form 2^n-1 in the range
421	* 1..32767]	421	* 1..32767]
422	* @cwmax: Maximum contention window [a value of the form 2^n-1 in the range	422	* @cwmax: Maximum contention window [a value of the form 2^n-1 in the range
423	* 1..32767]	423	* 1..32767]
424	* @aifs: Arbitration interframe space [0..255]	424	* @aifs: Arbitration interframe space [0..255]
425	*/	425	*/
426	struct ieee80211_txq_params {	426	struct ieee80211_txq_params {
427	enum nl80211_txq_q queue;	427	enum nl80211_txq_q queue;
428	u16 txop;	428	u16 txop;
429	u16 cwmin;	429	u16 cwmin;
430	u16 cwmax;	430	u16 cwmax;
431	u8 aifs;	431	u8 aifs;
432	};	432	};
433		433
434	/* from net/wireless.h */	434	/* from net/wireless.h */
435	struct wiphy;	435	struct wiphy;
436		436
437	/* from net/ieee80211.h */	437	/* from net/ieee80211.h */
438	struct ieee80211_channel;	438	struct ieee80211_channel;
439		439
440	/**	440	/**
441	* struct cfg80211_ops - backend description for wireless configuration	441	* struct cfg80211_ops - backend description for wireless configuration
442	*	442	*
443	* This struct is registered by fullmac card drivers and/or wireless stacks	443	* This struct is registered by fullmac card drivers and/or wireless stacks
444	* in order to handle configuration requests on their interfaces.	444	* in order to handle configuration requests on their interfaces.
445	*	445	*
446	* All callbacks except where otherwise noted should return 0	446	* All callbacks except where otherwise noted should return 0
447	* on success or a negative error code.	447	* on success or a negative error code.
448	*	448	*
449	* All operations are currently invoked under rtnl for consistency with the	449	* All operations are currently invoked under rtnl for consistency with the
450	* wireless extensions but this is subject to reevaluation as soon as this	450	* wireless extensions but this is subject to reevaluation as soon as this
451	* code is used more widely and we have a first user without wext.	451	* code is used more widely and we have a first user without wext.
452	*	452	*
453	* @add_virtual_intf: create a new virtual interface with the given name,	453	* @add_virtual_intf: create a new virtual interface with the given name,
454	* must set the struct wireless_dev's iftype.	454	* must set the struct wireless_dev's iftype.
455	*	455	*
456	* @del_virtual_intf: remove the virtual interface determined by ifindex.	456	* @del_virtual_intf: remove the virtual interface determined by ifindex.
457	*	457	*
458	* @change_virtual_intf: change type/configuration of virtual interface,	458	* @change_virtual_intf: change type/configuration of virtual interface,
459	* keep the struct wireless_dev's iftype updated.	459	* keep the struct wireless_dev's iftype updated.
460	*	460	*
461	* @add_key: add a key with the given parameters. @mac_addr will be %NULL	461	* @add_key: add a key with the given parameters. @mac_addr will be %NULL
462	* when adding a group key.	462	* when adding a group key.
463	*	463	*
464	* @get_key: get information about the key with the given parameters.	464	* @get_key: get information about the key with the given parameters.
465	* @mac_addr will be %NULL when requesting information for a group	465	* @mac_addr will be %NULL when requesting information for a group
466	* key. All pointers given to the @callback function need not be valid	466	* key. All pointers given to the @callback function need not be valid
467	* after it returns.	467	* after it returns.
468	*	468	*
469	* @del_key: remove a key given the @mac_addr (%NULL for a group key)	469	* @del_key: remove a key given the @mac_addr (%NULL for a group key)
470	* and @key_index	470	* and @key_index
471	*	471	*
472	* @set_default_key: set the default key on an interface	472	* @set_default_key: set the default key on an interface
473	*	473	*
474	* @add_beacon: Add a beacon with given parameters, @head, @interval	474	* @add_beacon: Add a beacon with given parameters, @head, @interval
475	* and @dtim_period will be valid, @tail is optional.	475	* and @dtim_period will be valid, @tail is optional.
476	* @set_beacon: Change the beacon parameters for an access point mode	476	* @set_beacon: Change the beacon parameters for an access point mode
477	* interface. This should reject the call when no beacon has been	477	* interface. This should reject the call when no beacon has been
478	* configured.	478	* configured.
479	* @del_beacon: Remove beacon configuration and stop sending the beacon.	479	* @del_beacon: Remove beacon configuration and stop sending the beacon.
480	*	480	*
481	* @add_station: Add a new station.	481	* @add_station: Add a new station.
482	*	482	*
483	* @del_station: Remove a station; @mac may be NULL to remove all stations.	483	* @del_station: Remove a station; @mac may be NULL to remove all stations.
484	*	484	*
485	* @change_station: Modify a given station.	485	* @change_station: Modify a given station.
486	*	486	*
487	* @get_mesh_params: Put the current mesh parameters into *params	487	* @get_mesh_params: Put the current mesh parameters into *params
488	*	488	*
489	* @set_mesh_params: Set mesh parameters.	489	* @set_mesh_params: Set mesh parameters.
490	* The mask is a bitfield which tells us which parameters to	490	* The mask is a bitfield which tells us which parameters to
491	* set, and which to leave alone.	491	* set, and which to leave alone.
492	*	492	*
493	* @set_mesh_cfg: set mesh parameters (by now, just mesh id)	493	* @set_mesh_cfg: set mesh parameters (by now, just mesh id)
494	*	494	*
495	* @change_bss: Modify parameters for a given BSS.	495	* @change_bss: Modify parameters for a given BSS.
496	*	496	*
497	* @set_txq_params: Set TX queue parameters	497	* @set_txq_params: Set TX queue parameters
498	*	498	*
499	* @set_channel: Set channel	499	* @set_channel: Set channel
500	*/	500	*/
501	struct cfg80211_ops {	501	struct cfg80211_ops {
502	int (add_virtual_intf)(struct wiphy wiphy, char *name,	502	int (add_virtual_intf)(struct wiphy wiphy, char *name,
503	enum nl80211_iftype type, u32 *flags,	503	enum nl80211_iftype type, u32 *flags,
504	struct vif_params *params);	504	struct vif_params *params);
505	int (del_virtual_intf)(struct wiphy wiphy, int ifindex);	505	int (del_virtual_intf)(struct wiphy wiphy, int ifindex);
506	int (change_virtual_intf)(struct wiphy wiphy, int ifindex,	506	int (change_virtual_intf)(struct wiphy wiphy, int ifindex,
507	enum nl80211_iftype type, u32 *flags,	507	enum nl80211_iftype type, u32 *flags,
508	struct vif_params *params);	508	struct vif_params *params);
509		509
510	int (add_key)(struct wiphy wiphy, struct net_device *netdev,	510	int (add_key)(struct wiphy wiphy, struct net_device *netdev,
511	u8 key_index, u8 *mac_addr,	511	u8 key_index, u8 *mac_addr,
512	struct key_params *params);	512	struct key_params *params);
513	int (get_key)(struct wiphy wiphy, struct net_device *netdev,	513	int (get_key)(struct wiphy wiphy, struct net_device *netdev,
514	u8 key_index, u8 mac_addr, void cookie,	514	u8 key_index, u8 mac_addr, void cookie,
515	void (callback)(void cookie, struct key_params*));	515	void (callback)(void cookie, struct key_params*));
516	int (del_key)(struct wiphy wiphy, struct net_device *netdev,	516	int (del_key)(struct wiphy wiphy, struct net_device *netdev,
517	u8 key_index, u8 *mac_addr);	517	u8 key_index, u8 *mac_addr);
518	int (set_default_key)(struct wiphy wiphy,	518	int (set_default_key)(struct wiphy wiphy,
519	struct net_device *netdev,	519	struct net_device *netdev,
520	u8 key_index);	520	u8 key_index);
521		521
522	int (add_beacon)(struct wiphy wiphy, struct net_device *dev,	522	int (add_beacon)(struct wiphy wiphy, struct net_device *dev,
523	struct beacon_parameters *info);	523	struct beacon_parameters *info);
524	int (set_beacon)(struct wiphy wiphy, struct net_device *dev,	524	int (set_beacon)(struct wiphy wiphy, struct net_device *dev,
525	struct beacon_parameters *info);	525	struct beacon_parameters *info);
526	int (del_beacon)(struct wiphy wiphy, struct net_device *dev);	526	int (del_beacon)(struct wiphy wiphy, struct net_device *dev);
527		527
528		528
529	int (add_station)(struct wiphy wiphy, struct net_device *dev,	529	int (add_station)(struct wiphy wiphy, struct net_device *dev,
530	u8 mac, struct station_parameters params);	530	u8 mac, struct station_parameters params);
531	int (del_station)(struct wiphy wiphy, struct net_device *dev,	531	int (del_station)(struct wiphy wiphy, struct net_device *dev,
532	u8 *mac);	532	u8 *mac);
533	int (change_station)(struct wiphy wiphy, struct net_device *dev,	533	int (change_station)(struct wiphy wiphy, struct net_device *dev,
534	u8 mac, struct station_parameters params);	534	u8 mac, struct station_parameters params);
535	int (get_station)(struct wiphy wiphy, struct net_device *dev,	535	int (get_station)(struct wiphy wiphy, struct net_device *dev,
536	u8 mac, struct station_info sinfo);	536	u8 mac, struct station_info sinfo);
537	int (dump_station)(struct wiphy wiphy, struct net_device *dev,	537	int (dump_station)(struct wiphy wiphy, struct net_device *dev,
538	int idx, u8 mac, struct station_info sinfo);	538	int idx, u8 mac, struct station_info sinfo);
539		539
540	int (add_mpath)(struct wiphy wiphy, struct net_device *dev,	540	int (add_mpath)(struct wiphy wiphy, struct net_device *dev,
541	u8 dst, u8 next_hop);	541	u8 dst, u8 next_hop);
542	int (del_mpath)(struct wiphy wiphy, struct net_device *dev,	542	int (del_mpath)(struct wiphy wiphy, struct net_device *dev,
543	u8 *dst);	543	u8 *dst);
544	int (change_mpath)(struct wiphy wiphy, struct net_device *dev,	544	int (change_mpath)(struct wiphy wiphy, struct net_device *dev,
545	u8 dst, u8 next_hop);	545	u8 dst, u8 next_hop);
546	int (get_mpath)(struct wiphy wiphy, struct net_device *dev,	546	int (get_mpath)(struct wiphy wiphy, struct net_device *dev,
547	u8 dst, u8 next_hop,	547	u8 dst, u8 next_hop,
548	struct mpath_info *pinfo);	548	struct mpath_info *pinfo);
549	int (dump_mpath)(struct wiphy wiphy, struct net_device *dev,	549	int (dump_mpath)(struct wiphy wiphy, struct net_device *dev,
550	int idx, u8 dst, u8 next_hop,	550	int idx, u8 dst, u8 next_hop,
551	struct mpath_info *pinfo);	551	struct mpath_info *pinfo);
552	int (get_mesh_params)(struct wiphy wiphy,	552	int (get_mesh_params)(struct wiphy wiphy,
553	struct net_device *dev,	553	struct net_device *dev,
554	struct mesh_config *conf);	554	struct mesh_config *conf);
555	int (set_mesh_params)(struct wiphy wiphy,	555	int (set_mesh_params)(struct wiphy wiphy,
556	struct net_device *dev,	556	struct net_device *dev,
557	const struct mesh_config *nconf, u32 mask);	557	const struct mesh_config *nconf, u32 mask);
558	int (change_bss)(struct wiphy wiphy, struct net_device *dev,	558	int (change_bss)(struct wiphy wiphy, struct net_device *dev,
559	struct bss_parameters *params);	559	struct bss_parameters *params);
560		560
561	int (set_txq_params)(struct wiphy wiphy,	561	int (set_txq_params)(struct wiphy wiphy,
562	struct ieee80211_txq_params *params);	562	struct ieee80211_txq_params *params);
563		563
564	int (set_channel)(struct wiphy wiphy,	564	int (set_channel)(struct wiphy wiphy,
565	struct ieee80211_channel *chan,	565	struct ieee80211_channel *chan,
566	enum nl80211_sec_chan_offset);	566	enum nl80211_channel_type channel_type);
567	};	567	};
568		568
569	/* temporary wext handlers */	569	/* temporary wext handlers */
570	int cfg80211_wext_giwname(struct net_device *dev,	570	int cfg80211_wext_giwname(struct net_device *dev,
571	struct iw_request_info *info,	571	struct iw_request_info *info,
572	char name, char extra);	572	char name, char extra);
573	int cfg80211_wext_siwmode(struct net_device dev, struct iw_request_info info,	573	int cfg80211_wext_siwmode(struct net_device dev, struct iw_request_info info,
574	u32 mode, char extra);	574	u32 mode, char extra);
575	int cfg80211_wext_giwmode(struct net_device dev, struct iw_request_info info,	575	int cfg80211_wext_giwmode(struct net_device dev, struct iw_request_info info,
576	u32 mode, char extra);	576	u32 mode, char extra);
577		577
578	#endif /* __NET_CFG80211_H */	578	#endif /* __NET_CFG80211_H */
579		579

include/net/mac80211.h

Diff comments View file @ 094d05d

 /*
  * mac80211 <-> driver interface
  *
  * Copyright 2002-2005, Devicescape Software, Inc.
  * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
  * Copyright 2007-2008	Johannes Berg <johannes@sipsolutions.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #ifndef MAC80211_H
 #define MAC80211_H
 #include <linux/kernel.h>
 #include <linux/if_ether.h>
 #include <linux/skbuff.h>
 #include <linux/wireless.h>
 #include <linux/device.h>
 #include <linux/ieee80211.h>
 #include <net/wireless.h>
 #include <net/cfg80211.h>
 /**
  * DOC: Introduction
  *
  * mac80211 is the Linux stack for 802.11 hardware that implements
  * only partial functionality in hard- or firmware. This document
  * defines the interface between mac80211 and low-level hardware
  * drivers.
  */
 /**
  * DOC: Calling mac80211 from interrupts
  *
  * Only ieee80211_tx_status_irqsafe() and ieee80211_rx_irqsafe() can be
  * called in hardware interrupt context. The low-level driver must not call any
  * other functions in hardware interrupt context. If there is a need for such
  * call, the low-level driver should first ACK the interrupt and perform the
  * IEEE 802.11 code call after this, e.g. from a scheduled workqueue or even
  * tasklet function.
  *
  * NOTE: If the driver opts to use the _irqsafe() functions, it may not also
  *	 use the non-IRQ-safe functions!
  */
 /**
  * DOC: Warning
  *
  * If you're reading this document and not the header file itself, it will
  * be incomplete because not all documentation has been converted yet.
  */
 /**
  * DOC: Frame format
  *
  * As a general rule, when frames are passed between mac80211 and the driver,
  * they start with the IEEE 802.11 header and include the same octets that are
  * sent over the air except for the FCS which should be calculated by the
  * hardware.
  *
  * There are, however, various exceptions to this rule for advanced features:
  *
  * The first exception is for hardware encryption and decryption offload
  * where the IV/ICV may or may not be generated in hardware.
  *
  * Secondly, when the hardware handles fragmentation, the frame handed to
  * the driver from mac80211 is the MSDU, not the MPDU.
  *
  * Finally, for received frames, the driver is able to indicate that it has
  * filled a radiotap header and put that in front of the frame; if it does
  * not do so then mac80211 may add this under certain circumstances.
  */
 /**
  * struct ieee80211_ht_bss_info - describing BSS's HT characteristics
  *
  * This structure describes most essential parameters needed
  * to describe 802.11n HT characteristics in a BSS.
  *
  * @primary_channel: channel number of primery channel
  * @bss_cap: 802.11n's general BSS capabilities (e.g. channel width)
  * @bss_op_mode: 802.11n's BSS operation modes (e.g. HT protection)
  */
 struct ieee80211_ht_bss_info {
 	u8 primary_channel;
 	u8 bss_cap;  /* use IEEE80211_HT_IE_CHA_ */
 	u8 bss_op_mode; /* use IEEE80211_HT_IE_ */
 };
 /**
  * enum ieee80211_max_queues - maximum number of queues
  *
  * @IEEE80211_MAX_QUEUES: Maximum number of regular device queues.
  * @IEEE80211_MAX_AMPDU_QUEUES: Maximum number of queues usable
  *	for A-MPDU operation.
  */
 enum ieee80211_max_queues {
 	IEEE80211_MAX_QUEUES =		16,
 	IEEE80211_MAX_AMPDU_QUEUES =	16,
 };
 /**
  * struct ieee80211_tx_queue_params - transmit queue configuration
  *
  * The information provided in this structure is required for QoS
  * transmit queue configuration. Cf. IEEE 802.11 7.3.2.29.
  *
  * @aifs: arbitration interframe space [0..255]
  * @cw_min: minimum contention window [a value of the form
  *	2^n-1 in the range 1..32767]
  * @cw_max: maximum contention window [like @cw_min]
  * @txop: maximum burst time in units of 32 usecs, 0 meaning disabled
  */
 struct ieee80211_tx_queue_params {
 	u16 txop;
 	u16 cw_min;
 	u16 cw_max;
 	u8 aifs;
 };
 /**
  * struct ieee80211_tx_queue_stats - transmit queue statistics
  *
  * @len: number of packets in queue
  * @limit: queue length limit
  * @count: number of frames sent
  */
 struct ieee80211_tx_queue_stats {
 	unsigned int len;
 	unsigned int limit;
 	unsigned int count;
 };
 struct ieee80211_low_level_stats {
 	unsigned int dot11ACKFailureCount;
 	unsigned int dot11RTSFailureCount;
 	unsigned int dot11FCSErrorCount;
 	unsigned int dot11RTSSuccessCount;
 };
 /**
  * enum ieee80211_bss_change - BSS change notification flags
  *
  * These flags are used with the bss_info_changed() callback
  * to indicate which BSS parameter changed.
  *
  * @BSS_CHANGED_ASSOC: association status changed (associated/disassociated),
  *	also implies a change in the AID.
  * @BSS_CHANGED_ERP_CTS_PROT: CTS protection changed
  * @BSS_CHANGED_ERP_PREAMBLE: preamble changed
  * @BSS_CHANGED_ERP_SLOT: slot timing changed
  * @BSS_CHANGED_HT: 802.11n parameters changed
  * @BSS_CHANGED_BASIC_RATES: Basic rateset changed
  */
 enum ieee80211_bss_change {
 	BSS_CHANGED_ASSOC		= 1<<0,
 	BSS_CHANGED_ERP_CTS_PROT	= 1<<1,
 	BSS_CHANGED_ERP_PREAMBLE	= 1<<2,
 	BSS_CHANGED_ERP_SLOT		= 1<<3,
 	BSS_CHANGED_HT                  = 1<<4,
 	BSS_CHANGED_BASIC_RATES		= 1<<5,
 };
 /**
  * struct ieee80211_bss_ht_conf - BSS's changing HT configuration
- * @secondary_channel_offset: secondary channel offset, uses
- *	%IEEE80211_HT_PARAM_CHA_SEC_ values
- * @width_40_ok: indicates that 40 MHz bandwidth may be used for TX
  * @operation_mode: HT operation mode (like in &struct ieee80211_ht_info)
  */
 struct ieee80211_bss_ht_conf {
-	u8 secondary_channel_offset;
-	bool width_40_ok;
 	u16 operation_mode;
 };
 /**
  * struct ieee80211_bss_conf - holds the BSS's changing parameters
  *
  * This structure keeps information about a BSS (and an association
  * to that BSS) that can change during the lifetime of the BSS.
  *
  * @assoc: association status
  * @aid: association ID number, valid only when @assoc is true
  * @use_cts_prot: use CTS protection
  * @use_short_preamble: use 802.11b short preamble;
  *	if the hardware cannot handle this it must set the
  *	IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE hardware flag
  * @use_short_slot: use short slot time (only relevant for ERP);
  *	if the hardware cannot handle this it must set the
  *	IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE hardware flag
  * @dtim_period: num of beacons before the next DTIM, for PSM
  * @timestamp: beacon timestamp
  * @beacon_int: beacon interval
  * @assoc_capability: capabilities taken from assoc resp
  * @ht: BSS's HT configuration
  * @basic_rates: bitmap of basic rates, each bit stands for an
  *	index into the rate table configured by the driver in
  *	the current band.
  */
 struct ieee80211_bss_conf {
 	/* association related data */
 	bool assoc;
 	u16 aid;
 	/* erp related data */
 	bool use_cts_prot;
 	bool use_short_preamble;
 	bool use_short_slot;
 	u8 dtim_period;
 	u16 beacon_int;
 	u16 assoc_capability;
 	u64 timestamp;
 	u64 basic_rates;
 	struct ieee80211_bss_ht_conf ht;
 };
 /**
  * enum mac80211_tx_control_flags - flags to describe transmission information/status
  *
  * These flags are used with the @flags member of &ieee80211_tx_info.
  *
  * @IEEE80211_TX_CTL_REQ_TX_STATUS: request TX status callback for this frame.
  * @IEEE80211_TX_CTL_ASSIGN_SEQ: The driver has to assign a sequence
  *	number to this frame, taking care of not overwriting the fragment
  *	number and increasing the sequence number only when the
  *	IEEE80211_TX_CTL_FIRST_FRAGMENT flag is set. mac80211 will properly
  *	assign sequence numbers to QoS-data frames but cannot do so correctly
  *	for non-QoS-data and management frames because beacons need them from
  *	that counter as well and mac80211 cannot guarantee proper sequencing.
  *	If this flag is set, the driver should instruct the hardware to
  *	assign a sequence number to the frame or assign one itself. Cf. IEEE
  *	802.11-2007 7.1.3.4.1 paragraph 3. This flag will always be set for
  *	beacons and always be clear for frames without a sequence number field.
  * @IEEE80211_TX_CTL_NO_ACK: tell the low level not to wait for an ack
  * @IEEE80211_TX_CTL_CLEAR_PS_FILT: clear powersave filter for destination
  *	station
  * @IEEE80211_TX_CTL_FIRST_FRAGMENT: this is a first fragment of the frame
  * @IEEE80211_TX_CTL_SEND_AFTER_DTIM: send this frame after DTIM beacon
  * @IEEE80211_TX_CTL_AMPDU: this frame should be sent as part of an A-MPDU
  * @IEEE80211_TX_CTL_INJECTED: Frame was injected, internal to mac80211.
  * @IEEE80211_TX_STAT_TX_FILTERED: The frame was not transmitted
  *	because the destination STA was in powersave mode.
  * @IEEE80211_TX_STAT_ACK: Frame was acknowledged
  * @IEEE80211_TX_STAT_AMPDU: The frame was aggregated, so status
  * 	is for the whole aggregation.
  * @IEEE80211_TX_STAT_AMPDU_NO_BACK: no block ack was returned,
  * 	so consider using block ack request (BAR).
  * @IEEE80211_TX_CTL_RATE_CTRL_PROBE: internal to mac80211, can be
  *	set by rate control algorithms to indicate probe rate, will
  *	be cleared for fragmented frames (except on the last fragment)
  */
 enum mac80211_tx_control_flags {
 	IEEE80211_TX_CTL_REQ_TX_STATUS		= BIT(0),
 	IEEE80211_TX_CTL_ASSIGN_SEQ		= BIT(1),
 	IEEE80211_TX_CTL_NO_ACK			= BIT(2),
 	IEEE80211_TX_CTL_CLEAR_PS_FILT		= BIT(3),
 	IEEE80211_TX_CTL_FIRST_FRAGMENT		= BIT(4),
 	IEEE80211_TX_CTL_SEND_AFTER_DTIM	= BIT(5),
 	IEEE80211_TX_CTL_AMPDU			= BIT(6),
 	IEEE80211_TX_CTL_INJECTED		= BIT(7),
 	IEEE80211_TX_STAT_TX_FILTERED		= BIT(8),
 	IEEE80211_TX_STAT_ACK			= BIT(9),
 	IEEE80211_TX_STAT_AMPDU			= BIT(10),
 	IEEE80211_TX_STAT_AMPDU_NO_BACK		= BIT(11),
 	IEEE80211_TX_CTL_RATE_CTRL_PROBE	= BIT(12),
 };
 enum mac80211_rate_control_flags {
 	IEEE80211_TX_RC_USE_RTS_CTS		= BIT(0),
 	IEEE80211_TX_RC_USE_CTS_PROTECT		= BIT(1),
 	IEEE80211_TX_RC_USE_SHORT_PREAMBLE	= BIT(2),
 	/* rate index is an MCS rate number instead of an index */
 	IEEE80211_TX_RC_MCS			= BIT(3),
 	IEEE80211_TX_RC_GREEN_FIELD		= BIT(4),
 	IEEE80211_TX_RC_40_MHZ_WIDTH		= BIT(5),
 	IEEE80211_TX_RC_DUP_DATA		= BIT(6),
 	IEEE80211_TX_RC_SHORT_GI		= BIT(7),
 };
 /* there are 40 bytes if you don't need the rateset to be kept */
 #define IEEE80211_TX_INFO_DRIVER_DATA_SIZE 40
 /* if you do need the rateset, then you have less space */
 #define IEEE80211_TX_INFO_RATE_DRIVER_DATA_SIZE 24
 /* maximum number of rate stages */
 #define IEEE80211_TX_MAX_RATES	5
 /**
  * struct ieee80211_tx_rate - rate selection/status
  *
  * @idx: rate index to attempt to send with
  * @flags: rate control flags (&enum mac80211_rate_control_flags)
  * @count: number of tries in this rate before going to the next rate
  *
  * A value of -1 for @idx indicates an invalid rate and, if used
  * in an array of retry rates, that no more rates should be tried.
  *
  * When used for transmit status reporting, the driver should
  * always report the rate along with the flags it used.
  */
 struct ieee80211_tx_rate {
 	s8 idx;
 	u8 count;
 	u8 flags;
 } __attribute__((packed));
 /**
  * struct ieee80211_tx_info - skb transmit information
  *
  * This structure is placed in skb->cb for three uses:
  *  (1) mac80211 TX control - mac80211 tells the driver what to do
  *  (2) driver internal use (if applicable)
  *  (3) TX status information - driver tells mac80211 what happened
  *
  * The TX control's sta pointer is only valid during the ->tx call,
  * it may be NULL.
  *
  * @flags: transmit info flags, defined above
  * @band: the band to transmit on (use for checking for races)
  * @antenna_sel_tx: antenna to use, 0 for automatic diversity
  * @pad: padding, ignore
  * @control: union for control data
  * @status: union for status data
  * @driver_data: array of driver_data pointers
  * @retry_count: number of retries
  * @ampdu_ack_len: number of aggregated frames.
  * 	relevant only if IEEE80211_TX_STATUS_AMPDU was set.
  * @ampdu_ack_map: block ack bit map for the aggregation.
  * 	relevant only if IEEE80211_TX_STATUS_AMPDU was set.
  * @ack_signal: signal strength of the ACK frame
  */
 struct ieee80211_tx_info {
 	/* common information */
 	u32 flags;
 	u8 band;
 	u8 antenna_sel_tx;
 	/* 2 byte hole */
 	u8 pad[2];
 	union {
 		struct {
 			union {
 				/* rate control */
 				struct {
 					struct ieee80211_tx_rate rates[
 						IEEE80211_TX_MAX_RATES];
 					s8 rts_cts_rate_idx;
 				};
 				/* only needed before rate control */
 				unsigned long jiffies;
 			};
 			/* NB: vif can be NULL for injected frames */
 			struct ieee80211_vif *vif;
 			struct ieee80211_key_conf *hw_key;
 			struct ieee80211_sta *sta;
 		} control;
 		struct {
 			struct ieee80211_tx_rate rates[IEEE80211_TX_MAX_RATES];
 			u8 ampdu_ack_len;
 			u64 ampdu_ack_map;
 			int ack_signal;
 			/* 8 bytes free */
 		} status;
 		struct {
 			struct ieee80211_tx_rate driver_rates[
 				IEEE80211_TX_MAX_RATES];
 			void *rate_driver_data[
 				IEEE80211_TX_INFO_RATE_DRIVER_DATA_SIZE / sizeof(void *)];
 		};
 		void *driver_data[
 			IEEE80211_TX_INFO_DRIVER_DATA_SIZE / sizeof(void *)];
 	};
 };
 static inline struct ieee80211_tx_info *IEEE80211_SKB_CB(struct sk_buff *skb)
 {
 	return (struct ieee80211_tx_info *)skb->cb;
 }
 /**
  * ieee80211_tx_info_clear_status - clear TX status
  *
  * @info: The &struct ieee80211_tx_info to be cleared.
  *
  * When the driver passes an skb back to mac80211, it must report
  * a number of things in TX status. This function clears everything
  * in the TX status but the rate control information (it does clear
  * the count since you need to fill that in anyway).
  *
  * NOTE: You can only use this function if you do NOT use
  *	 info->driver_data! Use info->rate_driver_data
  *	 instead if you need only the less space that allows.
  */
 static inline void
 ieee80211_tx_info_clear_status(struct ieee80211_tx_info *info)
 {
 	int i;
 	BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, status.rates) !=
 		     offsetof(struct ieee80211_tx_info, control.rates));
 	BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, status.rates) !=
 		     offsetof(struct ieee80211_tx_info, driver_rates));
 	BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, status.rates) != 8);
 	/* clear the rate counts */
 	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++)
 		info->status.rates[i].count = 0;
 	BUILD_BUG_ON(
 	    offsetof(struct ieee80211_tx_info, status.ampdu_ack_len) != 23);
 	memset(&info->status.ampdu_ack_len, 0,
 	       sizeof(struct ieee80211_tx_info) -
 	       offsetof(struct ieee80211_tx_info, status.ampdu_ack_len));
 }
 /**
  * enum mac80211_rx_flags - receive flags
  *
  * These flags are used with the @flag member of &struct ieee80211_rx_status.
  * @RX_FLAG_MMIC_ERROR: Michael MIC error was reported on this frame.
  *	Use together with %RX_FLAG_MMIC_STRIPPED.
  * @RX_FLAG_DECRYPTED: This frame was decrypted in hardware.
  * @RX_FLAG_RADIOTAP: This frame starts with a radiotap header.
  * @RX_FLAG_MMIC_STRIPPED: the Michael MIC is stripped off this frame,
  *	verification has been done by the hardware.
  * @RX_FLAG_IV_STRIPPED: The IV/ICV are stripped from this frame.
  *	If this flag is set, the stack cannot do any replay detection
  *	hence the driver or hardware will have to do that.
  * @RX_FLAG_FAILED_FCS_CRC: Set this flag if the FCS check failed on
  *	the frame.
  * @RX_FLAG_FAILED_PLCP_CRC: Set this flag if the PCLP check failed on
  *	the frame.
  * @RX_FLAG_TSFT: The timestamp passed in the RX status (@mactime field)
  *	is valid. This is useful in monitor mode and necessary for beacon frames
  *	to enable IBSS merging.
  * @RX_FLAG_SHORTPRE: Short preamble was used for this frame
  */
 enum mac80211_rx_flags {
 	RX_FLAG_MMIC_ERROR	= 1<<0,
 	RX_FLAG_DECRYPTED	= 1<<1,
 	RX_FLAG_RADIOTAP	= 1<<2,
 	RX_FLAG_MMIC_STRIPPED	= 1<<3,
 	RX_FLAG_IV_STRIPPED	= 1<<4,
 	RX_FLAG_FAILED_FCS_CRC	= 1<<5,
 	RX_FLAG_FAILED_PLCP_CRC = 1<<6,
 	RX_FLAG_TSFT		= 1<<7,
 	RX_FLAG_SHORTPRE	= 1<<8
 };
 /**
  * struct ieee80211_rx_status - receive status
  *
  * The low-level driver should provide this information (the subset
  * supported by hardware) to the 802.11 code with each received
  * frame.
  *
  * @mactime: value in microseconds of the 64-bit Time Synchronization Function
  * 	(TSF) timer when the first data symbol (MPDU) arrived at the hardware.
  * @band: the active band when this frame was received
  * @freq: frequency the radio was tuned to when receiving this frame, in MHz
  * @signal: signal strength when receiving this frame, either in dBm, in dB or
  *	unspecified depending on the hardware capabilities flags
  *	@IEEE80211_HW_SIGNAL_*
  * @noise: noise when receiving this frame, in dBm.
  * @qual: overall signal quality indication, in percent (0-100).
  * @antenna: antenna used
  * @rate_idx: index of data rate into band's supported rates
  * @flag: %RX_FLAG_*
  */
 struct ieee80211_rx_status {
 	u64 mactime;
 	enum ieee80211_band band;
 	int freq;
 	int signal;
 	int noise;
 	int qual;
 	int antenna;
 	int rate_idx;
 	int flag;
 };
 /**
  * enum ieee80211_conf_flags - configuration flags
  *
  * Flags to define PHY configuration options
  *
  * @IEEE80211_CONF_RADIOTAP: add radiotap header at receive time (if supported)
  * @IEEE80211_CONF_PS: Enable 802.11 power save mode
  */
 enum ieee80211_conf_flags {
 	IEEE80211_CONF_RADIOTAP		= (1<<0),
 	IEEE80211_CONF_PS		= (1<<1),
 };
 /* XXX: remove all this once drivers stop trying to use it */
 static inline int __deprecated __IEEE80211_CONF_SHORT_SLOT_TIME(void)
 {
 	return 0;
 }
 #define IEEE80211_CONF_SHORT_SLOT_TIME (__IEEE80211_CONF_SHORT_SLOT_TIME())
 struct ieee80211_ht_conf {
 	bool enabled;
-	int sec_chan_offset; /* 0 = HT40 disabled; -1 = HT40 enabled, secondary
+	enum nl80211_channel_type channel_type;
-			      * channel below primary; 1 = HT40 enabled,
-			      * secondary channel above primary */
 };
 /**
  * enum ieee80211_conf_changed - denotes which configuration changed
  *
  * @IEEE80211_CONF_CHANGE_RADIO_ENABLED: the value of radio_enabled changed
  * @IEEE80211_CONF_CHANGE_BEACON_INTERVAL: the beacon interval changed
  * @IEEE80211_CONF_CHANGE_LISTEN_INTERVAL: the listen interval changed
  * @IEEE80211_CONF_CHANGE_RADIOTAP: the radiotap flag changed
  * @IEEE80211_CONF_CHANGE_PS: the PS flag changed
  * @IEEE80211_CONF_CHANGE_POWER: the TX power changed
  * @IEEE80211_CONF_CHANGE_CHANNEL: the channel changed
  * @IEEE80211_CONF_CHANGE_RETRY_LIMITS: retry limits changed
  * @IEEE80211_CONF_CHANGE_HT: HT configuration changed
  */
 enum ieee80211_conf_changed {
 	IEEE80211_CONF_CHANGE_RADIO_ENABLED	= BIT(0),
 	IEEE80211_CONF_CHANGE_BEACON_INTERVAL	= BIT(1),
 	IEEE80211_CONF_CHANGE_LISTEN_INTERVAL	= BIT(2),
 	IEEE80211_CONF_CHANGE_RADIOTAP		= BIT(3),
 	IEEE80211_CONF_CHANGE_PS		= BIT(4),
 	IEEE80211_CONF_CHANGE_POWER		= BIT(5),
 	IEEE80211_CONF_CHANGE_CHANNEL		= BIT(6),
 	IEEE80211_CONF_CHANGE_RETRY_LIMITS	= BIT(7),
 	IEEE80211_CONF_CHANGE_HT		= BIT(8),
 };
 /**
  * struct ieee80211_conf - configuration of the device
  *
  * This struct indicates how the driver shall configure the hardware.
  *
  * @radio_enabled: when zero, driver is required to switch off the radio.
  * @beacon_int: beacon interval (TODO make interface config)
  * @listen_interval: listen interval in units of beacon interval
  * @flags: configuration flags defined above
  * @power_level: requested transmit power (in dBm)
  * @channel: the channel to tune to
  * @ht: the HT configuration for the device
  * @long_frame_max_tx_count: Maximum number of transmissions for a "long" frame
  *    (a frame not RTS protected), called "dot11LongRetryLimit" in 802.11,
  *    but actually means the number of transmissions not the number of retries
  * @short_frame_max_tx_count: Maximum number of transmissions for a "short"
  *    frame, called "dot11ShortRetryLimit" in 802.11, but actually means the
  *    number of transmissions not the number of retries
  */
 struct ieee80211_conf {
 	int beacon_int;
 	u32 flags;
 	int power_level;
 	u16 listen_interval;
 	bool radio_enabled;
 	u8 long_frame_max_tx_count, short_frame_max_tx_count;
 	struct ieee80211_channel *channel;
 	struct ieee80211_ht_conf ht;
 };
 /**
  * struct ieee80211_vif - per-interface data
  *
  * Data in this structure is continually present for driver
  * use during the life of a virtual interface.
  *
  * @type: type of this virtual interface
  * @bss_conf: BSS configuration for this interface, either our own
  *	or the BSS we're associated to
  * @drv_priv: data area for driver use, will always be aligned to
  *	sizeof(void *).
  */
 struct ieee80211_vif {
 	enum nl80211_iftype type;
 	struct ieee80211_bss_conf bss_conf;
 	/* must be last */
 	u8 drv_priv[0] __attribute__((__aligned__(sizeof(void *))));
 };
 static inline bool ieee80211_vif_is_mesh(struct ieee80211_vif *vif)
 {
 #ifdef CONFIG_MAC80211_MESH
 	return vif->type == NL80211_IFTYPE_MESH_POINT;
 #endif
 	return false;
 }
 /**
  * struct ieee80211_if_init_conf - initial configuration of an interface
  *
  * @vif: pointer to a driver-use per-interface structure. The pointer
  *	itself is also used for various functions including
  *	ieee80211_beacon_get() and ieee80211_get_buffered_bc().
  * @type: one of &enum nl80211_iftype constants. Determines the type of
  *	added/removed interface.
  * @mac_addr: pointer to MAC address of the interface. This pointer is valid
  *	until the interface is removed (i.e. it cannot be used after
  *	remove_interface() callback was called for this interface).
  *
  * This structure is used in add_interface() and remove_interface()
  * callbacks of &struct ieee80211_hw.
  *
  * When you allow multiple interfaces to be added to your PHY, take care
  * that the hardware can actually handle multiple MAC addresses. However,
  * also take care that when there's no interface left with mac_addr != %NULL
  * you remove the MAC address from the device to avoid acknowledging packets
  * in pure monitor mode.
  */
 struct ieee80211_if_init_conf {
 	enum nl80211_iftype type;
 	struct ieee80211_vif *vif;
 	void *mac_addr;
 };
 /**
  * enum ieee80211_if_conf_change - interface config change flags
  *
  * @IEEE80211_IFCC_BSSID: The BSSID changed.
  * @IEEE80211_IFCC_BEACON: The beacon for this interface changed
  *	(currently AP and MESH only), use ieee80211_beacon_get().
  */
 enum ieee80211_if_conf_change {
 	IEEE80211_IFCC_BSSID	= BIT(0),
 	IEEE80211_IFCC_BEACON	= BIT(1),
 };
 /**
  * struct ieee80211_if_conf - configuration of an interface
  *
  * @changed: parameters that have changed, see &enum ieee80211_if_conf_change.
  * @bssid: BSSID of the network we are associated to/creating.
  *
  * This structure is passed to the config_interface() callback of
  * &struct ieee80211_hw.
  */
 struct ieee80211_if_conf {
 	u32 changed;
 	u8 *bssid;
 };
 /**
  * enum ieee80211_key_alg - key algorithm
  * @ALG_WEP: WEP40 or WEP104
  * @ALG_TKIP: TKIP
  * @ALG_CCMP: CCMP (AES)
  */
 enum ieee80211_key_alg {
 	ALG_WEP,
 	ALG_TKIP,
 	ALG_CCMP,
 };
 /**
  * enum ieee80211_key_len - key length
  * @LEN_WEP40: WEP 5-byte long key
  * @LEN_WEP104: WEP 13-byte long key
  */
 enum ieee80211_key_len {
 	LEN_WEP40 = 5,
 	LEN_WEP104 = 13,
 };
 /**
  * enum ieee80211_key_flags - key flags
  *
  * These flags are used for communication about keys between the driver
  * and mac80211, with the @flags parameter of &struct ieee80211_key_conf.
  *
  * @IEEE80211_KEY_FLAG_WMM_STA: Set by mac80211, this flag indicates
  *	that the STA this key will be used with could be using QoS.
  * @IEEE80211_KEY_FLAG_GENERATE_IV: This flag should be set by the
  *	driver to indicate that it requires IV generation for this
  *	particular key.
  * @IEEE80211_KEY_FLAG_GENERATE_MMIC: This flag should be set by
  *	the driver for a TKIP key if it requires Michael MIC
  *	generation in software.
  * @IEEE80211_KEY_FLAG_PAIRWISE: Set by mac80211, this flag indicates
  *	that the key is pairwise rather then a shared key.
  */
 enum ieee80211_key_flags {
 	IEEE80211_KEY_FLAG_WMM_STA	= 1<<0,
 	IEEE80211_KEY_FLAG_GENERATE_IV	= 1<<1,
 	IEEE80211_KEY_FLAG_GENERATE_MMIC= 1<<2,
 	IEEE80211_KEY_FLAG_PAIRWISE	= 1<<3,
 };
 /**
  * struct ieee80211_key_conf - key information
  *
  * This key information is given by mac80211 to the driver by
  * the set_key() callback in &struct ieee80211_ops.
  *
  * @hw_key_idx: To be set by the driver, this is the key index the driver
  *	wants to be given when a frame is transmitted and needs to be
  *	encrypted in hardware.
  * @alg: The key algorithm.
  * @flags: key flags, see &enum ieee80211_key_flags.
  * @keyidx: the key index (0-3)
  * @keylen: key material length
  * @key: key material. For ALG_TKIP the key is encoded as a 256-bit (32 byte)
  * 	data block:
  * 	- Temporal Encryption Key (128 bits)
  * 	- Temporal Authenticator Tx MIC Key (64 bits)
  * 	- Temporal Authenticator Rx MIC Key (64 bits)
  * @icv_len: FIXME
  * @iv_len: FIXME
  */
 struct ieee80211_key_conf {
 	enum ieee80211_key_alg alg;
 	u8 icv_len;
 	u8 iv_len;
 	u8 hw_key_idx;
 	u8 flags;
 	s8 keyidx;
 	u8 keylen;
 	u8 key[0];
 };
 /**
  * enum set_key_cmd - key command
  *
  * Used with the set_key() callback in &struct ieee80211_ops, this
  * indicates whether a key is being removed or added.
  *
  * @SET_KEY: a key is set
  * @DISABLE_KEY: a key must be disabled
  */
 enum set_key_cmd {
 	SET_KEY, DISABLE_KEY,
 };
 /**
  * struct ieee80211_sta - station table entry
  *
  * A station table entry represents a station we are possibly
  * communicating with. Since stations are RCU-managed in
  * mac80211, any ieee80211_sta pointer you get access to must
  * either be protected by rcu_read_lock() explicitly or implicitly,
  * or you must take good care to not use such a pointer after a
  * call to your sta_notify callback that removed it.
  *
  * @addr: MAC address
  * @aid: AID we assigned to the station if we're an AP
  * @supp_rates: Bitmap of supported rates (per band)
  * @ht_cap: HT capabilities of this STA; restricted to our own TX capabilities
  * @drv_priv: data area for driver use, will always be aligned to
  *	sizeof(void *), size is determined in hw information.
  */
 struct ieee80211_sta {
 	u64 supp_rates[IEEE80211_NUM_BANDS];
 	u8 addr[ETH_ALEN];
 	u16 aid;
 	struct ieee80211_sta_ht_cap ht_cap;
 	/* must be last */
 	u8 drv_priv[0] __attribute__((__aligned__(sizeof(void *))));
 };
 /**
  * enum sta_notify_cmd - sta notify command
  *
  * Used with the sta_notify() callback in &struct ieee80211_ops, this
  * indicates addition and removal of a station to station table,
  * or if a associated station made a power state transition.
  *
  * @STA_NOTIFY_ADD: a station was added to the station table
  * @STA_NOTIFY_REMOVE: a station being removed from the station table
  * @STA_NOTIFY_SLEEP: a station is now sleeping
  * @STA_NOTIFY_AWAKE: a sleeping station woke up
  */
 enum sta_notify_cmd {
 	STA_NOTIFY_ADD, STA_NOTIFY_REMOVE,
 	STA_NOTIFY_SLEEP, STA_NOTIFY_AWAKE,
 };
 /**
  * enum ieee80211_tkip_key_type - get tkip key
  *
  * Used by drivers which need to get a tkip key for skb. Some drivers need a
  * phase 1 key, others need a phase 2 key. A single function allows the driver
  * to get the key, this enum indicates what type of key is required.
  *
  * @IEEE80211_TKIP_P1_KEY: the driver needs a phase 1 key
  * @IEEE80211_TKIP_P2_KEY: the driver needs a phase 2 key
  */
 enum ieee80211_tkip_key_type {
 	IEEE80211_TKIP_P1_KEY,
 	IEEE80211_TKIP_P2_KEY,
 };
 /**
  * enum ieee80211_hw_flags - hardware flags
  *
  * These flags are used to indicate hardware capabilities to
  * the stack. Generally, flags here should have their meaning
  * done in a way that the simplest hardware doesn't need setting
  * any particular flags. There are some exceptions to this rule,
  * however, so you are advised to review these flags carefully.
  *
  * @IEEE80211_HW_RX_INCLUDES_FCS:
  *	Indicates that received frames passed to the stack include
  *	the FCS at the end.
  *
  * @IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING:
  *	Some wireless LAN chipsets buffer broadcast/multicast frames
  *	for power saving stations in the hardware/firmware and others
  *	rely on the host system for such buffering. This option is used
  *	to configure the IEEE 802.11 upper layer to buffer broadcast and
  *	multicast frames when there are power saving stations so that
  *	the driver can fetch them with ieee80211_get_buffered_bc().
  *
  * @IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE:
  *	Hardware is not capable of short slot operation on the 2.4 GHz band.
  *
  * @IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE:
  *	Hardware is not capable of receiving frames with short preamble on
  *	the 2.4 GHz band.
  *
  * @IEEE80211_HW_SIGNAL_UNSPEC:
  *	Hardware can provide signal values but we don't know its units. We
  *	expect values between 0 and @max_signal.
  *	If possible please provide dB or dBm instead.
  *
  * @IEEE80211_HW_SIGNAL_DB:
  *	Hardware gives signal values in dB, decibel difference from an
  *	arbitrary, fixed reference. We expect values between 0 and @max_signal.
  *	If possible please provide dBm instead.
  *
  * @IEEE80211_HW_SIGNAL_DBM:
  *	Hardware gives signal values in dBm, decibel difference from
  *	one milliwatt. This is the preferred method since it is standardized
  *	between different devices. @max_signal does not need to be set.
  *
  * @IEEE80211_HW_NOISE_DBM:
  *	Hardware can provide noise (radio interference) values in units dBm,
  *      decibel difference from one milliwatt.
  *
  * @IEEE80211_HW_SPECTRUM_MGMT:
  * 	Hardware supports spectrum management defined in 802.11h
  * 	Measurement, Channel Switch, Quieting, TPC
  *
  * @IEEE80211_HW_AMPDU_AGGREGATION:
  *	Hardware supports 11n A-MPDU aggregation.
  */
 enum ieee80211_hw_flags {
 	IEEE80211_HW_RX_INCLUDES_FCS			= 1<<1,
 	IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING	= 1<<2,
 	IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE		= 1<<3,
 	IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE	= 1<<4,
 	IEEE80211_HW_SIGNAL_UNSPEC			= 1<<5,
 	IEEE80211_HW_SIGNAL_DB				= 1<<6,
 	IEEE80211_HW_SIGNAL_DBM				= 1<<7,
 	IEEE80211_HW_NOISE_DBM				= 1<<8,
 	IEEE80211_HW_SPECTRUM_MGMT			= 1<<9,
 	IEEE80211_HW_AMPDU_AGGREGATION			= 1<<10,
 };
 /**
  * struct ieee80211_hw - hardware information and state
  *
  * This structure contains the configuration and hardware
  * information for an 802.11 PHY.
  *
  * @wiphy: This points to the &struct wiphy allocated for this
  *	802.11 PHY. You must fill in the @perm_addr and @dev
  *	members of this structure using SET_IEEE80211_DEV()
  *	and SET_IEEE80211_PERM_ADDR(). Additionally, all supported
  *	bands (with channels, bitrates) are registered here.
  *
  * @conf: &struct ieee80211_conf, device configuration, don't use.
  *
  * @workqueue: single threaded workqueue available for driver use,
  *	allocated by mac80211 on registration and flushed when an
  *	interface is removed.
  *	NOTICE: All work performed on this workqueue should NEVER
  *	acquire the RTNL lock (i.e. Don't use the function
  *	ieee80211_iterate_active_interfaces())
  *
  * @priv: pointer to private area that was allocated for driver use
  *	along with this structure.
  *
  * @flags: hardware flags, see &enum ieee80211_hw_flags.
  *
  * @extra_tx_headroom: headroom to reserve in each transmit skb
  *	for use by the driver (e.g. for transmit headers.)
  *
  * @channel_change_time: time (in microseconds) it takes to change channels.
  *
  * @max_signal: Maximum value for signal (rssi) in RX information, used
  *     only when @IEEE80211_HW_SIGNAL_UNSPEC or @IEEE80211_HW_SIGNAL_DB
  *
  * @max_listen_interval: max listen interval in units of beacon interval
  *     that HW supports
  *
  * @queues: number of available hardware transmit queues for
  *	data packets. WMM/QoS requires at least four, these
  *	queues need to have configurable access parameters.
  *
  * @ampdu_queues: number of available hardware transmit queues
  *	for A-MPDU packets, these have no access parameters
  *	because they're used only for A-MPDU frames. Note that
  *	mac80211 will not currently use any of the regular queues
  *	for aggregation.
  *
  * @rate_control_algorithm: rate control algorithm for this hardware.
  *	If unset (NULL), the default algorithm will be used. Must be
  *	set before calling ieee80211_register_hw().
  *
  * @vif_data_size: size (in bytes) of the drv_priv data area
  *	within &struct ieee80211_vif.
  * @sta_data_size: size (in bytes) of the drv_priv data area
  *	within &struct ieee80211_sta.
  *
  * @max_rates: maximum number of alternate rate retry stages
  * @max_rate_tries: maximum number of tries for each stage
  */
 struct ieee80211_hw {
 	struct ieee80211_conf conf;
 	struct wiphy *wiphy;
 	struct workqueue_struct *workqueue;
 	const char *rate_control_algorithm;
 	void *priv;
 	u32 flags;
 	unsigned int extra_tx_headroom;
 	int channel_change_time;
 	int vif_data_size;
 	int sta_data_size;
 	u16 queues;
 	u16 ampdu_queues;
 	u16 max_listen_interval;
 	s8 max_signal;
 	u8 max_rates;
 	u8 max_rate_tries;
 };
 /**
  * SET_IEEE80211_DEV - set device for 802.11 hardware
  *
  * @hw: the &struct ieee80211_hw to set the device for
  * @dev: the &struct device of this 802.11 device
  */
 static inline void SET_IEEE80211_DEV(struct ieee80211_hw *hw, struct device *dev)
 {
 	set_wiphy_dev(hw->wiphy, dev);
 }
 /**
  * SET_IEEE80211_PERM_ADDR - set the permanent MAC address for 802.11 hardware
  *
  * @hw: the &struct ieee80211_hw to set the MAC address for
  * @addr: the address to set
  */
 static inline void SET_IEEE80211_PERM_ADDR(struct ieee80211_hw *hw, u8 *addr)
 {
 	memcpy(hw->wiphy->perm_addr, addr, ETH_ALEN);
 }
 static inline int ieee80211_num_regular_queues(struct ieee80211_hw *hw)
 {
 	return hw->queues;
 }
 static inline int ieee80211_num_queues(struct ieee80211_hw *hw)
 {
 	return hw->queues + hw->ampdu_queues;
 }
 static inline struct ieee80211_rate *
 ieee80211_get_tx_rate(const struct ieee80211_hw *hw,
 		      const struct ieee80211_tx_info *c)
 {
 	if (WARN_ON(c->control.rates[0].idx < 0))
 		return NULL;
 	return &hw->wiphy->bands[c->band]->bitrates[c->control.rates[0].idx];
 }
 static inline struct ieee80211_rate *
 ieee80211_get_rts_cts_rate(const struct ieee80211_hw *hw,
 			   const struct ieee80211_tx_info *c)
 {
 	if (c->control.rts_cts_rate_idx < 0)
 		return NULL;
 	return &hw->wiphy->bands[c->band]->bitrates[c->control.rts_cts_rate_idx];
 }
 static inline struct ieee80211_rate *
 ieee80211_get_alt_retry_rate(const struct ieee80211_hw *hw,
 			     const struct ieee80211_tx_info *c, int idx)
 {
 	if (c->control.rates[idx + 1].idx < 0)
 		return NULL;
 	return &hw->wiphy->bands[c->band]->bitrates[c->control.rates[idx + 1].idx];
 }
 /**
  * DOC: Hardware crypto acceleration
  *
  * mac80211 is capable of taking advantage of many hardware
  * acceleration designs for encryption and decryption operations.
  *
  * The set_key() callback in the &struct ieee80211_ops for a given
  * device is called to enable hardware acceleration of encryption and
  * decryption. The callback takes an @address parameter that will be
  * the broadcast address for default keys, the other station's hardware
  * address for individual keys or the zero address for keys that will
  * be used only for transmission.
  * Multiple transmission keys with the same key index may be used when
  * VLANs are configured for an access point.
  *
  * The @local_address parameter will always be set to our own address,
  * this is only relevant if you support multiple local addresses.
  *
  * When transmitting, the TX control data will use the @hw_key_idx
  * selected by the driver by modifying the &struct ieee80211_key_conf
  * pointed to by the @key parameter to the set_key() function.
  *
  * The set_key() call for the %SET_KEY command should return 0 if
  * the key is now in use, -%EOPNOTSUPP or -%ENOSPC if it couldn't be
  * added; if you return 0 then hw_key_idx must be assigned to the
  * hardware key index, you are free to use the full u8 range.
  *
  * When the cmd is %DISABLE_KEY then it must succeed.
  *
  * Note that it is permissible to not decrypt a frame even if a key
  * for it has been uploaded to hardware, the stack will not make any
  * decision based on whether a key has been uploaded or not but rather
  * based on the receive flags.
  *
  * The &struct ieee80211_key_conf structure pointed to by the @key
  * parameter is guaranteed to be valid until another call to set_key()
  * removes it, but it can only be used as a cookie to differentiate
  * keys.
  *
  * In TKIP some HW need to be provided a phase 1 key, for RX decryption
  * acceleration (i.e. iwlwifi). Those drivers should provide update_tkip_key
  * handler.
  * The update_tkip_key() call updates the driver with the new phase 1 key.
  * This happens everytime the iv16 wraps around (every 65536 packets). The
  * set_key() call will happen only once for each key (unless the AP did
  * rekeying), it will not include a valid phase 1 key. The valid phase 1 key is
  * provided by update_tkip_key only. The trigger that makes mac80211 call this
  * handler is software decryption with wrap around of iv16.
  */
 /**
  * DOC: Frame filtering
  *
  * mac80211 requires to see many management frames for proper
  * operation, and users may want to see many more frames when
  * in monitor mode. However, for best CPU usage and power consumption,
  * having as few frames as possible percolate through the stack is
  * desirable. Hence, the hardware should filter as much as possible.
  *
  * To achieve this, mac80211 uses filter flags (see below) to tell
  * the driver's configure_filter() function which frames should be
  * passed to mac80211 and which should be filtered out.
  *
  * The configure_filter() callback is invoked with the parameters
  * @mc_count and @mc_list for the combined multicast address list
  * of all virtual interfaces, @changed_flags telling which flags
  * were changed and @total_flags with the new flag states.
  *
  * If your device has no multicast address filters your driver will
  * need to check both the %FIF_ALLMULTI flag and the @mc_count
  * parameter to see whether multicast frames should be accepted
  * or dropped.
  *
  * All unsupported flags in @total_flags must be cleared.
  * Hardware does not support a flag if it is incapable of _passing_
  * the frame to the stack. Otherwise the driver must ignore
  * the flag, but not clear it.
  * You must _only_ clear the flag (announce no support for the
  * flag to mac80211) if you are not able to pass the packet type
  * to the stack (so the hardware always filters it).
  * So for example, you should clear @FIF_CONTROL, if your hardware
  * always filters control frames. If your hardware always passes
  * control frames to the kernel and is incapable of filtering them,
  * you do _not_ clear the @FIF_CONTROL flag.
  * This rule applies to all other FIF flags as well.
  */
 /**
  * enum ieee80211_filter_flags - hardware filter flags
  *
  * These flags determine what the filter in hardware should be
  * programmed to let through and what should not be passed to the
  * stack. It is always safe to pass more frames than requested,
  * but this has negative impact on power consumption.
  *
  * @FIF_PROMISC_IN_BSS: promiscuous mode within your BSS,
  *	think of the BSS as your network segment and then this corresponds
  *	to the regular ethernet device promiscuous mode.
  *
  * @FIF_ALLMULTI: pass all multicast frames, this is used if requested
  *	by the user or if the hardware is not capable of filtering by
  *	multicast address.
  *
  * @FIF_FCSFAIL: pass frames with failed FCS (but you need to set the
  *	%RX_FLAG_FAILED_FCS_CRC for them)
  *
  * @FIF_PLCPFAIL: pass frames with failed PLCP CRC (but you need to set
  *	the %RX_FLAG_FAILED_PLCP_CRC for them
  *
  * @FIF_BCN_PRBRESP_PROMISC: This flag is set during scanning to indicate
  *	to the hardware that it should not filter beacons or probe responses
  *	by BSSID. Filtering them can greatly reduce the amount of processing
  *	mac80211 needs to do and the amount of CPU wakeups, so you should
  *	honour this flag if possible.
  *
  * @FIF_CONTROL: pass control frames, if PROMISC_IN_BSS is not set then
  *	only those addressed to this station
  *
  * @FIF_OTHER_BSS: pass frames destined to other BSSes
  */
 enum ieee80211_filter_flags {
 	FIF_PROMISC_IN_BSS	= 1<<0,
 	FIF_ALLMULTI		= 1<<1,
 	FIF_FCSFAIL		= 1<<2,
 	FIF_PLCPFAIL		= 1<<3,
 	FIF_BCN_PRBRESP_PROMISC	= 1<<4,
 	FIF_CONTROL		= 1<<5,
 	FIF_OTHER_BSS		= 1<<6,
 };
 /**
  * enum ieee80211_ampdu_mlme_action - A-MPDU actions
  *
  * These flags are used with the ampdu_action() callback in
  * &struct ieee80211_ops to indicate which action is needed.
  * @IEEE80211_AMPDU_RX_START: start Rx aggregation
  * @IEEE80211_AMPDU_RX_STOP: stop Rx aggregation
  * @IEEE80211_AMPDU_TX_START: start Tx aggregation
  * @IEEE80211_AMPDU_TX_STOP: stop Tx aggregation
  * @IEEE80211_AMPDU_TX_RESUME: resume TX aggregation
  */
 enum ieee80211_ampdu_mlme_action {
 	IEEE80211_AMPDU_RX_START,
 	IEEE80211_AMPDU_RX_STOP,
 	IEEE80211_AMPDU_TX_START,
 	IEEE80211_AMPDU_TX_STOP,
 	IEEE80211_AMPDU_TX_RESUME,
 };
 /**
  * struct ieee80211_ops - callbacks from mac80211 to the driver
  *
  * This structure contains various callbacks that the driver may
  * handle or, in some cases, must handle, for example to configure
  * the hardware to a new channel or to transmit a frame.
  *
  * @tx: Handler that 802.11 module calls for each transmitted frame.
  *	skb contains the buffer starting from the IEEE 802.11 header.
  *	The low-level driver should send the frame out based on
  *	configuration in the TX control data. This handler should,
  *	preferably, never fail and stop queues appropriately, more
  *	importantly, however, it must never fail for A-MPDU-queues.
  *	Must be implemented and atomic.
  *
  * @start: Called before the first netdevice attached to the hardware
  *	is enabled. This should turn on the hardware and must turn on
  *	frame reception (for possibly enabled monitor interfaces.)
  *	Returns negative error codes, these may be seen in userspace,
  *	or zero.
  *	When the device is started it should not have a MAC address
  *	to avoid acknowledging frames before a non-monitor device
  *	is added.
  *	Must be implemented.
  *
  * @stop: Called after last netdevice attached to the hardware
  *	is disabled. This should turn off the hardware (at least
  *	it must turn off frame reception.)
  *	May be called right after add_interface if that rejects
  *	an interface.
  *	Must be implemented.
  *
  * @add_interface: Called when a netdevice attached to the hardware is
  *	enabled. Because it is not called for monitor mode devices, @start
  *	and @stop must be implemented.
  *	The driver should perform any initialization it needs before
  *	the device can be enabled. The initial configuration for the
  *	interface is given in the conf parameter.
  *	The callback may refuse to add an interface by returning a
  *	negative error code (which will be seen in userspace.)
  *	Must be implemented.
  *
  * @remove_interface: Notifies a driver that an interface is going down.
  *	The @stop callback is called after this if it is the last interface
  *	and no monitor interfaces are present.
  *	When all interfaces are removed, the MAC address in the hardware
  *	must be cleared so the device no longer acknowledges packets,
  *	the mac_addr member of the conf structure is, however, set to the
  *	MAC address of the device going away.
  *	Hence, this callback must be implemented.
  *
  * @config: Handler for configuration requests. IEEE 802.11 code calls this
  *	function to change hardware configuration, e.g., channel.
  *
  * @config_interface: Handler for configuration requests related to interfaces
  *	(e.g. BSSID changes.)
  *
  * @bss_info_changed: Handler for configuration requests related to BSS
  *	parameters that may vary during BSS's lifespan, and may affect low
  *	level driver (e.g. assoc/disassoc status, erp parameters).
  *	This function should not be used if no BSS has been set, unless
  *	for association indication. The @changed parameter indicates which
  *	of the bss parameters has changed when a call is made.
  *
  * @configure_filter: Configure the device's RX filter.
  *	See the section "Frame filtering" for more information.
  *	This callback must be implemented and atomic.
  *
  * @set_tim: Set TIM bit. mac80211 calls this function when a TIM bit
  * 	must be set or cleared for a given STA. Must be atomic.
  *
  * @set_key: See the section "Hardware crypto acceleration"
  *	This callback can sleep, and is only called between add_interface
  *	and remove_interface calls, i.e. while the interface with the
  *	given local_address is enabled.
  *
  * @update_tkip_key: See the section "Hardware crypto acceleration"
  * 	This callback will be called in the context of Rx. Called for drivers
  * 	which set IEEE80211_KEY_FLAG_TKIP_REQ_RX_P1_KEY.
  *
  * @hw_scan: Ask the hardware to service the scan request, no need to start
  *	the scan state machine in stack. The scan must honour the channel
  *	configuration done by the regulatory agent in the wiphy's registered
  *	bands. When the scan finishes, ieee80211_scan_completed() must be
  *	called; note that it also must be called when the scan cannot finish
  *	because the hardware is turned off! Anything else is a bug!
  *
  * @get_stats: return low-level statistics
  *
  * @get_tkip_seq: If your device implements TKIP encryption in hardware this
  *	callback should be provided to read the TKIP transmit IVs (both IV32
  *	and IV16) for the given key from hardware.
  *
  * @set_rts_threshold: Configuration of RTS threshold (if device needs it)
  *
  * @sta_notify: Notifies low level driver about addition, removal or power
  *	state transition of an associated station, AP,  IBSS/WDS/mesh peer etc.
  *	Must be atomic.
  *
  * @conf_tx: Configure TX queue parameters (EDCF (aifs, cw_min, cw_max),
  *	bursting) for a hardware TX queue.
  *
  * @get_tx_stats: Get statistics of the current TX queue status. This is used
  *	to get number of currently queued packets (queue length), maximum queue
  *	size (limit), and total number of packets sent using each TX queue
  *	(count). The 'stats' pointer points to an array that has hw->queues +
  *	hw->ampdu_queues items.
  *
  * @get_tsf: Get the current TSF timer value from firmware/hardware. Currently,
  *	this is only used for IBSS mode debugging and, as such, is not a
  *	required function. Must be atomic.
  *
  * @reset_tsf: Reset the TSF timer and allow firmware/hardware to synchronize
  *	with other STAs in the IBSS. This is only used in IBSS mode. This
  *	function is optional if the firmware/hardware takes full care of
  *	TSF synchronization.
  *
  * @tx_last_beacon: Determine whether the last IBSS beacon was sent by us.
  *	This is needed only for IBSS mode and the result of this function is
  *	used to determine whether to reply to Probe Requests.
  *
  * @ampdu_action: Perform a certain A-MPDU action
  * 	The RA/TID combination determines the destination and TID we want
  * 	the ampdu action to be performed for. The action is defined through
  * 	ieee80211_ampdu_mlme_action. Starting sequence number (@ssn)
  * 	is the first frame we expect to perform the action on. notice
  * 	that TX/RX_STOP can pass NULL for this parameter.
  */
 struct ieee80211_ops {
 	int (*tx)(struct ieee80211_hw *hw, struct sk_buff *skb);
 	int (*start)(struct ieee80211_hw *hw);
 	void (*stop)(struct ieee80211_hw *hw);
 	int (*add_interface)(struct ieee80211_hw *hw,
 			     struct ieee80211_if_init_conf *conf);
 	void (*remove_interface)(struct ieee80211_hw *hw,
 				 struct ieee80211_if_init_conf *conf);
 	int (*config)(struct ieee80211_hw *hw, u32 changed);
 	int (*config_interface)(struct ieee80211_hw *hw,
 				struct ieee80211_vif *vif,
 				struct ieee80211_if_conf *conf);
 	void (*bss_info_changed)(struct ieee80211_hw *hw,
 				 struct ieee80211_vif *vif,
 				 struct ieee80211_bss_conf *info,
 				 u32 changed);
 	void (*configure_filter)(struct ieee80211_hw *hw,
 				 unsigned int changed_flags,
 				 unsigned int *total_flags,
 				 int mc_count, struct dev_addr_list *mc_list);
 	int (*set_tim)(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
 		       bool set);
 	int (*set_key)(struct ieee80211_hw *hw, enum set_key_cmd cmd,
 		       const u8 *local_address, const u8 *address,
 		       struct ieee80211_key_conf *key);
 	void (*update_tkip_key)(struct ieee80211_hw *hw,
 			struct ieee80211_key_conf *conf, const u8 *address,
 			u32 iv32, u16 *phase1key);
 	int (*hw_scan)(struct ieee80211_hw *hw, u8 *ssid, size_t len);
 	int (*get_stats)(struct ieee80211_hw *hw,
 			 struct ieee80211_low_level_stats *stats);
 	void (*get_tkip_seq)(struct ieee80211_hw *hw, u8 hw_key_idx,
 			     u32 *iv32, u16 *iv16);
 	int (*set_rts_threshold)(struct ieee80211_hw *hw, u32 value);
 	void (*sta_notify)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 			enum sta_notify_cmd, struct ieee80211_sta *sta);
 	int (*conf_tx)(struct ieee80211_hw *hw, u16 queue,
 		       const struct ieee80211_tx_queue_params *params);
 	int (*get_tx_stats)(struct ieee80211_hw *hw,
 			    struct ieee80211_tx_queue_stats *stats);
 	u64 (*get_tsf)(struct ieee80211_hw *hw);
 	void (*reset_tsf)(struct ieee80211_hw *hw);
 	int (*tx_last_beacon)(struct ieee80211_hw *hw);
 	int (*ampdu_action)(struct ieee80211_hw *hw,
 			    enum ieee80211_ampdu_mlme_action action,
 			    struct ieee80211_sta *sta, u16 tid, u16 *ssn);
 };
 /**
  * ieee80211_alloc_hw -  Allocate a new hardware device
  *
  * This must be called once for each hardware device. The returned pointer
  * must be used to refer to this device when calling other functions.
  * mac80211 allocates a private data area for the driver pointed to by
  * @priv in &struct ieee80211_hw, the size of this area is given as
  * @priv_data_len.
  *
  * @priv_data_len: length of private data
  * @ops: callbacks for this device
  */
 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
 					const struct ieee80211_ops *ops);
 /**
  * ieee80211_register_hw - Register hardware device
  *
  * You must call this function before any other functions in
  * mac80211. Note that before a hardware can be registered, you
  * need to fill the contained wiphy's information.
  *
  * @hw: the device to register as returned by ieee80211_alloc_hw()
  */
 int ieee80211_register_hw(struct ieee80211_hw *hw);
 #ifdef CONFIG_MAC80211_LEDS
 extern char *__ieee80211_get_tx_led_name(struct ieee80211_hw *hw);
 extern char *__ieee80211_get_rx_led_name(struct ieee80211_hw *hw);
 extern char *__ieee80211_get_assoc_led_name(struct ieee80211_hw *hw);
 extern char *__ieee80211_get_radio_led_name(struct ieee80211_hw *hw);
 #endif
 /**
  * ieee80211_get_tx_led_name - get name of TX LED
  *
  * mac80211 creates a transmit LED trigger for each wireless hardware
  * that can be used to drive LEDs if your driver registers a LED device.
  * This function returns the name (or %NULL if not configured for LEDs)
  * of the trigger so you can automatically link the LED device.
  *
  * @hw: the hardware to get the LED trigger name for
  */
 static inline char *ieee80211_get_tx_led_name(struct ieee80211_hw *hw)
 {
 #ifdef CONFIG_MAC80211_LEDS
 	return __ieee80211_get_tx_led_name(hw);
 #else
 	return NULL;
 #endif
 }
 /**
  * ieee80211_get_rx_led_name - get name of RX LED
  *
  * mac80211 creates a receive LED trigger for each wireless hardware
  * that can be used to drive LEDs if your driver registers a LED device.
  * This function returns the name (or %NULL if not configured for LEDs)
  * of the trigger so you can automatically link the LED device.
  *
  * @hw: the hardware to get the LED trigger name for
  */
 static inline char *ieee80211_get_rx_led_name(struct ieee80211_hw *hw)
 {
 #ifdef CONFIG_MAC80211_LEDS
 	return __ieee80211_get_rx_led_name(hw);
 #else
 	return NULL;
 #endif
 }
 /**
  * ieee80211_get_assoc_led_name - get name of association LED
  *
  * mac80211 creates a association LED trigger for each wireless hardware
  * that can be used to drive LEDs if your driver registers a LED device.
  * This function returns the name (or %NULL if not configured for LEDs)
  * of the trigger so you can automatically link the LED device.
  *
  * @hw: the hardware to get the LED trigger name for
  */
 static inline char *ieee80211_get_assoc_led_name(struct ieee80211_hw *hw)
 {
 #ifdef CONFIG_MAC80211_LEDS
 	return __ieee80211_get_assoc_led_name(hw);
 #else
 	return NULL;
 #endif
 }
 /**
  * ieee80211_get_radio_led_name - get name of radio LED
  *
  * mac80211 creates a radio change LED trigger for each wireless hardware
  * that can be used to drive LEDs if your driver registers a LED device.
  * This function returns the name (or %NULL if not configured for LEDs)
  * of the trigger so you can automatically link the LED device.
  *
  * @hw: the hardware to get the LED trigger name for
  */
 static inline char *ieee80211_get_radio_led_name(struct ieee80211_hw *hw)
 {
 #ifdef CONFIG_MAC80211_LEDS
 	return __ieee80211_get_radio_led_name(hw);
 #else
 	return NULL;
 #endif
 }
 /**
  * ieee80211_unregister_hw - Unregister a hardware device
  *
  * This function instructs mac80211 to free allocated resources
  * and unregister netdevices from the networking subsystem.
  *
  * @hw: the hardware to unregister
  */
 void ieee80211_unregister_hw(struct ieee80211_hw *hw);
 /**
  * ieee80211_free_hw - free hardware descriptor
  *
  * This function frees everything that was allocated, including the
  * private data for the driver. You must call ieee80211_unregister_hw()
  * before calling this function.
  *
  * @hw: the hardware to free
  */
 void ieee80211_free_hw(struct ieee80211_hw *hw);
 /* trick to avoid symbol clashes with the ieee80211 subsystem */
 void __ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb,
 		    struct ieee80211_rx_status *status);
 /**
  * ieee80211_rx - receive frame
  *
  * Use this function to hand received frames to mac80211. The receive
  * buffer in @skb must start with an IEEE 802.11 header or a radiotap
  * header if %RX_FLAG_RADIOTAP is set in the @status flags.
  *
  * This function may not be called in IRQ context. Calls to this function
  * for a single hardware must be synchronized against each other. Calls
  * to this function and ieee80211_rx_irqsafe() may not be mixed for a
  * single hardware.
  *
  * @hw: the hardware this frame came in on
  * @skb: the buffer to receive, owned by mac80211 after this call
  * @status: status of this frame; the status pointer need not be valid
  *	after this function returns
  */
 static inline void ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb,
 				struct ieee80211_rx_status *status)
 {
 	__ieee80211_rx(hw, skb, status);
 }
 /**
  * ieee80211_rx_irqsafe - receive frame
  *
  * Like ieee80211_rx() but can be called in IRQ context
  * (internally defers to a tasklet.)
  *
  * Calls to this function and ieee80211_rx() may not be mixed for a
  * single hardware.
  *
  * @hw: the hardware this frame came in on
  * @skb: the buffer to receive, owned by mac80211 after this call
  * @status: status of this frame; the status pointer need not be valid
  *	after this function returns and is not freed by mac80211,
  *	it is recommended that it points to a stack area
  */
 void ieee80211_rx_irqsafe(struct ieee80211_hw *hw,
 			  struct sk_buff *skb,
 			  struct ieee80211_rx_status *status);
 /**
  * ieee80211_tx_status - transmit status callback
  *
  * Call this function for all transmitted frames after they have been
  * transmitted. It is permissible to not call this function for
  * multicast frames but this can affect statistics.
  *
  * This function may not be called in IRQ context. Calls to this function
  * for a single hardware must be synchronized against each other. Calls
  * to this function and ieee80211_tx_status_irqsafe() may not be mixed
  * for a single hardware.
  *
  * @hw: the hardware the frame was transmitted by
  * @skb: the frame that was transmitted, owned by mac80211 after this call
  */
 void ieee80211_tx_status(struct ieee80211_hw *hw,
 			 struct sk_buff *skb);
 /**
  * ieee80211_tx_status_irqsafe - IRQ-safe transmit status callback
  *
  * Like ieee80211_tx_status() but can be called in IRQ context
  * (internally defers to a tasklet.)
  *
  * Calls to this function and ieee80211_tx_status() may not be mixed for a
  * single hardware.
  *
  * @hw: the hardware the frame was transmitted by
  * @skb: the frame that was transmitted, owned by mac80211 after this call
  */
 void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
 				 struct sk_buff *skb);
 /**
  * ieee80211_beacon_get - beacon generation function
  * @hw: pointer obtained from ieee80211_alloc_hw().
  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
  *
  * If the beacon frames are generated by the host system (i.e., not in
  * hardware/firmware), the low-level driver uses this function to receive
  * the next beacon frame from the 802.11 code. The low-level is responsible
  * for calling this function before beacon data is needed (e.g., based on
  * hardware interrupt). Returned skb is used only once and low-level driver
  * is responsible for freeing it.
  */
 struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
 				     struct ieee80211_vif *vif);
 /**
  * ieee80211_rts_get - RTS frame generation function
  * @hw: pointer obtained from ieee80211_alloc_hw().
  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
  * @frame: pointer to the frame that is going to be protected by the RTS.
  * @frame_len: the frame length (in octets).
  * @frame_txctl: &struct ieee80211_tx_info of the frame.
  * @rts: The buffer where to store the RTS frame.
  *
  * If the RTS frames are generated by the host system (i.e., not in
  * hardware/firmware), the low-level driver uses this function to receive
  * the next RTS frame from the 802.11 code. The low-level is responsible
  * for calling this function before and RTS frame is needed.
  */
 void ieee80211_rts_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 		       const void *frame, size_t frame_len,
 		       const struct ieee80211_tx_info *frame_txctl,
 		       struct ieee80211_rts *rts);
 /**
  * ieee80211_rts_duration - Get the duration field for an RTS frame
  * @hw: pointer obtained from ieee80211_alloc_hw().
  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
  * @frame_len: the length of the frame that is going to be protected by the RTS.
  * @frame_txctl: &struct ieee80211_tx_info of the frame.
  *
  * If the RTS is generated in firmware, but the host system must provide
  * the duration field, the low-level driver uses this function to receive
  * the duration field value in little-endian byteorder.
  */
 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
 			      struct ieee80211_vif *vif, size_t frame_len,
 			      const struct ieee80211_tx_info *frame_txctl);
 /**
  * ieee80211_ctstoself_get - CTS-to-self frame generation function
  * @hw: pointer obtained from ieee80211_alloc_hw().
  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
  * @frame: pointer to the frame that is going to be protected by the CTS-to-self.
  * @frame_len: the frame length (in octets).
  * @frame_txctl: &struct ieee80211_tx_info of the frame.
  * @cts: The buffer where to store the CTS-to-self frame.
  *
  * If the CTS-to-self frames are generated by the host system (i.e., not in
  * hardware/firmware), the low-level driver uses this function to receive
  * the next CTS-to-self frame from the 802.11 code. The low-level is responsible
  * for calling this function before and CTS-to-self frame is needed.
  */
 void ieee80211_ctstoself_get(struct ieee80211_hw *hw,
 			     struct ieee80211_vif *vif,
 			     const void *frame, size_t frame_len,
 			     const struct ieee80211_tx_info *frame_txctl,
 			     struct ieee80211_cts *cts);
 /**
  * ieee80211_ctstoself_duration - Get the duration field for a CTS-to-self frame
  * @hw: pointer obtained from ieee80211_alloc_hw().
  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
  * @frame_len: the length of the frame that is going to be protected by the CTS-to-self.
  * @frame_txctl: &struct ieee80211_tx_info of the frame.
  *
  * If the CTS-to-self is generated in firmware, but the host system must provide
  * the duration field, the low-level driver uses this function to receive
  * the duration field value in little-endian byteorder.
  */
 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
 				    struct ieee80211_vif *vif,
 				    size_t frame_len,
 				    const struct ieee80211_tx_info *frame_txctl);
 /**
  * ieee80211_generic_frame_duration - Calculate the duration field for a frame
  * @hw: pointer obtained from ieee80211_alloc_hw().
  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
  * @frame_len: the length of the frame.
  * @rate: the rate at which the frame is going to be transmitted.
  *
  * Calculate the duration field of some generic frame, given its
  * length and transmission rate (in 100kbps).
  */
 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
 					struct ieee80211_vif *vif,
 					size_t frame_len,
 					struct ieee80211_rate *rate);
 /**
  * ieee80211_get_buffered_bc - accessing buffered broadcast and multicast frames
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
  *
  * Function for accessing buffered broadcast and multicast frames. If
  * hardware/firmware does not implement buffering of broadcast/multicast
  * frames when power saving is used, 802.11 code buffers them in the host
  * memory. The low-level driver uses this function to fetch next buffered
  * frame. In most cases, this is used when generating beacon frame. This
  * function returns a pointer to the next buffered skb or NULL if no more
  * buffered frames are available.
  *
  * Note: buffered frames are returned only after DTIM beacon frame was
  * generated with ieee80211_beacon_get() and the low-level driver must thus
  * call ieee80211_beacon_get() first. ieee80211_get_buffered_bc() returns
  * NULL if the previous generated beacon was not DTIM, so the low-level driver
  * does not need to check for DTIM beacons separately and should be able to
  * use common code for all beacons.
  */
 struct sk_buff *
 ieee80211_get_buffered_bc(struct ieee80211_hw *hw, struct ieee80211_vif *vif);
 /**
  * ieee80211_get_hdrlen_from_skb - get header length from data
  *
  * Given an skb with a raw 802.11 header at the data pointer this function
  * returns the 802.11 header length in bytes (not including encryption
  * headers). If the data in the sk_buff is too short to contain a valid 802.11
  * header the function returns 0.
  *
  * @skb: the frame
  */
 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb);
 /**
  * ieee80211_hdrlen - get header length in bytes from frame control
  * @fc: frame control field in little-endian format
  */
 unsigned int ieee80211_hdrlen(__le16 fc);
 /**
  * ieee80211_get_tkip_key - get a TKIP rc4 for skb
  *
  * This function computes a TKIP rc4 key for an skb. It computes
  * a phase 1 key if needed (iv16 wraps around). This function is to
  * be used by drivers which can do HW encryption but need to compute
  * to phase 1/2 key in SW.
  *
  * @keyconf: the parameter passed with the set key
  * @skb: the skb for which the key is needed
  * @type: TBD
  * @key: a buffer to which the key will be written
  */
 void ieee80211_get_tkip_key(struct ieee80211_key_conf *keyconf,
 				struct sk_buff *skb,
 				enum ieee80211_tkip_key_type type, u8 *key);
 /**
  * ieee80211_wake_queue - wake specific queue
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  * @queue: queue number (counted from zero).
  *
  * Drivers should use this function instead of netif_wake_queue.
  */
 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue);
 /**
  * ieee80211_stop_queue - stop specific queue
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  * @queue: queue number (counted from zero).
  *
  * Drivers should use this function instead of netif_stop_queue.
  */
 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue);
 /**
  * ieee80211_queue_stopped - test status of the queue
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  * @queue: queue number (counted from zero).
  *
  * Drivers should use this function instead of netif_stop_queue.
  */
 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue);
 /**
  * ieee80211_stop_queues - stop all queues
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  *
  * Drivers should use this function instead of netif_stop_queue.
  */
 void ieee80211_stop_queues(struct ieee80211_hw *hw);
 /**
  * ieee80211_wake_queues - wake all queues
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  *
  * Drivers should use this function instead of netif_wake_queue.
  */
 void ieee80211_wake_queues(struct ieee80211_hw *hw);
 /**
  * ieee80211_scan_completed - completed hardware scan
  *
  * When hardware scan offload is used (i.e. the hw_scan() callback is
  * assigned) this function needs to be called by the driver to notify
  * mac80211 that the scan finished.
  *
  * @hw: the hardware that finished the scan
  */
 void ieee80211_scan_completed(struct ieee80211_hw *hw);
 /**
  * ieee80211_iterate_active_interfaces - iterate active interfaces
  *
  * This function iterates over the interfaces associated with a given
  * hardware that are currently active and calls the callback for them.
  * This function allows the iterator function to sleep, when the iterator
  * function is atomic @ieee80211_iterate_active_interfaces_atomic can
  * be used.
  *
  * @hw: the hardware struct of which the interfaces should be iterated over
  * @iterator: the iterator function to call
  * @data: first argument of the iterator function
  */
 void ieee80211_iterate_active_interfaces(struct ieee80211_hw *hw,
 					 void (*iterator)(void *data, u8 *mac,
 						struct ieee80211_vif *vif),
 					 void *data);
 /**
  * ieee80211_iterate_active_interfaces_atomic - iterate active interfaces
  *
  * This function iterates over the interfaces associated with a given
  * hardware that are currently active and calls the callback for them.
  * This function requires the iterator callback function to be atomic,
  * if that is not desired, use @ieee80211_iterate_active_interfaces instead.
  *
  * @hw: the hardware struct of which the interfaces should be iterated over
  * @iterator: the iterator function to call, cannot sleep
  * @data: first argument of the iterator function
  */
 void ieee80211_iterate_active_interfaces_atomic(struct ieee80211_hw *hw,
 						void (*iterator)(void *data,
 						    u8 *mac,
 						    struct ieee80211_vif *vif),
 						void *data);
 /**
  * ieee80211_start_tx_ba_session - Start a tx Block Ack session.
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  * @ra: receiver address of the BA session recipient
  * @tid: the TID to BA on.
  *
  * Return: success if addBA request was sent, failure otherwise
  *
  * Although mac80211/low level driver/user space application can estimate
  * the need to start aggregation on a certain RA/TID, the session level
  * will be managed by the mac80211.
  */
 int ieee80211_start_tx_ba_session(struct ieee80211_hw *hw, u8 *ra, u16 tid);
 /**
  * ieee80211_start_tx_ba_cb - low level driver ready to aggregate.
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  * @ra: receiver address of the BA session recipient.
  * @tid: the TID to BA on.
  *
  * This function must be called by low level driver once it has
  * finished with preparations for the BA session.
  */
 void ieee80211_start_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u16 tid);
 /**
  * ieee80211_start_tx_ba_cb_irqsafe - low level driver ready to aggregate.
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  * @ra: receiver address of the BA session recipient.
  * @tid: the TID to BA on.
  *
  * This function must be called by low level driver once it has
  * finished with preparations for the BA session.
  * This version of the function is IRQ-safe.
  */
 void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_hw *hw, const u8 *ra,
 				      u16 tid);
 /**
  * ieee80211_stop_tx_ba_session - Stop a Block Ack session.
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  * @ra: receiver address of the BA session recipient
  * @tid: the TID to stop BA.
  * @initiator: if indicates initiator DELBA frame will be sent.
  *
  * Return: error if no sta with matching da found, success otherwise
  *
  * Although mac80211/low level driver/user space application can estimate
  * the need to stop aggregation on a certain RA/TID, the session level
  * will be managed by the mac80211.
  */
 int ieee80211_stop_tx_ba_session(struct ieee80211_hw *hw,
 				 u8 *ra, u16 tid,
 				 enum ieee80211_back_parties initiator);
 /**
  * ieee80211_stop_tx_ba_cb - low level driver ready to stop aggregate.
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  * @ra: receiver address of the BA session recipient.
  * @tid: the desired TID to BA on.
  *
  * This function must be called by low level driver once it has
  * finished with preparations for the BA session tear down.
  */
 void ieee80211_stop_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u8 tid);
 /**
  * ieee80211_stop_tx_ba_cb_irqsafe - low level driver ready to stop aggregate.
  * @hw: pointer as obtained from ieee80211_alloc_hw().
  * @ra: receiver address of the BA session recipient.
  * @tid: the desired TID to BA on.
  *
  * This function must be called by low level driver once it has
  * finished with preparations for the BA session tear down.
  * This version of the function is IRQ-safe.
  */
 void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_hw *hw, const u8 *ra,
 				     u16 tid);
 /**
  * ieee80211_find_sta - find a station
  *
  * @hw: pointer as obtained from ieee80211_alloc_hw()
  * @addr: station's address
  *
  * This function must be called under RCU lock and the
  * resulting pointer is only valid under RCU lock as well.
  */
 struct ieee80211_sta *ieee80211_find_sta(struct ieee80211_hw *hw,
 					 const u8 *addr);
 /* Rate control API */
 /**
  * struct ieee80211_tx_rate_control - rate control information for/from RC algo
  *
  * @hw: The hardware the algorithm is invoked for.
  * @sband: The band this frame is being transmitted on.
  * @bss_conf: the current BSS configuration
  * @reported_rate: The rate control algorithm can fill this in to indicate
  *	which rate should be reported to userspace as the current rate and
  *	used for rate calculations in the mesh network.
  * @rts: whether RTS will be used for this frame because it is longer than the
  *	RTS threshold
  * @short_preamble: whether mac80211 will request short-preamble transmission
  *	if the selected rate supports it
  * @max_rate_idx: user-requested maximum rate (not MCS for now)
  * @skb: the skb that will be transmitted, the control information in it needs
  *	to be filled in
  */
 struct ieee80211_tx_rate_control {
 	struct ieee80211_hw *hw;
 	struct ieee80211_supported_band *sband;
 	struct ieee80211_bss_conf *bss_conf;
 	struct sk_buff *skb;
 	struct ieee80211_tx_rate reported_rate;
 	bool rts, short_preamble;
 	u8 max_rate_idx;
 };
 struct rate_control_ops {
 	struct module *module;
 	const char *name;
 	void *(*alloc)(struct ieee80211_hw *hw, struct dentry *debugfsdir);
 	void (*free)(void *priv);
 	void *(*alloc_sta)(void *priv, struct ieee80211_sta *sta, gfp_t gfp);
 	void (*rate_init)(void *priv, struct ieee80211_supported_band *sband,
 			  struct ieee80211_sta *sta, void *priv_sta);
 	void (*free_sta)(void *priv, struct ieee80211_sta *sta,
 			 void *priv_sta);
 	void (*tx_status)(void *priv, struct ieee80211_supported_band *sband,
 			  struct ieee80211_sta *sta, void *priv_sta,
 			  struct sk_buff *skb);
 	void (*get_rate)(void *priv, struct ieee80211_sta *sta, void *priv_sta,
 			 struct ieee80211_tx_rate_control *txrc);
 	void (*add_sta_debugfs)(void *priv, void *priv_sta,
 				struct dentry *dir);
 	void (*remove_sta_debugfs)(void *priv, void *priv_sta);
 };
 static inline int rate_supported(struct ieee80211_sta *sta,
 				 enum ieee80211_band band,
 				 int index)
 {
 	return (sta == NULL || sta->supp_rates[band] & BIT(index));
 }
 static inline s8
 rate_lowest_index(struct ieee80211_supported_band *sband,
 		  struct ieee80211_sta *sta)
 {
 	int i;
 	for (i = 0; i < sband->n_bitrates; i++)
 		if (rate_supported(sta, sband->band, i))
 			return i;
 	/* warn when we cannot find a rate. */
 	WARN_ON(1);
 	return 0;
 }
 int ieee80211_rate_control_register(struct rate_control_ops *ops);
 void ieee80211_rate_control_unregister(struct rate_control_ops *ops);
 #endif /* MAC80211_H */

net/mac80211/cfg.c

Diff comments View file @ 094d05d

1	/*	1	/*
2	* mac80211 configuration hooks for cfg80211	2	* mac80211 configuration hooks for cfg80211
3	*	3	*
4	* Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>	4	* Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>
5	*	5	*
6	* This file is GPLv2 as found in COPYING.	6	* This file is GPLv2 as found in COPYING.
7	*/	7	*/
8		8
9	#include <linux/ieee80211.h>	9	#include <linux/ieee80211.h>
10	#include <linux/nl80211.h>	10	#include <linux/nl80211.h>
11	#include <linux/rtnetlink.h>	11	#include <linux/rtnetlink.h>
12	#include <net/net_namespace.h>	12	#include <net/net_namespace.h>
13	#include <linux/rcupdate.h>	13	#include <linux/rcupdate.h>
14	#include <net/cfg80211.h>	14	#include <net/cfg80211.h>
15	#include "ieee80211_i.h"	15	#include "ieee80211_i.h"
16	#include "cfg.h"	16	#include "cfg.h"
17	#include "rate.h"	17	#include "rate.h"
18	#include "mesh.h"	18	#include "mesh.h"
19		19
20	static bool nl80211_type_check(enum nl80211_iftype type)	20	static bool nl80211_type_check(enum nl80211_iftype type)
21	{	21	{
22	switch (type) {	22	switch (type) {
23	case NL80211_IFTYPE_ADHOC:	23	case NL80211_IFTYPE_ADHOC:
24	case NL80211_IFTYPE_STATION:	24	case NL80211_IFTYPE_STATION:
25	case NL80211_IFTYPE_MONITOR:	25	case NL80211_IFTYPE_MONITOR:
26	#ifdef CONFIG_MAC80211_MESH	26	#ifdef CONFIG_MAC80211_MESH
27	case NL80211_IFTYPE_MESH_POINT:	27	case NL80211_IFTYPE_MESH_POINT:
28	#endif	28	#endif
29	case NL80211_IFTYPE_AP:	29	case NL80211_IFTYPE_AP:
30	case NL80211_IFTYPE_AP_VLAN:	30	case NL80211_IFTYPE_AP_VLAN:
31	case NL80211_IFTYPE_WDS:	31	case NL80211_IFTYPE_WDS:
32	return true;	32	return true;
33	default:	33	default:
34	return false;	34	return false;
35	}	35	}
36	}	36	}
37		37
38	static int ieee80211_add_iface(struct wiphy wiphy, char name,	38	static int ieee80211_add_iface(struct wiphy wiphy, char name,
39	enum nl80211_iftype type, u32 *flags,	39	enum nl80211_iftype type, u32 *flags,
40	struct vif_params *params)	40	struct vif_params *params)
41	{	41	{
42	struct ieee80211_local *local = wiphy_priv(wiphy);	42	struct ieee80211_local *local = wiphy_priv(wiphy);
43	struct net_device *dev;	43	struct net_device *dev;
44	struct ieee80211_sub_if_data *sdata;	44	struct ieee80211_sub_if_data *sdata;
45	int err;	45	int err;
46		46
47	if (!nl80211_type_check(type))	47	if (!nl80211_type_check(type))
48	return -EINVAL;	48	return -EINVAL;
49		49
50	err = ieee80211_if_add(local, name, &dev, type, params);	50	err = ieee80211_if_add(local, name, &dev, type, params);
51	if (err \|\| type != NL80211_IFTYPE_MONITOR \|\| !flags)	51	if (err \|\| type != NL80211_IFTYPE_MONITOR \|\| !flags)
52	return err;	52	return err;
53		53
54	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	54	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
55	sdata->u.mntr_flags = *flags;	55	sdata->u.mntr_flags = *flags;
56	return 0;	56	return 0;
57	}	57	}
58		58
59	static int ieee80211_del_iface(struct wiphy *wiphy, int ifindex)	59	static int ieee80211_del_iface(struct wiphy *wiphy, int ifindex)
60	{	60	{
61	struct net_device *dev;	61	struct net_device *dev;
62	struct ieee80211_sub_if_data *sdata;	62	struct ieee80211_sub_if_data *sdata;
63		63
64	/* we're under RTNL */	64	/* we're under RTNL */
65	dev = __dev_get_by_index(&init_net, ifindex);	65	dev = __dev_get_by_index(&init_net, ifindex);
66	if (!dev)	66	if (!dev)
67	return -ENODEV;	67	return -ENODEV;
68		68
69	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	69	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
70		70
71	ieee80211_if_remove(sdata);	71	ieee80211_if_remove(sdata);
72		72
73	return 0;	73	return 0;
74	}	74	}
75		75
76	static int ieee80211_change_iface(struct wiphy *wiphy, int ifindex,	76	static int ieee80211_change_iface(struct wiphy *wiphy, int ifindex,
77	enum nl80211_iftype type, u32 *flags,	77	enum nl80211_iftype type, u32 *flags,
78	struct vif_params *params)	78	struct vif_params *params)
79	{	79	{
80	struct net_device *dev;	80	struct net_device *dev;
81	struct ieee80211_sub_if_data *sdata;	81	struct ieee80211_sub_if_data *sdata;
82	int ret;	82	int ret;
83		83
84	/* we're under RTNL */	84	/* we're under RTNL */
85	dev = __dev_get_by_index(&init_net, ifindex);	85	dev = __dev_get_by_index(&init_net, ifindex);
86	if (!dev)	86	if (!dev)
87	return -ENODEV;	87	return -ENODEV;
88		88
89	if (!nl80211_type_check(type))	89	if (!nl80211_type_check(type))
90	return -EINVAL;	90	return -EINVAL;
91		91
92	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	92	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
93		93
94	ret = ieee80211_if_change_type(sdata, type);	94	ret = ieee80211_if_change_type(sdata, type);
95	if (ret)	95	if (ret)
96	return ret;	96	return ret;
97		97
98	if (netif_running(sdata->dev))	98	if (netif_running(sdata->dev))
99	return -EBUSY;	99	return -EBUSY;
100		100
101	if (ieee80211_vif_is_mesh(&sdata->vif) && params->mesh_id_len)	101	if (ieee80211_vif_is_mesh(&sdata->vif) && params->mesh_id_len)
102	ieee80211_sdata_set_mesh_id(sdata,	102	ieee80211_sdata_set_mesh_id(sdata,
103	params->mesh_id_len,	103	params->mesh_id_len,
104	params->mesh_id);	104	params->mesh_id);
105		105
106	if (sdata->vif.type != NL80211_IFTYPE_MONITOR \|\| !flags)	106	if (sdata->vif.type != NL80211_IFTYPE_MONITOR \|\| !flags)
107	return 0;	107	return 0;
108		108
109	sdata->u.mntr_flags = *flags;	109	sdata->u.mntr_flags = *flags;
110	return 0;	110	return 0;
111	}	111	}
112		112
113	static int ieee80211_add_key(struct wiphy wiphy, struct net_device dev,	113	static int ieee80211_add_key(struct wiphy wiphy, struct net_device dev,
114	u8 key_idx, u8 *mac_addr,	114	u8 key_idx, u8 *mac_addr,
115	struct key_params *params)	115	struct key_params *params)
116	{	116	{
117	struct ieee80211_sub_if_data *sdata;	117	struct ieee80211_sub_if_data *sdata;
118	struct sta_info *sta = NULL;	118	struct sta_info *sta = NULL;
119	enum ieee80211_key_alg alg;	119	enum ieee80211_key_alg alg;
120	struct ieee80211_key *key;	120	struct ieee80211_key *key;
121	int err;	121	int err;
122		122
123	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	123	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
124		124
125	switch (params->cipher) {	125	switch (params->cipher) {
126	case WLAN_CIPHER_SUITE_WEP40:	126	case WLAN_CIPHER_SUITE_WEP40:
127	case WLAN_CIPHER_SUITE_WEP104:	127	case WLAN_CIPHER_SUITE_WEP104:
128	alg = ALG_WEP;	128	alg = ALG_WEP;
129	break;	129	break;
130	case WLAN_CIPHER_SUITE_TKIP:	130	case WLAN_CIPHER_SUITE_TKIP:
131	alg = ALG_TKIP;	131	alg = ALG_TKIP;
132	break;	132	break;
133	case WLAN_CIPHER_SUITE_CCMP:	133	case WLAN_CIPHER_SUITE_CCMP:
134	alg = ALG_CCMP;	134	alg = ALG_CCMP;
135	break;	135	break;
136	default:	136	default:
137	return -EINVAL;	137	return -EINVAL;
138	}	138	}
139		139
140	key = ieee80211_key_alloc(alg, key_idx, params->key_len, params->key);	140	key = ieee80211_key_alloc(alg, key_idx, params->key_len, params->key);
141	if (!key)	141	if (!key)
142	return -ENOMEM;	142	return -ENOMEM;
143		143
144	rcu_read_lock();	144	rcu_read_lock();
145		145
146	if (mac_addr) {	146	if (mac_addr) {
147	sta = sta_info_get(sdata->local, mac_addr);	147	sta = sta_info_get(sdata->local, mac_addr);
148	if (!sta) {	148	if (!sta) {
149	ieee80211_key_free(key);	149	ieee80211_key_free(key);
150	err = -ENOENT;	150	err = -ENOENT;
151	goto out_unlock;	151	goto out_unlock;
152	}	152	}
153	}	153	}
154		154
155	ieee80211_key_link(key, sdata, sta);	155	ieee80211_key_link(key, sdata, sta);
156		156
157	err = 0;	157	err = 0;
158	out_unlock:	158	out_unlock:
159	rcu_read_unlock();	159	rcu_read_unlock();
160		160
161	return err;	161	return err;
162	}	162	}
163		163
164	static int ieee80211_del_key(struct wiphy wiphy, struct net_device dev,	164	static int ieee80211_del_key(struct wiphy wiphy, struct net_device dev,
165	u8 key_idx, u8 *mac_addr)	165	u8 key_idx, u8 *mac_addr)
166	{	166	{
167	struct ieee80211_sub_if_data *sdata;	167	struct ieee80211_sub_if_data *sdata;
168	struct sta_info *sta;	168	struct sta_info *sta;
169	int ret;	169	int ret;
170		170
171	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	171	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
172		172
173	rcu_read_lock();	173	rcu_read_lock();
174		174
175	if (mac_addr) {	175	if (mac_addr) {
176	ret = -ENOENT;	176	ret = -ENOENT;
177		177
178	sta = sta_info_get(sdata->local, mac_addr);	178	sta = sta_info_get(sdata->local, mac_addr);
179	if (!sta)	179	if (!sta)
180	goto out_unlock;	180	goto out_unlock;
181		181
182	if (sta->key) {	182	if (sta->key) {
183	ieee80211_key_free(sta->key);	183	ieee80211_key_free(sta->key);
184	WARN_ON(sta->key);	184	WARN_ON(sta->key);
185	ret = 0;	185	ret = 0;
186	}	186	}
187		187
188	goto out_unlock;	188	goto out_unlock;
189	}	189	}
190		190
191	if (!sdata->keys[key_idx]) {	191	if (!sdata->keys[key_idx]) {
192	ret = -ENOENT;	192	ret = -ENOENT;
193	goto out_unlock;	193	goto out_unlock;
194	}	194	}
195		195
196	ieee80211_key_free(sdata->keys[key_idx]);	196	ieee80211_key_free(sdata->keys[key_idx]);
197	WARN_ON(sdata->keys[key_idx]);	197	WARN_ON(sdata->keys[key_idx]);
198		198
199	ret = 0;	199	ret = 0;
200	out_unlock:	200	out_unlock:
201	rcu_read_unlock();	201	rcu_read_unlock();
202		202
203	return ret;	203	return ret;
204	}	204	}
205		205
206	static int ieee80211_get_key(struct wiphy wiphy, struct net_device dev,	206	static int ieee80211_get_key(struct wiphy wiphy, struct net_device dev,
207	u8 key_idx, u8 mac_addr, void cookie,	207	u8 key_idx, u8 mac_addr, void cookie,
208	void (callback)(void cookie,	208	void (callback)(void cookie,
209	struct key_params *params))	209	struct key_params *params))
210	{	210	{
211	struct ieee80211_sub_if_data *sdata;	211	struct ieee80211_sub_if_data *sdata;
212	struct sta_info *sta = NULL;	212	struct sta_info *sta = NULL;
213	u8 seq[6] = {0};	213	u8 seq[6] = {0};
214	struct key_params params;	214	struct key_params params;
215	struct ieee80211_key *key;	215	struct ieee80211_key *key;
216	u32 iv32;	216	u32 iv32;
217	u16 iv16;	217	u16 iv16;
218	int err = -ENOENT;	218	int err = -ENOENT;
219		219
220	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	220	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
221		221
222	rcu_read_lock();	222	rcu_read_lock();
223		223
224	if (mac_addr) {	224	if (mac_addr) {
225	sta = sta_info_get(sdata->local, mac_addr);	225	sta = sta_info_get(sdata->local, mac_addr);
226	if (!sta)	226	if (!sta)
227	goto out;	227	goto out;
228		228
229	key = sta->key;	229	key = sta->key;
230	} else	230	} else
231	key = sdata->keys[key_idx];	231	key = sdata->keys[key_idx];
232		232
233	if (!key)	233	if (!key)
234	goto out;	234	goto out;
235		235
236	memset(&params, 0, sizeof(params));	236	memset(&params, 0, sizeof(params));
237		237
238	switch (key->conf.alg) {	238	switch (key->conf.alg) {
239	case ALG_TKIP:	239	case ALG_TKIP:
240	params.cipher = WLAN_CIPHER_SUITE_TKIP;	240	params.cipher = WLAN_CIPHER_SUITE_TKIP;
241		241
242	iv32 = key->u.tkip.tx.iv32;	242	iv32 = key->u.tkip.tx.iv32;
243	iv16 = key->u.tkip.tx.iv16;	243	iv16 = key->u.tkip.tx.iv16;
244		244
245	if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE &&	245	if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE &&
246	sdata->local->ops->get_tkip_seq)	246	sdata->local->ops->get_tkip_seq)
247	sdata->local->ops->get_tkip_seq(	247	sdata->local->ops->get_tkip_seq(
248	local_to_hw(sdata->local),	248	local_to_hw(sdata->local),
249	key->conf.hw_key_idx,	249	key->conf.hw_key_idx,
250	&iv32, &iv16);	250	&iv32, &iv16);
251		251
252	seq[0] = iv16 & 0xff;	252	seq[0] = iv16 & 0xff;
253	seq[1] = (iv16 >> 8) & 0xff;	253	seq[1] = (iv16 >> 8) & 0xff;
254	seq[2] = iv32 & 0xff;	254	seq[2] = iv32 & 0xff;
255	seq[3] = (iv32 >> 8) & 0xff;	255	seq[3] = (iv32 >> 8) & 0xff;
256	seq[4] = (iv32 >> 16) & 0xff;	256	seq[4] = (iv32 >> 16) & 0xff;
257	seq[5] = (iv32 >> 24) & 0xff;	257	seq[5] = (iv32 >> 24) & 0xff;
258	params.seq = seq;	258	params.seq = seq;
259	params.seq_len = 6;	259	params.seq_len = 6;
260	break;	260	break;
261	case ALG_CCMP:	261	case ALG_CCMP:
262	params.cipher = WLAN_CIPHER_SUITE_CCMP;	262	params.cipher = WLAN_CIPHER_SUITE_CCMP;
263	seq[0] = key->u.ccmp.tx_pn[5];	263	seq[0] = key->u.ccmp.tx_pn[5];
264	seq[1] = key->u.ccmp.tx_pn[4];	264	seq[1] = key->u.ccmp.tx_pn[4];
265	seq[2] = key->u.ccmp.tx_pn[3];	265	seq[2] = key->u.ccmp.tx_pn[3];
266	seq[3] = key->u.ccmp.tx_pn[2];	266	seq[3] = key->u.ccmp.tx_pn[2];
267	seq[4] = key->u.ccmp.tx_pn[1];	267	seq[4] = key->u.ccmp.tx_pn[1];
268	seq[5] = key->u.ccmp.tx_pn[0];	268	seq[5] = key->u.ccmp.tx_pn[0];
269	params.seq = seq;	269	params.seq = seq;
270	params.seq_len = 6;	270	params.seq_len = 6;
271	break;	271	break;
272	case ALG_WEP:	272	case ALG_WEP:
273	if (key->conf.keylen == 5)	273	if (key->conf.keylen == 5)
274	params.cipher = WLAN_CIPHER_SUITE_WEP40;	274	params.cipher = WLAN_CIPHER_SUITE_WEP40;
275	else	275	else
276	params.cipher = WLAN_CIPHER_SUITE_WEP104;	276	params.cipher = WLAN_CIPHER_SUITE_WEP104;
277	break;	277	break;
278	}	278	}
279		279
280	params.key = key->conf.key;	280	params.key = key->conf.key;
281	params.key_len = key->conf.keylen;	281	params.key_len = key->conf.keylen;
282		282
283	callback(cookie, &params);	283	callback(cookie, &params);
284	err = 0;	284	err = 0;
285		285
286	out:	286	out:
287	rcu_read_unlock();	287	rcu_read_unlock();
288	return err;	288	return err;
289	}	289	}
290		290
291	static int ieee80211_config_default_key(struct wiphy *wiphy,	291	static int ieee80211_config_default_key(struct wiphy *wiphy,
292	struct net_device *dev,	292	struct net_device *dev,
293	u8 key_idx)	293	u8 key_idx)
294	{	294	{
295	struct ieee80211_sub_if_data *sdata;	295	struct ieee80211_sub_if_data *sdata;
296		296
297	rcu_read_lock();	297	rcu_read_lock();
298		298
299	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	299	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
300	ieee80211_set_default_key(sdata, key_idx);	300	ieee80211_set_default_key(sdata, key_idx);
301		301
302	rcu_read_unlock();	302	rcu_read_unlock();
303		303
304	return 0;	304	return 0;
305	}	305	}
306		306
307	static void sta_set_sinfo(struct sta_info sta, struct station_info sinfo)	307	static void sta_set_sinfo(struct sta_info sta, struct station_info sinfo)
308	{	308	{
309	struct ieee80211_sub_if_data *sdata = sta->sdata;	309	struct ieee80211_sub_if_data *sdata = sta->sdata;
310		310
311	sinfo->filled = STATION_INFO_INACTIVE_TIME \|	311	sinfo->filled = STATION_INFO_INACTIVE_TIME \|
312	STATION_INFO_RX_BYTES \|	312	STATION_INFO_RX_BYTES \|
313	STATION_INFO_TX_BYTES \|	313	STATION_INFO_TX_BYTES \|
314	STATION_INFO_TX_BITRATE;	314	STATION_INFO_TX_BITRATE;
315		315
316	sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);	316	sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
317	sinfo->rx_bytes = sta->rx_bytes;	317	sinfo->rx_bytes = sta->rx_bytes;
318	sinfo->tx_bytes = sta->tx_bytes;	318	sinfo->tx_bytes = sta->tx_bytes;
319		319
320	if (sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) {	320	if (sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) {
321	sinfo->filled \|= STATION_INFO_SIGNAL;	321	sinfo->filled \|= STATION_INFO_SIGNAL;
322	sinfo->signal = (s8)sta->last_signal;	322	sinfo->signal = (s8)sta->last_signal;
323	}	323	}
324		324
325	sinfo->txrate.flags = 0;	325	sinfo->txrate.flags = 0;
326	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)	326	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)
327	sinfo->txrate.flags \|= RATE_INFO_FLAGS_MCS;	327	sinfo->txrate.flags \|= RATE_INFO_FLAGS_MCS;
328	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_40_MHZ_WIDTH)	328	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
329	sinfo->txrate.flags \|= RATE_INFO_FLAGS_40_MHZ_WIDTH;	329	sinfo->txrate.flags \|= RATE_INFO_FLAGS_40_MHZ_WIDTH;
330	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_SHORT_GI)	330	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_SHORT_GI)
331	sinfo->txrate.flags \|= RATE_INFO_FLAGS_SHORT_GI;	331	sinfo->txrate.flags \|= RATE_INFO_FLAGS_SHORT_GI;
332		332
333	if (!(sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)) {	333	if (!(sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)) {
334	struct ieee80211_supported_band *sband;	334	struct ieee80211_supported_band *sband;
335	sband = sta->local->hw.wiphy->bands[	335	sband = sta->local->hw.wiphy->bands[
336	sta->local->hw.conf.channel->band];	336	sta->local->hw.conf.channel->band];
337	sinfo->txrate.legacy =	337	sinfo->txrate.legacy =
338	sband->bitrates[sta->last_tx_rate.idx].bitrate;	338	sband->bitrates[sta->last_tx_rate.idx].bitrate;
339	} else	339	} else
340	sinfo->txrate.mcs = sta->last_tx_rate.idx;	340	sinfo->txrate.mcs = sta->last_tx_rate.idx;
341		341
342	if (ieee80211_vif_is_mesh(&sdata->vif)) {	342	if (ieee80211_vif_is_mesh(&sdata->vif)) {
343	#ifdef CONFIG_MAC80211_MESH	343	#ifdef CONFIG_MAC80211_MESH
344	sinfo->filled \|= STATION_INFO_LLID \|	344	sinfo->filled \|= STATION_INFO_LLID \|
345	STATION_INFO_PLID \|	345	STATION_INFO_PLID \|
346	STATION_INFO_PLINK_STATE;	346	STATION_INFO_PLINK_STATE;
347		347
348	sinfo->llid = le16_to_cpu(sta->llid);	348	sinfo->llid = le16_to_cpu(sta->llid);
349	sinfo->plid = le16_to_cpu(sta->plid);	349	sinfo->plid = le16_to_cpu(sta->plid);
350	sinfo->plink_state = sta->plink_state;	350	sinfo->plink_state = sta->plink_state;
351	#endif	351	#endif
352	}	352	}
353	}	353	}
354		354
355		355
356	static int ieee80211_dump_station(struct wiphy wiphy, struct net_device dev,	356	static int ieee80211_dump_station(struct wiphy wiphy, struct net_device dev,
357	int idx, u8 mac, struct station_info sinfo)	357	int idx, u8 mac, struct station_info sinfo)
358	{	358	{
359	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);	359	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
360	struct sta_info *sta;	360	struct sta_info *sta;
361	int ret = -ENOENT;	361	int ret = -ENOENT;
362		362
363	rcu_read_lock();	363	rcu_read_lock();
364		364
365	sta = sta_info_get_by_idx(local, idx, dev);	365	sta = sta_info_get_by_idx(local, idx, dev);
366	if (sta) {	366	if (sta) {
367	ret = 0;	367	ret = 0;
368	memcpy(mac, sta->sta.addr, ETH_ALEN);	368	memcpy(mac, sta->sta.addr, ETH_ALEN);
369	sta_set_sinfo(sta, sinfo);	369	sta_set_sinfo(sta, sinfo);
370	}	370	}
371		371
372	rcu_read_unlock();	372	rcu_read_unlock();
373		373
374	return ret;	374	return ret;
375	}	375	}
376		376
377	static int ieee80211_get_station(struct wiphy wiphy, struct net_device dev,	377	static int ieee80211_get_station(struct wiphy wiphy, struct net_device dev,
378	u8 mac, struct station_info sinfo)	378	u8 mac, struct station_info sinfo)
379	{	379	{
380	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);	380	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
381	struct sta_info *sta;	381	struct sta_info *sta;
382	int ret = -ENOENT;	382	int ret = -ENOENT;
383		383
384	rcu_read_lock();	384	rcu_read_lock();
385		385
386	/* XXX: verify sta->dev == dev */	386	/* XXX: verify sta->dev == dev */
387		387
388	sta = sta_info_get(local, mac);	388	sta = sta_info_get(local, mac);
389	if (sta) {	389	if (sta) {
390	ret = 0;	390	ret = 0;
391	sta_set_sinfo(sta, sinfo);	391	sta_set_sinfo(sta, sinfo);
392	}	392	}
393		393
394	rcu_read_unlock();	394	rcu_read_unlock();
395		395
396	return ret;	396	return ret;
397	}	397	}
398		398
399	/*	399	/*
400	* This handles both adding a beacon and setting new beacon info	400	* This handles both adding a beacon and setting new beacon info
401	*/	401	*/
402	static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata,	402	static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata,
403	struct beacon_parameters *params)	403	struct beacon_parameters *params)
404	{	404	{
405	struct beacon_data new, old;	405	struct beacon_data new, old;
406	int new_head_len, new_tail_len;	406	int new_head_len, new_tail_len;
407	int size;	407	int size;
408	int err = -EINVAL;	408	int err = -EINVAL;
409		409
410	old = sdata->u.ap.beacon;	410	old = sdata->u.ap.beacon;
411		411
412	/* head must not be zero-length */	412	/* head must not be zero-length */
413	if (params->head && !params->head_len)	413	if (params->head && !params->head_len)
414	return -EINVAL;	414	return -EINVAL;
415		415
416	/*	416	/*
417	* This is a kludge. beacon interval should really be part	417	* This is a kludge. beacon interval should really be part
418	* of the beacon information.	418	* of the beacon information.
419	*/	419	*/
420	if (params->interval) {	420	if (params->interval) {
421	sdata->local->hw.conf.beacon_int = params->interval;	421	sdata->local->hw.conf.beacon_int = params->interval;
422	err = ieee80211_hw_config(sdata->local,	422	err = ieee80211_hw_config(sdata->local,
423	IEEE80211_CONF_CHANGE_BEACON_INTERVAL);	423	IEEE80211_CONF_CHANGE_BEACON_INTERVAL);
424	if (err < 0)	424	if (err < 0)
425	return err;	425	return err;
426	/*	426	/*
427	* We updated some parameter so if below bails out	427	* We updated some parameter so if below bails out
428	* it's not an error.	428	* it's not an error.
429	*/	429	*/
430	err = 0;	430	err = 0;
431	}	431	}
432		432
433	/* Need to have a beacon head if we don't have one yet */	433	/* Need to have a beacon head if we don't have one yet */
434	if (!params->head && !old)	434	if (!params->head && !old)
435	return err;	435	return err;
436		436
437	/* sorry, no way to start beaconing without dtim period */	437	/* sorry, no way to start beaconing without dtim period */
438	if (!params->dtim_period && !old)	438	if (!params->dtim_period && !old)
439	return err;	439	return err;
440		440
441	/* new or old head? */	441	/* new or old head? */
442	if (params->head)	442	if (params->head)
443	new_head_len = params->head_len;	443	new_head_len = params->head_len;
444	else	444	else
445	new_head_len = old->head_len;	445	new_head_len = old->head_len;
446		446
447	/* new or old tail? */	447	/* new or old tail? */
448	if (params->tail \|\| !old)	448	if (params->tail \|\| !old)
449	/* params->tail_len will be zero for !params->tail */	449	/* params->tail_len will be zero for !params->tail */
450	new_tail_len = params->tail_len;	450	new_tail_len = params->tail_len;
451	else	451	else
452	new_tail_len = old->tail_len;	452	new_tail_len = old->tail_len;
453		453
454	size = sizeof(*new) + new_head_len + new_tail_len;	454	size = sizeof(*new) + new_head_len + new_tail_len;
455		455
456	new = kzalloc(size, GFP_KERNEL);	456	new = kzalloc(size, GFP_KERNEL);
457	if (!new)	457	if (!new)
458	return -ENOMEM;	458	return -ENOMEM;
459		459
460	/* start filling the new info now */	460	/* start filling the new info now */
461		461
462	/* new or old dtim period? */	462	/* new or old dtim period? */
463	if (params->dtim_period)	463	if (params->dtim_period)
464	new->dtim_period = params->dtim_period;	464	new->dtim_period = params->dtim_period;
465	else	465	else
466	new->dtim_period = old->dtim_period;	466	new->dtim_period = old->dtim_period;
467		467
468	/*	468	/*
469	* pointers go into the block we allocated,	469	* pointers go into the block we allocated,
470	* memory is \| beacon_data \| head \| tail \|	470	* memory is \| beacon_data \| head \| tail \|
471	*/	471	*/
472	new->head = ((u8 ) new) + sizeof(new);	472	new->head = ((u8 ) new) + sizeof(new);
473	new->tail = new->head + new_head_len;	473	new->tail = new->head + new_head_len;
474	new->head_len = new_head_len;	474	new->head_len = new_head_len;
475	new->tail_len = new_tail_len;	475	new->tail_len = new_tail_len;
476		476
477	/* copy in head */	477	/* copy in head */
478	if (params->head)	478	if (params->head)
479	memcpy(new->head, params->head, new_head_len);	479	memcpy(new->head, params->head, new_head_len);
480	else	480	else
481	memcpy(new->head, old->head, new_head_len);	481	memcpy(new->head, old->head, new_head_len);
482		482
483	/* copy in optional tail */	483	/* copy in optional tail */
484	if (params->tail)	484	if (params->tail)
485	memcpy(new->tail, params->tail, new_tail_len);	485	memcpy(new->tail, params->tail, new_tail_len);
486	else	486	else
487	if (old)	487	if (old)
488	memcpy(new->tail, old->tail, new_tail_len);	488	memcpy(new->tail, old->tail, new_tail_len);
489		489
490	rcu_assign_pointer(sdata->u.ap.beacon, new);	490	rcu_assign_pointer(sdata->u.ap.beacon, new);
491		491
492	synchronize_rcu();	492	synchronize_rcu();
493		493
494	kfree(old);	494	kfree(old);
495		495
496	return ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON);	496	return ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON);
497	}	497	}
498		498
499	static int ieee80211_add_beacon(struct wiphy wiphy, struct net_device dev,	499	static int ieee80211_add_beacon(struct wiphy wiphy, struct net_device dev,
500	struct beacon_parameters *params)	500	struct beacon_parameters *params)
501	{	501	{
502	struct ieee80211_sub_if_data *sdata;	502	struct ieee80211_sub_if_data *sdata;
503	struct beacon_data *old;	503	struct beacon_data *old;
504		504
505	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	505	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
506		506
507	if (sdata->vif.type != NL80211_IFTYPE_AP)	507	if (sdata->vif.type != NL80211_IFTYPE_AP)
508	return -EINVAL;	508	return -EINVAL;
509		509
510	old = sdata->u.ap.beacon;	510	old = sdata->u.ap.beacon;
511		511
512	if (old)	512	if (old)
513	return -EALREADY;	513	return -EALREADY;
514		514
515	return ieee80211_config_beacon(sdata, params);	515	return ieee80211_config_beacon(sdata, params);
516	}	516	}
517		517
518	static int ieee80211_set_beacon(struct wiphy wiphy, struct net_device dev,	518	static int ieee80211_set_beacon(struct wiphy wiphy, struct net_device dev,
519	struct beacon_parameters *params)	519	struct beacon_parameters *params)
520	{	520	{
521	struct ieee80211_sub_if_data *sdata;	521	struct ieee80211_sub_if_data *sdata;
522	struct beacon_data *old;	522	struct beacon_data *old;
523		523
524	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	524	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
525		525
526	if (sdata->vif.type != NL80211_IFTYPE_AP)	526	if (sdata->vif.type != NL80211_IFTYPE_AP)
527	return -EINVAL;	527	return -EINVAL;
528		528
529	old = sdata->u.ap.beacon;	529	old = sdata->u.ap.beacon;
530		530
531	if (!old)	531	if (!old)
532	return -ENOENT;	532	return -ENOENT;
533		533
534	return ieee80211_config_beacon(sdata, params);	534	return ieee80211_config_beacon(sdata, params);
535	}	535	}
536		536
537	static int ieee80211_del_beacon(struct wiphy wiphy, struct net_device dev)	537	static int ieee80211_del_beacon(struct wiphy wiphy, struct net_device dev)
538	{	538	{
539	struct ieee80211_sub_if_data *sdata;	539	struct ieee80211_sub_if_data *sdata;
540	struct beacon_data *old;	540	struct beacon_data *old;
541		541
542	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	542	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
543		543
544	if (sdata->vif.type != NL80211_IFTYPE_AP)	544	if (sdata->vif.type != NL80211_IFTYPE_AP)
545	return -EINVAL;	545	return -EINVAL;
546		546
547	old = sdata->u.ap.beacon;	547	old = sdata->u.ap.beacon;
548		548
549	if (!old)	549	if (!old)
550	return -ENOENT;	550	return -ENOENT;
551		551
552	rcu_assign_pointer(sdata->u.ap.beacon, NULL);	552	rcu_assign_pointer(sdata->u.ap.beacon, NULL);
553	synchronize_rcu();	553	synchronize_rcu();
554	kfree(old);	554	kfree(old);
555		555
556	return ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON);	556	return ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON);
557	}	557	}
558		558
559	/* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */	559	/* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
560	struct iapp_layer2_update {	560	struct iapp_layer2_update {
561	u8 da[ETH_ALEN]; /* broadcast */	561	u8 da[ETH_ALEN]; /* broadcast */
562	u8 sa[ETH_ALEN]; /* STA addr */	562	u8 sa[ETH_ALEN]; /* STA addr */
563	__be16 len; /* 6 */	563	__be16 len; /* 6 */
564	u8 dsap; /* 0 */	564	u8 dsap; /* 0 */
565	u8 ssap; /* 0 */	565	u8 ssap; /* 0 */
566	u8 control;	566	u8 control;
567	u8 xid_info[3];	567	u8 xid_info[3];
568	} __attribute__ ((packed));	568	} __attribute__ ((packed));
569		569
570	static void ieee80211_send_layer2_update(struct sta_info *sta)	570	static void ieee80211_send_layer2_update(struct sta_info *sta)
571	{	571	{
572	struct iapp_layer2_update *msg;	572	struct iapp_layer2_update *msg;
573	struct sk_buff *skb;	573	struct sk_buff *skb;
574		574
575	/* Send Level 2 Update Frame to update forwarding tables in layer 2	575	/* Send Level 2 Update Frame to update forwarding tables in layer 2
576	* bridge devices */	576	* bridge devices */
577		577
578	skb = dev_alloc_skb(sizeof(*msg));	578	skb = dev_alloc_skb(sizeof(*msg));
579	if (!skb)	579	if (!skb)
580	return;	580	return;
581	msg = (struct iapp_layer2_update )skb_put(skb, sizeof(msg));	581	msg = (struct iapp_layer2_update )skb_put(skb, sizeof(msg));
582		582
583	/* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID)	583	/* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID)
584	* Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */	584	* Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */
585		585
586	memset(msg->da, 0xff, ETH_ALEN);	586	memset(msg->da, 0xff, ETH_ALEN);
587	memcpy(msg->sa, sta->sta.addr, ETH_ALEN);	587	memcpy(msg->sa, sta->sta.addr, ETH_ALEN);
588	msg->len = htons(6);	588	msg->len = htons(6);
589	msg->dsap = 0;	589	msg->dsap = 0;
590	msg->ssap = 0x01; /* NULL LSAP, CR Bit: Response */	590	msg->ssap = 0x01; /* NULL LSAP, CR Bit: Response */
591	msg->control = 0xaf; /* XID response lsb.1111F101.	591	msg->control = 0xaf; /* XID response lsb.1111F101.
592	* F=0 (no poll command; unsolicited frame) */	592	* F=0 (no poll command; unsolicited frame) */
593	msg->xid_info[0] = 0x81; /* XID format identifier */	593	msg->xid_info[0] = 0x81; /* XID format identifier */
594	msg->xid_info[1] = 1; /* LLC types/classes: Type 1 LLC */	594	msg->xid_info[1] = 1; /* LLC types/classes: Type 1 LLC */
595	msg->xid_info[2] = 0; /* XID sender's receive window size (RW) */	595	msg->xid_info[2] = 0; /* XID sender's receive window size (RW) */
596		596
597	skb->dev = sta->sdata->dev;	597	skb->dev = sta->sdata->dev;
598	skb->protocol = eth_type_trans(skb, sta->sdata->dev);	598	skb->protocol = eth_type_trans(skb, sta->sdata->dev);
599	memset(skb->cb, 0, sizeof(skb->cb));	599	memset(skb->cb, 0, sizeof(skb->cb));
600	netif_rx(skb);	600	netif_rx(skb);
601	}	601	}
602		602
603	static void sta_apply_parameters(struct ieee80211_local *local,	603	static void sta_apply_parameters(struct ieee80211_local *local,
604	struct sta_info *sta,	604	struct sta_info *sta,
605	struct station_parameters *params)	605	struct station_parameters *params)
606	{	606	{
607	u32 rates;	607	u32 rates;
608	int i, j;	608	int i, j;
609	struct ieee80211_supported_band *sband;	609	struct ieee80211_supported_band *sband;
610	struct ieee80211_sub_if_data *sdata = sta->sdata;	610	struct ieee80211_sub_if_data *sdata = sta->sdata;
611		611
612	sband = local->hw.wiphy->bands[local->oper_channel->band];	612	sband = local->hw.wiphy->bands[local->oper_channel->band];
613		613
614	/*	614	/*
615	* FIXME: updating the flags is racy when this function is	615	* FIXME: updating the flags is racy when this function is
616	* called from ieee80211_change_station(), this will	616	* called from ieee80211_change_station(), this will
617	* be resolved in a future patch.	617	* be resolved in a future patch.
618	*/	618	*/
619		619
620	if (params->station_flags & STATION_FLAG_CHANGED) {	620	if (params->station_flags & STATION_FLAG_CHANGED) {
621	spin_lock_bh(&sta->lock);	621	spin_lock_bh(&sta->lock);
622	sta->flags &= ~WLAN_STA_AUTHORIZED;	622	sta->flags &= ~WLAN_STA_AUTHORIZED;
623	if (params->station_flags & STATION_FLAG_AUTHORIZED)	623	if (params->station_flags & STATION_FLAG_AUTHORIZED)
624	sta->flags \|= WLAN_STA_AUTHORIZED;	624	sta->flags \|= WLAN_STA_AUTHORIZED;
625		625
626	sta->flags &= ~WLAN_STA_SHORT_PREAMBLE;	626	sta->flags &= ~WLAN_STA_SHORT_PREAMBLE;
627	if (params->station_flags & STATION_FLAG_SHORT_PREAMBLE)	627	if (params->station_flags & STATION_FLAG_SHORT_PREAMBLE)
628	sta->flags \|= WLAN_STA_SHORT_PREAMBLE;	628	sta->flags \|= WLAN_STA_SHORT_PREAMBLE;
629		629
630	sta->flags &= ~WLAN_STA_WME;	630	sta->flags &= ~WLAN_STA_WME;
631	if (params->station_flags & STATION_FLAG_WME)	631	if (params->station_flags & STATION_FLAG_WME)
632	sta->flags \|= WLAN_STA_WME;	632	sta->flags \|= WLAN_STA_WME;
633	spin_unlock_bh(&sta->lock);	633	spin_unlock_bh(&sta->lock);
634	}	634	}
635		635
636	/*	636	/*
637	* FIXME: updating the following information is racy when this	637	* FIXME: updating the following information is racy when this
638	* function is called from ieee80211_change_station().	638	* function is called from ieee80211_change_station().
639	* However, all this information should be static so	639	* However, all this information should be static so
640	* maybe we should just reject attemps to change it.	640	* maybe we should just reject attemps to change it.
641	*/	641	*/
642		642
643	if (params->aid) {	643	if (params->aid) {
644	sta->sta.aid = params->aid;	644	sta->sta.aid = params->aid;
645	if (sta->sta.aid > IEEE80211_MAX_AID)	645	if (sta->sta.aid > IEEE80211_MAX_AID)
646	sta->sta.aid = 0; /* XXX: should this be an error? */	646	sta->sta.aid = 0; /* XXX: should this be an error? */
647	}	647	}
648		648
649	if (params->listen_interval >= 0)	649	if (params->listen_interval >= 0)
650	sta->listen_interval = params->listen_interval;	650	sta->listen_interval = params->listen_interval;
651		651
652	if (params->supported_rates) {	652	if (params->supported_rates) {
653	rates = 0;	653	rates = 0;
654		654
655	for (i = 0; i < params->supported_rates_len; i++) {	655	for (i = 0; i < params->supported_rates_len; i++) {
656	int rate = (params->supported_rates[i] & 0x7f) * 5;	656	int rate = (params->supported_rates[i] & 0x7f) * 5;
657	for (j = 0; j < sband->n_bitrates; j++) {	657	for (j = 0; j < sband->n_bitrates; j++) {
658	if (sband->bitrates[j].bitrate == rate)	658	if (sband->bitrates[j].bitrate == rate)
659	rates \|= BIT(j);	659	rates \|= BIT(j);
660	}	660	}
661	}	661	}
662	sta->sta.supp_rates[local->oper_channel->band] = rates;	662	sta->sta.supp_rates[local->oper_channel->band] = rates;
663	}	663	}
664		664
665	if (params->ht_capa)	665	if (params->ht_capa)
666	ieee80211_ht_cap_ie_to_sta_ht_cap(sband,	666	ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
667	params->ht_capa,	667	params->ht_capa,
668	&sta->sta.ht_cap);	668	&sta->sta.ht_cap);
669		669
670	if (ieee80211_vif_is_mesh(&sdata->vif) && params->plink_action) {	670	if (ieee80211_vif_is_mesh(&sdata->vif) && params->plink_action) {
671	switch (params->plink_action) {	671	switch (params->plink_action) {
672	case PLINK_ACTION_OPEN:	672	case PLINK_ACTION_OPEN:
673	mesh_plink_open(sta);	673	mesh_plink_open(sta);
674	break;	674	break;
675	case PLINK_ACTION_BLOCK:	675	case PLINK_ACTION_BLOCK:
676	mesh_plink_block(sta);	676	mesh_plink_block(sta);
677	break;	677	break;
678	}	678	}
679	}	679	}
680	}	680	}
681		681
682	static int ieee80211_add_station(struct wiphy wiphy, struct net_device dev,	682	static int ieee80211_add_station(struct wiphy wiphy, struct net_device dev,
683	u8 mac, struct station_parameters params)	683	u8 mac, struct station_parameters params)
684	{	684	{
685	struct ieee80211_local *local = wiphy_priv(wiphy);	685	struct ieee80211_local *local = wiphy_priv(wiphy);
686	struct sta_info *sta;	686	struct sta_info *sta;
687	struct ieee80211_sub_if_data *sdata;	687	struct ieee80211_sub_if_data *sdata;
688	int err;	688	int err;
689		689
690	/* Prevent a race with changing the rate control algorithm */	690	/* Prevent a race with changing the rate control algorithm */
691	if (!netif_running(dev))	691	if (!netif_running(dev))
692	return -ENETDOWN;	692	return -ENETDOWN;
693		693
694	if (params->vlan) {	694	if (params->vlan) {
695	sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);	695	sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
696		696
697	if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&	697	if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
698	sdata->vif.type != NL80211_IFTYPE_AP)	698	sdata->vif.type != NL80211_IFTYPE_AP)
699	return -EINVAL;	699	return -EINVAL;
700	} else	700	} else
701	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	701	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
702		702
703	if (compare_ether_addr(mac, dev->dev_addr) == 0)	703	if (compare_ether_addr(mac, dev->dev_addr) == 0)
704	return -EINVAL;	704	return -EINVAL;
705		705
706	if (is_multicast_ether_addr(mac))	706	if (is_multicast_ether_addr(mac))
707	return -EINVAL;	707	return -EINVAL;
708		708
709	sta = sta_info_alloc(sdata, mac, GFP_KERNEL);	709	sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
710	if (!sta)	710	if (!sta)
711	return -ENOMEM;	711	return -ENOMEM;
712		712
713	sta->flags = WLAN_STA_AUTH \| WLAN_STA_ASSOC;	713	sta->flags = WLAN_STA_AUTH \| WLAN_STA_ASSOC;
714		714
715	sta_apply_parameters(local, sta, params);	715	sta_apply_parameters(local, sta, params);
716		716
717	rate_control_rate_init(sta);	717	rate_control_rate_init(sta);
718		718
719	rcu_read_lock();	719	rcu_read_lock();
720		720
721	err = sta_info_insert(sta);	721	err = sta_info_insert(sta);
722	if (err) {	722	if (err) {
723	/* STA has been freed */	723	/* STA has been freed */
724	rcu_read_unlock();	724	rcu_read_unlock();
725	return err;	725	return err;
726	}	726	}
727		727
728	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN \|\|	728	if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN \|\|
729	sdata->vif.type == NL80211_IFTYPE_AP)	729	sdata->vif.type == NL80211_IFTYPE_AP)
730	ieee80211_send_layer2_update(sta);	730	ieee80211_send_layer2_update(sta);
731		731
732	rcu_read_unlock();	732	rcu_read_unlock();
733		733
734	return 0;	734	return 0;
735	}	735	}
736		736
737	static int ieee80211_del_station(struct wiphy wiphy, struct net_device dev,	737	static int ieee80211_del_station(struct wiphy wiphy, struct net_device dev,
738	u8 *mac)	738	u8 *mac)
739	{	739	{
740	struct ieee80211_local *local = wiphy_priv(wiphy);	740	struct ieee80211_local *local = wiphy_priv(wiphy);
741	struct ieee80211_sub_if_data *sdata;	741	struct ieee80211_sub_if_data *sdata;
742	struct sta_info *sta;	742	struct sta_info *sta;
743		743
744	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	744	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
745		745
746	if (mac) {	746	if (mac) {
747	rcu_read_lock();	747	rcu_read_lock();
748		748
749	/* XXX: get sta belonging to dev */	749	/* XXX: get sta belonging to dev */
750	sta = sta_info_get(local, mac);	750	sta = sta_info_get(local, mac);
751	if (!sta) {	751	if (!sta) {
752	rcu_read_unlock();	752	rcu_read_unlock();
753	return -ENOENT;	753	return -ENOENT;
754	}	754	}
755		755
756	sta_info_unlink(&sta);	756	sta_info_unlink(&sta);
757	rcu_read_unlock();	757	rcu_read_unlock();
758		758
759	sta_info_destroy(sta);	759	sta_info_destroy(sta);
760	} else	760	} else
761	sta_info_flush(local, sdata);	761	sta_info_flush(local, sdata);
762		762
763	return 0;	763	return 0;
764	}	764	}
765		765
766	static int ieee80211_change_station(struct wiphy *wiphy,	766	static int ieee80211_change_station(struct wiphy *wiphy,
767	struct net_device *dev,	767	struct net_device *dev,
768	u8 *mac,	768	u8 *mac,
769	struct station_parameters *params)	769	struct station_parameters *params)
770	{	770	{
771	struct ieee80211_local *local = wiphy_priv(wiphy);	771	struct ieee80211_local *local = wiphy_priv(wiphy);
772	struct sta_info *sta;	772	struct sta_info *sta;
773	struct ieee80211_sub_if_data *vlansdata;	773	struct ieee80211_sub_if_data *vlansdata;
774		774
775	rcu_read_lock();	775	rcu_read_lock();
776		776
777	/* XXX: get sta belonging to dev */	777	/* XXX: get sta belonging to dev */
778	sta = sta_info_get(local, mac);	778	sta = sta_info_get(local, mac);
779	if (!sta) {	779	if (!sta) {
780	rcu_read_unlock();	780	rcu_read_unlock();
781	return -ENOENT;	781	return -ENOENT;
782	}	782	}
783		783
784	if (params->vlan && params->vlan != sta->sdata->dev) {	784	if (params->vlan && params->vlan != sta->sdata->dev) {
785	vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);	785	vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
786		786
787	if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN &&	787	if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
788	vlansdata->vif.type != NL80211_IFTYPE_AP) {	788	vlansdata->vif.type != NL80211_IFTYPE_AP) {
789	rcu_read_unlock();	789	rcu_read_unlock();
790	return -EINVAL;	790	return -EINVAL;
791	}	791	}
792		792
793	sta->sdata = vlansdata;	793	sta->sdata = vlansdata;
794	ieee80211_send_layer2_update(sta);	794	ieee80211_send_layer2_update(sta);
795	}	795	}
796		796
797	sta_apply_parameters(local, sta, params);	797	sta_apply_parameters(local, sta, params);
798		798
799	rcu_read_unlock();	799	rcu_read_unlock();
800		800
801	return 0;	801	return 0;
802	}	802	}
803		803
804	#ifdef CONFIG_MAC80211_MESH	804	#ifdef CONFIG_MAC80211_MESH
805	static int ieee80211_add_mpath(struct wiphy wiphy, struct net_device dev,	805	static int ieee80211_add_mpath(struct wiphy wiphy, struct net_device dev,
806	u8 dst, u8 next_hop)	806	u8 dst, u8 next_hop)
807	{	807	{
808	struct ieee80211_local *local = wiphy_priv(wiphy);	808	struct ieee80211_local *local = wiphy_priv(wiphy);
809	struct ieee80211_sub_if_data *sdata;	809	struct ieee80211_sub_if_data *sdata;
810	struct mesh_path *mpath;	810	struct mesh_path *mpath;
811	struct sta_info *sta;	811	struct sta_info *sta;
812	int err;	812	int err;
813		813
814	if (!netif_running(dev))	814	if (!netif_running(dev))
815	return -ENETDOWN;	815	return -ENETDOWN;
816		816
817	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	817	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
818		818
819	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)	819	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
820	return -ENOTSUPP;	820	return -ENOTSUPP;
821		821
822	rcu_read_lock();	822	rcu_read_lock();
823	sta = sta_info_get(local, next_hop);	823	sta = sta_info_get(local, next_hop);
824	if (!sta) {	824	if (!sta) {
825	rcu_read_unlock();	825	rcu_read_unlock();
826	return -ENOENT;	826	return -ENOENT;
827	}	827	}
828		828
829	err = mesh_path_add(dst, sdata);	829	err = mesh_path_add(dst, sdata);
830	if (err) {	830	if (err) {
831	rcu_read_unlock();	831	rcu_read_unlock();
832	return err;	832	return err;
833	}	833	}
834		834
835	mpath = mesh_path_lookup(dst, sdata);	835	mpath = mesh_path_lookup(dst, sdata);
836	if (!mpath) {	836	if (!mpath) {
837	rcu_read_unlock();	837	rcu_read_unlock();
838	return -ENXIO;	838	return -ENXIO;
839	}	839	}
840	mesh_path_fix_nexthop(mpath, sta);	840	mesh_path_fix_nexthop(mpath, sta);
841		841
842	rcu_read_unlock();	842	rcu_read_unlock();
843	return 0;	843	return 0;
844	}	844	}
845		845
846	static int ieee80211_del_mpath(struct wiphy wiphy, struct net_device dev,	846	static int ieee80211_del_mpath(struct wiphy wiphy, struct net_device dev,
847	u8 *dst)	847	u8 *dst)
848	{	848	{
849	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);	849	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
850		850
851	if (dst)	851	if (dst)
852	return mesh_path_del(dst, sdata);	852	return mesh_path_del(dst, sdata);
853		853
854	mesh_path_flush(sdata);	854	mesh_path_flush(sdata);
855	return 0;	855	return 0;
856	}	856	}
857		857
858	static int ieee80211_change_mpath(struct wiphy *wiphy,	858	static int ieee80211_change_mpath(struct wiphy *wiphy,
859	struct net_device *dev,	859	struct net_device *dev,
860	u8 dst, u8 next_hop)	860	u8 dst, u8 next_hop)
861	{	861	{
862	struct ieee80211_local *local = wiphy_priv(wiphy);	862	struct ieee80211_local *local = wiphy_priv(wiphy);
863	struct ieee80211_sub_if_data *sdata;	863	struct ieee80211_sub_if_data *sdata;
864	struct mesh_path *mpath;	864	struct mesh_path *mpath;
865	struct sta_info *sta;	865	struct sta_info *sta;
866		866
867	if (!netif_running(dev))	867	if (!netif_running(dev))
868	return -ENETDOWN;	868	return -ENETDOWN;
869		869
870	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	870	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
871		871
872	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)	872	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
873	return -ENOTSUPP;	873	return -ENOTSUPP;
874		874
875	rcu_read_lock();	875	rcu_read_lock();
876		876
877	sta = sta_info_get(local, next_hop);	877	sta = sta_info_get(local, next_hop);
878	if (!sta) {	878	if (!sta) {
879	rcu_read_unlock();	879	rcu_read_unlock();
880	return -ENOENT;	880	return -ENOENT;
881	}	881	}
882		882
883	mpath = mesh_path_lookup(dst, sdata);	883	mpath = mesh_path_lookup(dst, sdata);
884	if (!mpath) {	884	if (!mpath) {
885	rcu_read_unlock();	885	rcu_read_unlock();
886	return -ENOENT;	886	return -ENOENT;
887	}	887	}
888		888
889	mesh_path_fix_nexthop(mpath, sta);	889	mesh_path_fix_nexthop(mpath, sta);
890		890
891	rcu_read_unlock();	891	rcu_read_unlock();
892	return 0;	892	return 0;
893	}	893	}
894		894
895	static void mpath_set_pinfo(struct mesh_path mpath, u8 next_hop,	895	static void mpath_set_pinfo(struct mesh_path mpath, u8 next_hop,
896	struct mpath_info *pinfo)	896	struct mpath_info *pinfo)
897	{	897	{
898	if (mpath->next_hop)	898	if (mpath->next_hop)
899	memcpy(next_hop, mpath->next_hop->sta.addr, ETH_ALEN);	899	memcpy(next_hop, mpath->next_hop->sta.addr, ETH_ALEN);
900	else	900	else
901	memset(next_hop, 0, ETH_ALEN);	901	memset(next_hop, 0, ETH_ALEN);
902		902
903	pinfo->filled = MPATH_INFO_FRAME_QLEN \|	903	pinfo->filled = MPATH_INFO_FRAME_QLEN \|
904	MPATH_INFO_DSN \|	904	MPATH_INFO_DSN \|
905	MPATH_INFO_METRIC \|	905	MPATH_INFO_METRIC \|
906	MPATH_INFO_EXPTIME \|	906	MPATH_INFO_EXPTIME \|
907	MPATH_INFO_DISCOVERY_TIMEOUT \|	907	MPATH_INFO_DISCOVERY_TIMEOUT \|
908	MPATH_INFO_DISCOVERY_RETRIES \|	908	MPATH_INFO_DISCOVERY_RETRIES \|
909	MPATH_INFO_FLAGS;	909	MPATH_INFO_FLAGS;
910		910
911	pinfo->frame_qlen = mpath->frame_queue.qlen;	911	pinfo->frame_qlen = mpath->frame_queue.qlen;
912	pinfo->dsn = mpath->dsn;	912	pinfo->dsn = mpath->dsn;
913	pinfo->metric = mpath->metric;	913	pinfo->metric = mpath->metric;
914	if (time_before(jiffies, mpath->exp_time))	914	if (time_before(jiffies, mpath->exp_time))
915	pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies);	915	pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies);
916	pinfo->discovery_timeout =	916	pinfo->discovery_timeout =
917	jiffies_to_msecs(mpath->discovery_timeout);	917	jiffies_to_msecs(mpath->discovery_timeout);
918	pinfo->discovery_retries = mpath->discovery_retries;	918	pinfo->discovery_retries = mpath->discovery_retries;
919	pinfo->flags = 0;	919	pinfo->flags = 0;
920	if (mpath->flags & MESH_PATH_ACTIVE)	920	if (mpath->flags & MESH_PATH_ACTIVE)
921	pinfo->flags \|= NL80211_MPATH_FLAG_ACTIVE;	921	pinfo->flags \|= NL80211_MPATH_FLAG_ACTIVE;
922	if (mpath->flags & MESH_PATH_RESOLVING)	922	if (mpath->flags & MESH_PATH_RESOLVING)
923	pinfo->flags \|= NL80211_MPATH_FLAG_RESOLVING;	923	pinfo->flags \|= NL80211_MPATH_FLAG_RESOLVING;
924	if (mpath->flags & MESH_PATH_DSN_VALID)	924	if (mpath->flags & MESH_PATH_DSN_VALID)
925	pinfo->flags \|= NL80211_MPATH_FLAG_DSN_VALID;	925	pinfo->flags \|= NL80211_MPATH_FLAG_DSN_VALID;
926	if (mpath->flags & MESH_PATH_FIXED)	926	if (mpath->flags & MESH_PATH_FIXED)
927	pinfo->flags \|= NL80211_MPATH_FLAG_FIXED;	927	pinfo->flags \|= NL80211_MPATH_FLAG_FIXED;
928	if (mpath->flags & MESH_PATH_RESOLVING)	928	if (mpath->flags & MESH_PATH_RESOLVING)
929	pinfo->flags \|= NL80211_MPATH_FLAG_RESOLVING;	929	pinfo->flags \|= NL80211_MPATH_FLAG_RESOLVING;
930		930
931	pinfo->flags = mpath->flags;	931	pinfo->flags = mpath->flags;
932	}	932	}
933		933
934	static int ieee80211_get_mpath(struct wiphy wiphy, struct net_device dev,	934	static int ieee80211_get_mpath(struct wiphy wiphy, struct net_device dev,
935	u8 dst, u8 next_hop, struct mpath_info *pinfo)	935	u8 dst, u8 next_hop, struct mpath_info *pinfo)
936		936
937	{	937	{
938	struct ieee80211_sub_if_data *sdata;	938	struct ieee80211_sub_if_data *sdata;
939	struct mesh_path *mpath;	939	struct mesh_path *mpath;
940		940
941	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	941	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
942		942
943	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)	943	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
944	return -ENOTSUPP;	944	return -ENOTSUPP;
945		945
946	rcu_read_lock();	946	rcu_read_lock();
947	mpath = mesh_path_lookup(dst, sdata);	947	mpath = mesh_path_lookup(dst, sdata);
948	if (!mpath) {	948	if (!mpath) {
949	rcu_read_unlock();	949	rcu_read_unlock();
950	return -ENOENT;	950	return -ENOENT;
951	}	951	}
952	memcpy(dst, mpath->dst, ETH_ALEN);	952	memcpy(dst, mpath->dst, ETH_ALEN);
953	mpath_set_pinfo(mpath, next_hop, pinfo);	953	mpath_set_pinfo(mpath, next_hop, pinfo);
954	rcu_read_unlock();	954	rcu_read_unlock();
955	return 0;	955	return 0;
956	}	956	}
957		957
958	static int ieee80211_dump_mpath(struct wiphy wiphy, struct net_device dev,	958	static int ieee80211_dump_mpath(struct wiphy wiphy, struct net_device dev,
959	int idx, u8 dst, u8 next_hop,	959	int idx, u8 dst, u8 next_hop,
960	struct mpath_info *pinfo)	960	struct mpath_info *pinfo)
961	{	961	{
962	struct ieee80211_sub_if_data *sdata;	962	struct ieee80211_sub_if_data *sdata;
963	struct mesh_path *mpath;	963	struct mesh_path *mpath;
964		964
965	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	965	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
966		966
967	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)	967	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
968	return -ENOTSUPP;	968	return -ENOTSUPP;
969		969
970	rcu_read_lock();	970	rcu_read_lock();
971	mpath = mesh_path_lookup_by_idx(idx, sdata);	971	mpath = mesh_path_lookup_by_idx(idx, sdata);
972	if (!mpath) {	972	if (!mpath) {
973	rcu_read_unlock();	973	rcu_read_unlock();
974	return -ENOENT;	974	return -ENOENT;
975	}	975	}
976	memcpy(dst, mpath->dst, ETH_ALEN);	976	memcpy(dst, mpath->dst, ETH_ALEN);
977	mpath_set_pinfo(mpath, next_hop, pinfo);	977	mpath_set_pinfo(mpath, next_hop, pinfo);
978	rcu_read_unlock();	978	rcu_read_unlock();
979	return 0;	979	return 0;
980	}	980	}
981		981
982	static int ieee80211_get_mesh_params(struct wiphy *wiphy,	982	static int ieee80211_get_mesh_params(struct wiphy *wiphy,
983	struct net_device *dev,	983	struct net_device *dev,
984	struct mesh_config *conf)	984	struct mesh_config *conf)
985	{	985	{
986	struct ieee80211_sub_if_data *sdata;	986	struct ieee80211_sub_if_data *sdata;
987	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	987	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
988		988
989	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)	989	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
990	return -ENOTSUPP;	990	return -ENOTSUPP;
991	memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config));	991	memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config));
992	return 0;	992	return 0;
993	}	993	}
994		994
995	static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)	995	static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)
996	{	996	{
997	return (mask >> (parm-1)) & 0x1;	997	return (mask >> (parm-1)) & 0x1;
998	}	998	}
999		999
1000	static int ieee80211_set_mesh_params(struct wiphy *wiphy,	1000	static int ieee80211_set_mesh_params(struct wiphy *wiphy,
1001	struct net_device *dev,	1001	struct net_device *dev,
1002	const struct mesh_config *nconf, u32 mask)	1002	const struct mesh_config *nconf, u32 mask)
1003	{	1003	{
1004	struct mesh_config *conf;	1004	struct mesh_config *conf;
1005	struct ieee80211_sub_if_data *sdata;	1005	struct ieee80211_sub_if_data *sdata;
1006	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	1006	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1007		1007
1008	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)	1008	if (sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
1009	return -ENOTSUPP;	1009	return -ENOTSUPP;
1010		1010
1011	/* Set the config options which we are interested in setting */	1011	/* Set the config options which we are interested in setting */
1012	conf = &(sdata->u.mesh.mshcfg);	1012	conf = &(sdata->u.mesh.mshcfg);
1013	if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask))	1013	if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask))
1014	conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout;	1014	conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout;
1015	if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask))	1015	if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask))
1016	conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout;	1016	conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout;
1017	if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask))	1017	if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask))
1018	conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout;	1018	conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout;
1019	if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask))	1019	if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask))
1020	conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks;	1020	conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks;
1021	if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask))	1021	if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask))
1022	conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries;	1022	conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries;
1023	if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask))	1023	if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask))
1024	conf->dot11MeshTTL = nconf->dot11MeshTTL;	1024	conf->dot11MeshTTL = nconf->dot11MeshTTL;
1025	if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask))	1025	if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask))
1026	conf->auto_open_plinks = nconf->auto_open_plinks;	1026	conf->auto_open_plinks = nconf->auto_open_plinks;
1027	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask))	1027	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask))
1028	conf->dot11MeshHWMPmaxPREQretries =	1028	conf->dot11MeshHWMPmaxPREQretries =
1029	nconf->dot11MeshHWMPmaxPREQretries;	1029	nconf->dot11MeshHWMPmaxPREQretries;
1030	if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask))	1030	if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask))
1031	conf->path_refresh_time = nconf->path_refresh_time;	1031	conf->path_refresh_time = nconf->path_refresh_time;
1032	if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask))	1032	if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask))
1033	conf->min_discovery_timeout = nconf->min_discovery_timeout;	1033	conf->min_discovery_timeout = nconf->min_discovery_timeout;
1034	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask))	1034	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask))
1035	conf->dot11MeshHWMPactivePathTimeout =	1035	conf->dot11MeshHWMPactivePathTimeout =
1036	nconf->dot11MeshHWMPactivePathTimeout;	1036	nconf->dot11MeshHWMPactivePathTimeout;
1037	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask))	1037	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask))
1038	conf->dot11MeshHWMPpreqMinInterval =	1038	conf->dot11MeshHWMPpreqMinInterval =
1039	nconf->dot11MeshHWMPpreqMinInterval;	1039	nconf->dot11MeshHWMPpreqMinInterval;
1040	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,	1040	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
1041	mask))	1041	mask))
1042	conf->dot11MeshHWMPnetDiameterTraversalTime =	1042	conf->dot11MeshHWMPnetDiameterTraversalTime =
1043	nconf->dot11MeshHWMPnetDiameterTraversalTime;	1043	nconf->dot11MeshHWMPnetDiameterTraversalTime;
1044	return 0;	1044	return 0;
1045	}	1045	}
1046		1046
1047	#endif	1047	#endif
1048		1048
1049	static int ieee80211_change_bss(struct wiphy *wiphy,	1049	static int ieee80211_change_bss(struct wiphy *wiphy,
1050	struct net_device *dev,	1050	struct net_device *dev,
1051	struct bss_parameters *params)	1051	struct bss_parameters *params)
1052	{	1052	{
1053	struct ieee80211_sub_if_data *sdata;	1053	struct ieee80211_sub_if_data *sdata;
1054	u32 changed = 0;	1054	u32 changed = 0;
1055		1055
1056	sdata = IEEE80211_DEV_TO_SUB_IF(dev);	1056	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1057		1057
1058	if (sdata->vif.type != NL80211_IFTYPE_AP)	1058	if (sdata->vif.type != NL80211_IFTYPE_AP)
1059	return -EINVAL;	1059	return -EINVAL;
1060		1060
1061	if (params->use_cts_prot >= 0) {	1061	if (params->use_cts_prot >= 0) {
1062	sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;	1062	sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
1063	changed \|= BSS_CHANGED_ERP_CTS_PROT;	1063	changed \|= BSS_CHANGED_ERP_CTS_PROT;
1064	}	1064	}
1065	if (params->use_short_preamble >= 0) {	1065	if (params->use_short_preamble >= 0) {
1066	sdata->vif.bss_conf.use_short_preamble =	1066	sdata->vif.bss_conf.use_short_preamble =
1067	params->use_short_preamble;	1067	params->use_short_preamble;
1068	changed \|= BSS_CHANGED_ERP_PREAMBLE;	1068	changed \|= BSS_CHANGED_ERP_PREAMBLE;
1069	}	1069	}
1070	if (params->use_short_slot_time >= 0) {	1070	if (params->use_short_slot_time >= 0) {
1071	sdata->vif.bss_conf.use_short_slot =	1071	sdata->vif.bss_conf.use_short_slot =
1072	params->use_short_slot_time;	1072	params->use_short_slot_time;
1073	changed \|= BSS_CHANGED_ERP_SLOT;	1073	changed \|= BSS_CHANGED_ERP_SLOT;
1074	}	1074	}
1075		1075
1076	if (params->basic_rates) {	1076	if (params->basic_rates) {
1077	int i, j;	1077	int i, j;
1078	u32 rates = 0;	1078	u32 rates = 0;
1079	struct ieee80211_local *local = wiphy_priv(wiphy);	1079	struct ieee80211_local *local = wiphy_priv(wiphy);
1080	struct ieee80211_supported_band *sband =	1080	struct ieee80211_supported_band *sband =
1081	wiphy->bands[local->oper_channel->band];	1081	wiphy->bands[local->oper_channel->band];
1082		1082
1083	for (i = 0; i < params->basic_rates_len; i++) {	1083	for (i = 0; i < params->basic_rates_len; i++) {
1084	int rate = (params->basic_rates[i] & 0x7f) * 5;	1084	int rate = (params->basic_rates[i] & 0x7f) * 5;
1085	for (j = 0; j < sband->n_bitrates; j++) {	1085	for (j = 0; j < sband->n_bitrates; j++) {
1086	if (sband->bitrates[j].bitrate == rate)	1086	if (sband->bitrates[j].bitrate == rate)
1087	rates \|= BIT(j);	1087	rates \|= BIT(j);
1088	}	1088	}
1089	}	1089	}
1090	sdata->vif.bss_conf.basic_rates = rates;	1090	sdata->vif.bss_conf.basic_rates = rates;
1091	changed \|= BSS_CHANGED_BASIC_RATES;	1091	changed \|= BSS_CHANGED_BASIC_RATES;
1092	}	1092	}
1093		1093
1094	ieee80211_bss_info_change_notify(sdata, changed);	1094	ieee80211_bss_info_change_notify(sdata, changed);
1095		1095
1096	return 0;	1096	return 0;
1097	}	1097	}
1098		1098
1099	static int ieee80211_set_txq_params(struct wiphy *wiphy,	1099	static int ieee80211_set_txq_params(struct wiphy *wiphy,
1100	struct ieee80211_txq_params *params)	1100	struct ieee80211_txq_params *params)
1101	{	1101	{
1102	struct ieee80211_local *local = wiphy_priv(wiphy);	1102	struct ieee80211_local *local = wiphy_priv(wiphy);
1103	struct ieee80211_tx_queue_params p;	1103	struct ieee80211_tx_queue_params p;
1104		1104
1105	if (!local->ops->conf_tx)	1105	if (!local->ops->conf_tx)
1106	return -EOPNOTSUPP;	1106	return -EOPNOTSUPP;
1107		1107
1108	memset(&p, 0, sizeof(p));	1108	memset(&p, 0, sizeof(p));
1109	p.aifs = params->aifs;	1109	p.aifs = params->aifs;
1110	p.cw_max = params->cwmax;	1110	p.cw_max = params->cwmax;
1111	p.cw_min = params->cwmin;	1111	p.cw_min = params->cwmin;
1112	p.txop = params->txop;	1112	p.txop = params->txop;
1113	if (local->ops->conf_tx(local_to_hw(local), params->queue, &p)) {	1113	if (local->ops->conf_tx(local_to_hw(local), params->queue, &p)) {
1114	printk(KERN_DEBUG "%s: failed to set TX queue "	1114	printk(KERN_DEBUG "%s: failed to set TX queue "
1115	"parameters for queue %d\n", local->mdev->name,	1115	"parameters for queue %d\n", local->mdev->name,
1116	params->queue);	1116	params->queue);
1117	return -EINVAL;	1117	return -EINVAL;
1118	}	1118	}
1119		1119
1120	return 0;	1120	return 0;
1121	}	1121	}
1122		1122
1123	static int ieee80211_set_channel(struct wiphy *wiphy,	1123	static int ieee80211_set_channel(struct wiphy *wiphy,
1124	struct ieee80211_channel *chan,	1124	struct ieee80211_channel *chan,
1125	enum nl80211_sec_chan_offset sec_chan_offset)	1125	enum nl80211_channel_type channel_type)
1126	{	1126	{
1127	struct ieee80211_local *local = wiphy_priv(wiphy);	1127	struct ieee80211_local *local = wiphy_priv(wiphy);
1128		1128
1129	local->oper_channel = chan;	1129	local->oper_channel = chan;
1130	local->oper_sec_chan_offset = sec_chan_offset;	1130	local->oper_channel_type = channel_type;
1131		1131
1132	return ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);	1132	return ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
1133	}	1133	}
1134		1134
1135	struct cfg80211_ops mac80211_config_ops = {	1135	struct cfg80211_ops mac80211_config_ops = {
1136	.add_virtual_intf = ieee80211_add_iface,	1136	.add_virtual_intf = ieee80211_add_iface,
1137	.del_virtual_intf = ieee80211_del_iface,	1137	.del_virtual_intf = ieee80211_del_iface,
1138	.change_virtual_intf = ieee80211_change_iface,	1138	.change_virtual_intf = ieee80211_change_iface,
1139	.add_key = ieee80211_add_key,	1139	.add_key = ieee80211_add_key,
1140	.del_key = ieee80211_del_key,	1140	.del_key = ieee80211_del_key,
1141	.get_key = ieee80211_get_key,	1141	.get_key = ieee80211_get_key,
1142	.set_default_key = ieee80211_config_default_key,	1142	.set_default_key = ieee80211_config_default_key,
1143	.add_beacon = ieee80211_add_beacon,	1143	.add_beacon = ieee80211_add_beacon,
1144	.set_beacon = ieee80211_set_beacon,	1144	.set_beacon = ieee80211_set_beacon,
1145	.del_beacon = ieee80211_del_beacon,	1145	.del_beacon = ieee80211_del_beacon,
1146	.add_station = ieee80211_add_station,	1146	.add_station = ieee80211_add_station,
1147	.del_station = ieee80211_del_station,	1147	.del_station = ieee80211_del_station,
1148	.change_station = ieee80211_change_station,	1148	.change_station = ieee80211_change_station,
1149	.get_station = ieee80211_get_station,	1149	.get_station = ieee80211_get_station,
1150	.dump_station = ieee80211_dump_station,	1150	.dump_station = ieee80211_dump_station,
1151	#ifdef CONFIG_MAC80211_MESH	1151	#ifdef CONFIG_MAC80211_MESH
1152	.add_mpath = ieee80211_add_mpath,	1152	.add_mpath = ieee80211_add_mpath,
1153	.del_mpath = ieee80211_del_mpath,	1153	.del_mpath = ieee80211_del_mpath,
1154	.change_mpath = ieee80211_change_mpath,	1154	.change_mpath = ieee80211_change_mpath,
1155	.get_mpath = ieee80211_get_mpath,	1155	.get_mpath = ieee80211_get_mpath,
1156	.dump_mpath = ieee80211_dump_mpath,	1156	.dump_mpath = ieee80211_dump_mpath,
1157	.set_mesh_params = ieee80211_set_mesh_params,	1157	.set_mesh_params = ieee80211_set_mesh_params,
1158	.get_mesh_params = ieee80211_get_mesh_params,	1158	.get_mesh_params = ieee80211_get_mesh_params,
1159	#endif	1159	#endif
1160	.change_bss = ieee80211_change_bss,	1160	.change_bss = ieee80211_change_bss,
1161	.set_txq_params = ieee80211_set_txq_params,	1161	.set_txq_params = ieee80211_set_txq_params,
1162	.set_channel = ieee80211_set_channel,	1162	.set_channel = ieee80211_set_channel,
1163	};	1163	};
1164		1164

net/mac80211/ht.c

Diff comments View file @ 094d05d

net/mac80211/ieee80211_i.h

Diff comments View file @ 094d05d

1	/*	1	/*
2	* Copyright 2002-2005, Instant802 Networks, Inc.	2	* Copyright 2002-2005, Instant802 Networks, Inc.
3	* Copyright 2005, Devicescape Software, Inc.	3	* Copyright 2005, Devicescape Software, Inc.
4	* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>	4	* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
5	* Copyright 2007-2008 Johannes Berg <johannes@sipsolutions.net>	5	* Copyright 2007-2008 Johannes Berg <johannes@sipsolutions.net>
6	*	6	*
7	* This program is free software; you can redistribute it and/or modify	7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License version 2 as	8	* it under the terms of the GNU General Public License version 2 as
9	* published by the Free Software Foundation.	9	* published by the Free Software Foundation.
10	*/	10	*/
11		11
12	#ifndef IEEE80211_I_H	12	#ifndef IEEE80211_I_H
13	#define IEEE80211_I_H	13	#define IEEE80211_I_H
14		14
15	#include <linux/kernel.h>	15	#include <linux/kernel.h>
16	#include <linux/device.h>	16	#include <linux/device.h>
17	#include <linux/if_ether.h>	17	#include <linux/if_ether.h>
18	#include <linux/interrupt.h>	18	#include <linux/interrupt.h>
19	#include <linux/list.h>	19	#include <linux/list.h>
20	#include <linux/netdevice.h>	20	#include <linux/netdevice.h>
21	#include <linux/skbuff.h>	21	#include <linux/skbuff.h>
22	#include <linux/workqueue.h>	22	#include <linux/workqueue.h>
23	#include <linux/types.h>	23	#include <linux/types.h>
24	#include <linux/spinlock.h>	24	#include <linux/spinlock.h>
25	#include <linux/etherdevice.h>	25	#include <linux/etherdevice.h>
26	#include <net/cfg80211.h>	26	#include <net/cfg80211.h>
27	#include <net/wireless.h>	27	#include <net/wireless.h>
28	#include <net/iw_handler.h>	28	#include <net/iw_handler.h>
29	#include <net/mac80211.h>	29	#include <net/mac80211.h>
30	#include "key.h"	30	#include "key.h"
31	#include "sta_info.h"	31	#include "sta_info.h"
32		32
33	struct ieee80211_local;	33	struct ieee80211_local;
34		34
35	/* Maximum number of broadcast/multicast frames to buffer when some of the	35	/* Maximum number of broadcast/multicast frames to buffer when some of the
36	* associated stations are using power saving. */	36	* associated stations are using power saving. */
37	#define AP_MAX_BC_BUFFER 128	37	#define AP_MAX_BC_BUFFER 128
38		38
39	/* Maximum number of frames buffered to all STAs, including multicast frames.	39	/* Maximum number of frames buffered to all STAs, including multicast frames.
40	* Note: increasing this limit increases the potential memory requirement. Each	40	* Note: increasing this limit increases the potential memory requirement. Each
41	* frame can be up to about 2 kB long. */	41	* frame can be up to about 2 kB long. */
42	#define TOTAL_MAX_TX_BUFFER 512	42	#define TOTAL_MAX_TX_BUFFER 512
43		43
44	/* Required encryption head and tailroom */	44	/* Required encryption head and tailroom */
45	#define IEEE80211_ENCRYPT_HEADROOM 8	45	#define IEEE80211_ENCRYPT_HEADROOM 8
46	#define IEEE80211_ENCRYPT_TAILROOM 12	46	#define IEEE80211_ENCRYPT_TAILROOM 12
47		47
48	/* IEEE 802.11 (Ch. 9.5 Defragmentation) requires support for concurrent	48	/* IEEE 802.11 (Ch. 9.5 Defragmentation) requires support for concurrent
49	* reception of at least three fragmented frames. This limit can be increased	49	* reception of at least three fragmented frames. This limit can be increased
50	* by changing this define, at the cost of slower frame reassembly and	50	* by changing this define, at the cost of slower frame reassembly and
51	* increased memory use (about 2 kB of RAM per entry). */	51	* increased memory use (about 2 kB of RAM per entry). */
52	#define IEEE80211_FRAGMENT_MAX 4	52	#define IEEE80211_FRAGMENT_MAX 4
53		53
54	/*	54	/*
55	* Time after which we ignore scan results and no longer report/use	55	* Time after which we ignore scan results and no longer report/use
56	* them in any way.	56	* them in any way.
57	*/	57	*/
58	#define IEEE80211_SCAN_RESULT_EXPIRE (10 * HZ)	58	#define IEEE80211_SCAN_RESULT_EXPIRE (10 * HZ)
59		59
60	struct ieee80211_fragment_entry {	60	struct ieee80211_fragment_entry {
61	unsigned long first_frag_time;	61	unsigned long first_frag_time;
62	unsigned int seq;	62	unsigned int seq;
63	unsigned int rx_queue;	63	unsigned int rx_queue;
64	unsigned int last_frag;	64	unsigned int last_frag;
65	unsigned int extra_len;	65	unsigned int extra_len;
66	struct sk_buff_head skb_list;	66	struct sk_buff_head skb_list;
67	int ccmp; /* Whether fragments were encrypted with CCMP */	67	int ccmp; /* Whether fragments were encrypted with CCMP */
68	u8 last_pn[6]; /* PN of the last fragment if CCMP was used */	68	u8 last_pn[6]; /* PN of the last fragment if CCMP was used */
69	};	69	};
70		70
71		71
72	struct ieee80211_bss {	72	struct ieee80211_bss {
73	struct list_head list;	73	struct list_head list;
74	struct ieee80211_bss *hnext;	74	struct ieee80211_bss *hnext;
75	size_t ssid_len;	75	size_t ssid_len;
76		76
77	atomic_t users;	77	atomic_t users;
78		78
79	u8 bssid[ETH_ALEN];	79	u8 bssid[ETH_ALEN];
80	u8 ssid[IEEE80211_MAX_SSID_LEN];	80	u8 ssid[IEEE80211_MAX_SSID_LEN];
81	u8 dtim_period;	81	u8 dtim_period;
82	u16 capability; /* host byte order */	82	u16 capability; /* host byte order */
83	enum ieee80211_band band;	83	enum ieee80211_band band;
84	int freq;	84	int freq;
85	int signal, noise, qual;	85	int signal, noise, qual;
86	u8 ies; / all information elements from the last Beacon or Probe	86	u8 ies; / all information elements from the last Beacon or Probe
87	* Response frames; note Beacon frame is not allowed to	87	* Response frames; note Beacon frame is not allowed to
88	* override values from Probe Response */	88	* override values from Probe Response */
89	size_t ies_len;	89	size_t ies_len;
90	bool wmm_used;	90	bool wmm_used;
91	#ifdef CONFIG_MAC80211_MESH	91	#ifdef CONFIG_MAC80211_MESH
92	u8 *mesh_id;	92	u8 *mesh_id;
93	size_t mesh_id_len;	93	size_t mesh_id_len;
94	u8 *mesh_cfg;	94	u8 *mesh_cfg;
95	#endif	95	#endif
96	#define IEEE80211_MAX_SUPP_RATES 32	96	#define IEEE80211_MAX_SUPP_RATES 32
97	u8 supp_rates[IEEE80211_MAX_SUPP_RATES];	97	u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
98	size_t supp_rates_len;	98	size_t supp_rates_len;
99	u64 timestamp;	99	u64 timestamp;
100	int beacon_int;	100	int beacon_int;
101		101
102	unsigned long last_probe_resp;	102	unsigned long last_probe_resp;
103	unsigned long last_update;	103	unsigned long last_update;
104		104
105	/* during assocation, we save an ERP value from a probe response so	105	/* during assocation, we save an ERP value from a probe response so
106	* that we can feed ERP info to the driver when handling the	106	* that we can feed ERP info to the driver when handling the
107	* association completes. these fields probably won't be up-to-date	107	* association completes. these fields probably won't be up-to-date
108	* otherwise, you probably don't want to use them. */	108	* otherwise, you probably don't want to use them. */
109	int has_erp_value;	109	int has_erp_value;
110	u8 erp_value;	110	u8 erp_value;
111	};	111	};
112		112
113	static inline u8 bss_mesh_cfg(struct ieee80211_bss bss)	113	static inline u8 bss_mesh_cfg(struct ieee80211_bss bss)
114	{	114	{
115	#ifdef CONFIG_MAC80211_MESH	115	#ifdef CONFIG_MAC80211_MESH
116	return bss->mesh_cfg;	116	return bss->mesh_cfg;
117	#endif	117	#endif
118	return NULL;	118	return NULL;
119	}	119	}
120		120
121	static inline u8 bss_mesh_id(struct ieee80211_bss bss)	121	static inline u8 bss_mesh_id(struct ieee80211_bss bss)
122	{	122	{
123	#ifdef CONFIG_MAC80211_MESH	123	#ifdef CONFIG_MAC80211_MESH
124	return bss->mesh_id;	124	return bss->mesh_id;
125	#endif	125	#endif
126	return NULL;	126	return NULL;
127	}	127	}
128		128
129	static inline u8 bss_mesh_id_len(struct ieee80211_bss *bss)	129	static inline u8 bss_mesh_id_len(struct ieee80211_bss *bss)
130	{	130	{
131	#ifdef CONFIG_MAC80211_MESH	131	#ifdef CONFIG_MAC80211_MESH
132	return bss->mesh_id_len;	132	return bss->mesh_id_len;
133	#endif	133	#endif
134	return 0;	134	return 0;
135	}	135	}
136		136
137		137
138	typedef unsigned __bitwise__ ieee80211_tx_result;	138	typedef unsigned __bitwise__ ieee80211_tx_result;
139	#define TX_CONTINUE ((__force ieee80211_tx_result) 0u)	139	#define TX_CONTINUE ((__force ieee80211_tx_result) 0u)
140	#define TX_DROP ((__force ieee80211_tx_result) 1u)	140	#define TX_DROP ((__force ieee80211_tx_result) 1u)
141	#define TX_QUEUED ((__force ieee80211_tx_result) 2u)	141	#define TX_QUEUED ((__force ieee80211_tx_result) 2u)
142		142
143	#define IEEE80211_TX_FRAGMENTED BIT(0)	143	#define IEEE80211_TX_FRAGMENTED BIT(0)
144	#define IEEE80211_TX_UNICAST BIT(1)	144	#define IEEE80211_TX_UNICAST BIT(1)
145	#define IEEE80211_TX_PS_BUFFERED BIT(2)	145	#define IEEE80211_TX_PS_BUFFERED BIT(2)
146		146
147	struct ieee80211_tx_data {	147	struct ieee80211_tx_data {
148	struct sk_buff *skb;	148	struct sk_buff *skb;
149	struct net_device *dev;	149	struct net_device *dev;
150	struct ieee80211_local *local;	150	struct ieee80211_local *local;
151	struct ieee80211_sub_if_data *sdata;	151	struct ieee80211_sub_if_data *sdata;
152	struct sta_info *sta;	152	struct sta_info *sta;
153	struct ieee80211_key *key;	153	struct ieee80211_key *key;
154		154
155	struct ieee80211_channel *channel;	155	struct ieee80211_channel *channel;
156		156
157	/* Extra fragments (in addition to the first fragment	157	/* Extra fragments (in addition to the first fragment
158	* in skb) */	158	* in skb) */
159	struct sk_buff **extra_frag;	159	struct sk_buff **extra_frag;
160	int num_extra_frag;	160	int num_extra_frag;
161		161
162	u16 ethertype;	162	u16 ethertype;
163	unsigned int flags;	163	unsigned int flags;
164	};	164	};
165		165
166		166
167	typedef unsigned __bitwise__ ieee80211_rx_result;	167	typedef unsigned __bitwise__ ieee80211_rx_result;
168	#define RX_CONTINUE ((__force ieee80211_rx_result) 0u)	168	#define RX_CONTINUE ((__force ieee80211_rx_result) 0u)
169	#define RX_DROP_UNUSABLE ((__force ieee80211_rx_result) 1u)	169	#define RX_DROP_UNUSABLE ((__force ieee80211_rx_result) 1u)
170	#define RX_DROP_MONITOR ((__force ieee80211_rx_result) 2u)	170	#define RX_DROP_MONITOR ((__force ieee80211_rx_result) 2u)
171	#define RX_QUEUED ((__force ieee80211_rx_result) 3u)	171	#define RX_QUEUED ((__force ieee80211_rx_result) 3u)
172		172
173	#define IEEE80211_RX_IN_SCAN BIT(0)	173	#define IEEE80211_RX_IN_SCAN BIT(0)
174	/* frame is destined to interface currently processed (incl. multicast frames) */	174	/* frame is destined to interface currently processed (incl. multicast frames) */
175	#define IEEE80211_RX_RA_MATCH BIT(1)	175	#define IEEE80211_RX_RA_MATCH BIT(1)
176	#define IEEE80211_RX_AMSDU BIT(2)	176	#define IEEE80211_RX_AMSDU BIT(2)
177	#define IEEE80211_RX_CMNTR_REPORTED BIT(3)	177	#define IEEE80211_RX_CMNTR_REPORTED BIT(3)
178	#define IEEE80211_RX_FRAGMENTED BIT(4)	178	#define IEEE80211_RX_FRAGMENTED BIT(4)
179		179
180	struct ieee80211_rx_data {	180	struct ieee80211_rx_data {
181	struct sk_buff *skb;	181	struct sk_buff *skb;
182	struct net_device *dev;	182	struct net_device *dev;
183	struct ieee80211_local *local;	183	struct ieee80211_local *local;
184	struct ieee80211_sub_if_data *sdata;	184	struct ieee80211_sub_if_data *sdata;
185	struct sta_info *sta;	185	struct sta_info *sta;
186	struct ieee80211_key *key;	186	struct ieee80211_key *key;
187	struct ieee80211_rx_status *status;	187	struct ieee80211_rx_status *status;
188	struct ieee80211_rate *rate;	188	struct ieee80211_rate *rate;
189		189
190	unsigned int flags;	190	unsigned int flags;
191	int sent_ps_buffered;	191	int sent_ps_buffered;
192	int queue;	192	int queue;
193	u32 tkip_iv32;	193	u32 tkip_iv32;
194	u16 tkip_iv16;	194	u16 tkip_iv16;
195	};	195	};
196		196
197	struct ieee80211_tx_stored_packet {	197	struct ieee80211_tx_stored_packet {
198	struct sk_buff *skb;	198	struct sk_buff *skb;
199	struct sk_buff **extra_frag;	199	struct sk_buff **extra_frag;
200	int num_extra_frag;	200	int num_extra_frag;
201	};	201	};
202		202
203	struct beacon_data {	203	struct beacon_data {
204	u8 head, tail;	204	u8 head, tail;
205	int head_len, tail_len;	205	int head_len, tail_len;
206	int dtim_period;	206	int dtim_period;
207	};	207	};
208		208
209	struct ieee80211_if_ap {	209	struct ieee80211_if_ap {
210	struct beacon_data *beacon;	210	struct beacon_data *beacon;
211		211
212	struct list_head vlans;	212	struct list_head vlans;
213		213
214	/* yes, this looks ugly, but guarantees that we can later use	214	/* yes, this looks ugly, but guarantees that we can later use
215	* bitmap_empty :)	215	* bitmap_empty :)
216	* NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */	216	* NB: don't touch this bitmap, use sta_info_{set,clear}_tim_bit */
217	u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)];	217	u8 tim[sizeof(unsigned long) * BITS_TO_LONGS(IEEE80211_MAX_AID + 1)];
218	struct sk_buff_head ps_bc_buf;	218	struct sk_buff_head ps_bc_buf;
219	atomic_t num_sta_ps; /* number of stations in PS mode */	219	atomic_t num_sta_ps; /* number of stations in PS mode */
220	int dtim_count;	220	int dtim_count;
221	};	221	};
222		222
223	struct ieee80211_if_wds {	223	struct ieee80211_if_wds {
224	struct sta_info *sta;	224	struct sta_info *sta;
225	u8 remote_addr[ETH_ALEN];	225	u8 remote_addr[ETH_ALEN];
226	};	226	};
227		227
228	struct ieee80211_if_vlan {	228	struct ieee80211_if_vlan {
229	struct list_head list;	229	struct list_head list;
230	};	230	};
231		231
232	struct mesh_stats {	232	struct mesh_stats {
233	__u32 fwded_frames; /* Mesh forwarded frames */	233	__u32 fwded_frames; /* Mesh forwarded frames */
234	__u32 dropped_frames_ttl; /* Not transmitted since mesh_ttl == 0*/	234	__u32 dropped_frames_ttl; /* Not transmitted since mesh_ttl == 0*/
235	__u32 dropped_frames_no_route; /* Not transmitted, no route found */	235	__u32 dropped_frames_no_route; /* Not transmitted, no route found */
236	atomic_t estab_plinks;	236	atomic_t estab_plinks;
237	};	237	};
238		238
239	#define PREQ_Q_F_START 0x1	239	#define PREQ_Q_F_START 0x1
240	#define PREQ_Q_F_REFRESH 0x2	240	#define PREQ_Q_F_REFRESH 0x2
241	struct mesh_preq_queue {	241	struct mesh_preq_queue {
242	struct list_head list;	242	struct list_head list;
243	u8 dst[ETH_ALEN];	243	u8 dst[ETH_ALEN];
244	u8 flags;	244	u8 flags;
245	};	245	};
246		246
247	/* flags used in struct ieee80211_if_sta.flags */	247	/* flags used in struct ieee80211_if_sta.flags */
248	#define IEEE80211_STA_SSID_SET BIT(0)	248	#define IEEE80211_STA_SSID_SET BIT(0)
249	#define IEEE80211_STA_BSSID_SET BIT(1)	249	#define IEEE80211_STA_BSSID_SET BIT(1)
250	#define IEEE80211_STA_PREV_BSSID_SET BIT(2)	250	#define IEEE80211_STA_PREV_BSSID_SET BIT(2)
251	#define IEEE80211_STA_AUTHENTICATED BIT(3)	251	#define IEEE80211_STA_AUTHENTICATED BIT(3)
252	#define IEEE80211_STA_ASSOCIATED BIT(4)	252	#define IEEE80211_STA_ASSOCIATED BIT(4)
253	#define IEEE80211_STA_PROBEREQ_POLL BIT(5)	253	#define IEEE80211_STA_PROBEREQ_POLL BIT(5)
254	#define IEEE80211_STA_CREATE_IBSS BIT(6)	254	#define IEEE80211_STA_CREATE_IBSS BIT(6)
255	#define IEEE80211_STA_MIXED_CELL BIT(7)	255	#define IEEE80211_STA_MIXED_CELL BIT(7)
256	#define IEEE80211_STA_WMM_ENABLED BIT(8)	256	#define IEEE80211_STA_WMM_ENABLED BIT(8)
257	#define IEEE80211_STA_AUTO_SSID_SEL BIT(10)	257	#define IEEE80211_STA_AUTO_SSID_SEL BIT(10)
258	#define IEEE80211_STA_AUTO_BSSID_SEL BIT(11)	258	#define IEEE80211_STA_AUTO_BSSID_SEL BIT(11)
259	#define IEEE80211_STA_AUTO_CHANNEL_SEL BIT(12)	259	#define IEEE80211_STA_AUTO_CHANNEL_SEL BIT(12)
260	#define IEEE80211_STA_PRIVACY_INVOKED BIT(13)	260	#define IEEE80211_STA_PRIVACY_INVOKED BIT(13)
261	/* flags for MLME request */	261	/* flags for MLME request */
262	#define IEEE80211_STA_REQ_SCAN 0	262	#define IEEE80211_STA_REQ_SCAN 0
263	#define IEEE80211_STA_REQ_DIRECT_PROBE 1	263	#define IEEE80211_STA_REQ_DIRECT_PROBE 1
264	#define IEEE80211_STA_REQ_AUTH 2	264	#define IEEE80211_STA_REQ_AUTH 2
265	#define IEEE80211_STA_REQ_RUN 3	265	#define IEEE80211_STA_REQ_RUN 3
266		266
267	/* STA/IBSS MLME states */	267	/* STA/IBSS MLME states */
268	enum ieee80211_sta_mlme_state {	268	enum ieee80211_sta_mlme_state {
269	IEEE80211_STA_MLME_DISABLED,	269	IEEE80211_STA_MLME_DISABLED,
270	IEEE80211_STA_MLME_DIRECT_PROBE,	270	IEEE80211_STA_MLME_DIRECT_PROBE,
271	IEEE80211_STA_MLME_AUTHENTICATE,	271	IEEE80211_STA_MLME_AUTHENTICATE,
272	IEEE80211_STA_MLME_ASSOCIATE,	272	IEEE80211_STA_MLME_ASSOCIATE,
273	IEEE80211_STA_MLME_ASSOCIATED,	273	IEEE80211_STA_MLME_ASSOCIATED,
274	IEEE80211_STA_MLME_IBSS_SEARCH,	274	IEEE80211_STA_MLME_IBSS_SEARCH,
275	IEEE80211_STA_MLME_IBSS_JOINED,	275	IEEE80211_STA_MLME_IBSS_JOINED,
276	};	276	};
277		277
278	/* bitfield of allowed auth algs */	278	/* bitfield of allowed auth algs */
279	#define IEEE80211_AUTH_ALG_OPEN BIT(0)	279	#define IEEE80211_AUTH_ALG_OPEN BIT(0)
280	#define IEEE80211_AUTH_ALG_SHARED_KEY BIT(1)	280	#define IEEE80211_AUTH_ALG_SHARED_KEY BIT(1)
281	#define IEEE80211_AUTH_ALG_LEAP BIT(2)	281	#define IEEE80211_AUTH_ALG_LEAP BIT(2)
282		282
283	struct ieee80211_if_sta {	283	struct ieee80211_if_sta {
284	struct timer_list timer;	284	struct timer_list timer;
285	struct work_struct work;	285	struct work_struct work;
286	u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];	286	u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];
287	u8 ssid[IEEE80211_MAX_SSID_LEN];	287	u8 ssid[IEEE80211_MAX_SSID_LEN];
288	enum ieee80211_sta_mlme_state state;	288	enum ieee80211_sta_mlme_state state;
289	size_t ssid_len;	289	size_t ssid_len;
290	u8 scan_ssid[IEEE80211_MAX_SSID_LEN];	290	u8 scan_ssid[IEEE80211_MAX_SSID_LEN];
291	size_t scan_ssid_len;	291	size_t scan_ssid_len;
292	u16 aid;	292	u16 aid;
293	u16 ap_capab, capab;	293	u16 ap_capab, capab;
294	u8 extra_ie; / to be added to the end of AssocReq */	294	u8 extra_ie; / to be added to the end of AssocReq */
295	size_t extra_ie_len;	295	size_t extra_ie_len;
296		296
297	/* The last AssocReq/Resp IEs */	297	/* The last AssocReq/Resp IEs */
298	u8 assocreq_ies, assocresp_ies;	298	u8 assocreq_ies, assocresp_ies;
299	size_t assocreq_ies_len, assocresp_ies_len;	299	size_t assocreq_ies_len, assocresp_ies_len;
300		300
301	struct sk_buff_head skb_queue;	301	struct sk_buff_head skb_queue;
302		302
303	int assoc_scan_tries; /* number of scans done pre-association */	303	int assoc_scan_tries; /* number of scans done pre-association */
304	int direct_probe_tries; /* retries for direct probes */	304	int direct_probe_tries; /* retries for direct probes */
305	int auth_tries; /* retries for auth req */	305	int auth_tries; /* retries for auth req */
306	int assoc_tries; /* retries for assoc req */	306	int assoc_tries; /* retries for assoc req */
307		307
308	unsigned long request;	308	unsigned long request;
309		309
310	unsigned long last_probe;	310	unsigned long last_probe;
311		311
312	unsigned int flags;	312	unsigned int flags;
313		313
314	unsigned int auth_algs; /* bitfield of allowed auth algs */	314	unsigned int auth_algs; /* bitfield of allowed auth algs */
315	int auth_alg; /* currently used IEEE 802.11 authentication algorithm */	315	int auth_alg; /* currently used IEEE 802.11 authentication algorithm */
316	int auth_transaction;	316	int auth_transaction;
317		317
318	unsigned long ibss_join_req;	318	unsigned long ibss_join_req;
319	struct sk_buff probe_resp; / ProbeResp template for IBSS */	319	struct sk_buff probe_resp; / ProbeResp template for IBSS */
320	u32 supp_rates_bits[IEEE80211_NUM_BANDS];	320	u32 supp_rates_bits[IEEE80211_NUM_BANDS];
321		321
322	int wmm_last_param_set;	322	int wmm_last_param_set;
323	};	323	};
324		324
325	struct ieee80211_if_mesh {	325	struct ieee80211_if_mesh {
326	struct work_struct work;	326	struct work_struct work;
327	struct timer_list housekeeping_timer;	327	struct timer_list housekeeping_timer;
328	struct timer_list mesh_path_timer;	328	struct timer_list mesh_path_timer;
329	struct sk_buff_head skb_queue;	329	struct sk_buff_head skb_queue;
330		330
331	bool housekeeping;	331	bool housekeeping;
332		332
333	u8 mesh_id[IEEE80211_MAX_MESH_ID_LEN];	333	u8 mesh_id[IEEE80211_MAX_MESH_ID_LEN];
334	size_t mesh_id_len;	334	size_t mesh_id_len;
335	/* Active Path Selection Protocol Identifier */	335	/* Active Path Selection Protocol Identifier */
336	u8 mesh_pp_id[4];	336	u8 mesh_pp_id[4];
337	/* Active Path Selection Metric Identifier */	337	/* Active Path Selection Metric Identifier */
338	u8 mesh_pm_id[4];	338	u8 mesh_pm_id[4];
339	/* Congestion Control Mode Identifier */	339	/* Congestion Control Mode Identifier */
340	u8 mesh_cc_id[4];	340	u8 mesh_cc_id[4];
341	/* Local mesh Destination Sequence Number */	341	/* Local mesh Destination Sequence Number */
342	u32 dsn;	342	u32 dsn;
343	/* Last used PREQ ID */	343	/* Last used PREQ ID */
344	u32 preq_id;	344	u32 preq_id;
345	atomic_t mpaths;	345	atomic_t mpaths;
346	/* Timestamp of last DSN update */	346	/* Timestamp of last DSN update */
347	unsigned long last_dsn_update;	347	unsigned long last_dsn_update;
348	/* Timestamp of last DSN sent */	348	/* Timestamp of last DSN sent */
349	unsigned long last_preq;	349	unsigned long last_preq;
350	struct mesh_rmc *rmc;	350	struct mesh_rmc *rmc;
351	spinlock_t mesh_preq_queue_lock;	351	spinlock_t mesh_preq_queue_lock;
352	struct mesh_preq_queue preq_queue;	352	struct mesh_preq_queue preq_queue;
353	int preq_queue_len;	353	int preq_queue_len;
354	struct mesh_stats mshstats;	354	struct mesh_stats mshstats;
355	struct mesh_config mshcfg;	355	struct mesh_config mshcfg;
356	u32 mesh_seqnum;	356	u32 mesh_seqnum;
357	bool accepting_plinks;	357	bool accepting_plinks;
358	};	358	};
359		359
360	#ifdef CONFIG_MAC80211_MESH	360	#ifdef CONFIG_MAC80211_MESH
361	#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \	361	#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
362	do { (msh)->mshstats.name++; } while (0)	362	do { (msh)->mshstats.name++; } while (0)
363	#else	363	#else
364	#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \	364	#define IEEE80211_IFSTA_MESH_CTR_INC(msh, name) \
365	do { } while (0)	365	do { } while (0)
366	#endif	366	#endif
367		367
368	/**	368	/**
369	* enum ieee80211_sub_if_data_flags - virtual interface flags	369	* enum ieee80211_sub_if_data_flags - virtual interface flags
370	*	370	*
371	* @IEEE80211_SDATA_ALLMULTI: interface wants all multicast packets	371	* @IEEE80211_SDATA_ALLMULTI: interface wants all multicast packets
372	* @IEEE80211_SDATA_PROMISC: interface is promisc	372	* @IEEE80211_SDATA_PROMISC: interface is promisc
373	* @IEEE80211_SDATA_USERSPACE_MLME: userspace MLME is active	373	* @IEEE80211_SDATA_USERSPACE_MLME: userspace MLME is active
374	* @IEEE80211_SDATA_OPERATING_GMODE: operating in G-only mode	374	* @IEEE80211_SDATA_OPERATING_GMODE: operating in G-only mode
375	* @IEEE80211_SDATA_DONT_BRIDGE_PACKETS: bridge packets between	375	* @IEEE80211_SDATA_DONT_BRIDGE_PACKETS: bridge packets between
376	* associated stations and deliver multicast frames both	376	* associated stations and deliver multicast frames both
377	* back to wireless media and to the local net stack.	377	* back to wireless media and to the local net stack.
378	*/	378	*/
379	enum ieee80211_sub_if_data_flags {	379	enum ieee80211_sub_if_data_flags {
380	IEEE80211_SDATA_ALLMULTI = BIT(0),	380	IEEE80211_SDATA_ALLMULTI = BIT(0),
381	IEEE80211_SDATA_PROMISC = BIT(1),	381	IEEE80211_SDATA_PROMISC = BIT(1),
382	IEEE80211_SDATA_USERSPACE_MLME = BIT(2),	382	IEEE80211_SDATA_USERSPACE_MLME = BIT(2),
383	IEEE80211_SDATA_OPERATING_GMODE = BIT(3),	383	IEEE80211_SDATA_OPERATING_GMODE = BIT(3),
384	IEEE80211_SDATA_DONT_BRIDGE_PACKETS = BIT(4),	384	IEEE80211_SDATA_DONT_BRIDGE_PACKETS = BIT(4),
385	};	385	};
386		386
387	struct ieee80211_sub_if_data {	387	struct ieee80211_sub_if_data {
388	struct list_head list;	388	struct list_head list;
389		389
390	struct wireless_dev wdev;	390	struct wireless_dev wdev;
391		391
392	/* keys */	392	/* keys */
393	struct list_head key_list;	393	struct list_head key_list;
394		394
395	struct net_device *dev;	395	struct net_device *dev;
396	struct ieee80211_local *local;	396	struct ieee80211_local *local;
397		397
398	unsigned int flags;	398	unsigned int flags;
399		399
400	int drop_unencrypted;	400	int drop_unencrypted;
401		401
402	/* Fragment table for host-based reassembly */	402	/* Fragment table for host-based reassembly */
403	struct ieee80211_fragment_entry fragments[IEEE80211_FRAGMENT_MAX];	403	struct ieee80211_fragment_entry fragments[IEEE80211_FRAGMENT_MAX];
404	unsigned int fragment_next;	404	unsigned int fragment_next;
405		405
406	#define NUM_DEFAULT_KEYS 4	406	#define NUM_DEFAULT_KEYS 4
407	struct ieee80211_key *keys[NUM_DEFAULT_KEYS];	407	struct ieee80211_key *keys[NUM_DEFAULT_KEYS];
408	struct ieee80211_key *default_key;	408	struct ieee80211_key *default_key;
409		409
410	u16 sequence_number;	410	u16 sequence_number;
411		411
412	/*	412	/*
413	* AP this belongs to: self in AP mode and	413	* AP this belongs to: self in AP mode and
414	* corresponding AP in VLAN mode, NULL for	414	* corresponding AP in VLAN mode, NULL for
415	* all others (might be needed later in IBSS)	415	* all others (might be needed later in IBSS)
416	*/	416	*/
417	struct ieee80211_if_ap *bss;	417	struct ieee80211_if_ap *bss;
418		418
419	int force_unicast_rateidx; /* forced TX rateidx for unicast frames */	419	int force_unicast_rateidx; /* forced TX rateidx for unicast frames */
420	int max_ratectrl_rateidx; /* max TX rateidx for rate control */	420	int max_ratectrl_rateidx; /* max TX rateidx for rate control */
421		421
422	union {	422	union {
423	struct ieee80211_if_ap ap;	423	struct ieee80211_if_ap ap;
424	struct ieee80211_if_wds wds;	424	struct ieee80211_if_wds wds;
425	struct ieee80211_if_vlan vlan;	425	struct ieee80211_if_vlan vlan;
426	struct ieee80211_if_sta sta;	426	struct ieee80211_if_sta sta;
427	#ifdef CONFIG_MAC80211_MESH	427	#ifdef CONFIG_MAC80211_MESH
428	struct ieee80211_if_mesh mesh;	428	struct ieee80211_if_mesh mesh;
429	#endif	429	#endif
430	u32 mntr_flags;	430	u32 mntr_flags;
431	} u;	431	} u;
432		432
433	#ifdef CONFIG_MAC80211_DEBUGFS	433	#ifdef CONFIG_MAC80211_DEBUGFS
434	struct dentry *debugfsdir;	434	struct dentry *debugfsdir;
435	union {	435	union {
436	struct {	436	struct {
437	struct dentry *drop_unencrypted;	437	struct dentry *drop_unencrypted;
438	struct dentry *state;	438	struct dentry *state;
439	struct dentry *bssid;	439	struct dentry *bssid;
440	struct dentry *prev_bssid;	440	struct dentry *prev_bssid;
441	struct dentry *ssid_len;	441	struct dentry *ssid_len;
442	struct dentry *aid;	442	struct dentry *aid;
443	struct dentry *ap_capab;	443	struct dentry *ap_capab;
444	struct dentry *capab;	444	struct dentry *capab;
445	struct dentry *extra_ie_len;	445	struct dentry *extra_ie_len;
446	struct dentry *auth_tries;	446	struct dentry *auth_tries;
447	struct dentry *assoc_tries;	447	struct dentry *assoc_tries;
448	struct dentry *auth_algs;	448	struct dentry *auth_algs;
449	struct dentry *auth_alg;	449	struct dentry *auth_alg;
450	struct dentry *auth_transaction;	450	struct dentry *auth_transaction;
451	struct dentry *flags;	451	struct dentry *flags;
452	struct dentry *force_unicast_rateidx;	452	struct dentry *force_unicast_rateidx;
453	struct dentry *max_ratectrl_rateidx;	453	struct dentry *max_ratectrl_rateidx;
454	} sta;	454	} sta;
455	struct {	455	struct {
456	struct dentry *drop_unencrypted;	456	struct dentry *drop_unencrypted;
457	struct dentry *num_sta_ps;	457	struct dentry *num_sta_ps;
458	struct dentry *dtim_count;	458	struct dentry *dtim_count;
459	struct dentry *force_unicast_rateidx;	459	struct dentry *force_unicast_rateidx;
460	struct dentry *max_ratectrl_rateidx;	460	struct dentry *max_ratectrl_rateidx;
461	struct dentry *num_buffered_multicast;	461	struct dentry *num_buffered_multicast;
462	} ap;	462	} ap;
463	struct {	463	struct {
464	struct dentry *drop_unencrypted;	464	struct dentry *drop_unencrypted;
465	struct dentry *peer;	465	struct dentry *peer;
466	struct dentry *force_unicast_rateidx;	466	struct dentry *force_unicast_rateidx;
467	struct dentry *max_ratectrl_rateidx;	467	struct dentry *max_ratectrl_rateidx;
468	} wds;	468	} wds;
469	struct {	469	struct {
470	struct dentry *drop_unencrypted;	470	struct dentry *drop_unencrypted;
471	struct dentry *force_unicast_rateidx;	471	struct dentry *force_unicast_rateidx;
472	struct dentry *max_ratectrl_rateidx;	472	struct dentry *max_ratectrl_rateidx;
473	} vlan;	473	} vlan;
474	struct {	474	struct {
475	struct dentry *mode;	475	struct dentry *mode;
476	} monitor;	476	} monitor;
477	} debugfs;	477	} debugfs;
478	struct {	478	struct {
479	struct dentry *default_key;	479	struct dentry *default_key;
480	} common_debugfs;	480	} common_debugfs;
481		481
482	#ifdef CONFIG_MAC80211_MESH	482	#ifdef CONFIG_MAC80211_MESH
483	struct dentry *mesh_stats_dir;	483	struct dentry *mesh_stats_dir;
484	struct {	484	struct {
485	struct dentry *fwded_frames;	485	struct dentry *fwded_frames;
486	struct dentry *dropped_frames_ttl;	486	struct dentry *dropped_frames_ttl;
487	struct dentry *dropped_frames_no_route;	487	struct dentry *dropped_frames_no_route;
488	struct dentry *estab_plinks;	488	struct dentry *estab_plinks;
489	struct timer_list mesh_path_timer;	489	struct timer_list mesh_path_timer;
490	} mesh_stats;	490	} mesh_stats;
491		491
492	struct dentry *mesh_config_dir;	492	struct dentry *mesh_config_dir;
493	struct {	493	struct {
494	struct dentry *dot11MeshRetryTimeout;	494	struct dentry *dot11MeshRetryTimeout;
495	struct dentry *dot11MeshConfirmTimeout;	495	struct dentry *dot11MeshConfirmTimeout;
496	struct dentry *dot11MeshHoldingTimeout;	496	struct dentry *dot11MeshHoldingTimeout;
497	struct dentry *dot11MeshMaxRetries;	497	struct dentry *dot11MeshMaxRetries;
498	struct dentry *dot11MeshTTL;	498	struct dentry *dot11MeshTTL;
499	struct dentry *auto_open_plinks;	499	struct dentry *auto_open_plinks;
500	struct dentry *dot11MeshMaxPeerLinks;	500	struct dentry *dot11MeshMaxPeerLinks;
501	struct dentry *dot11MeshHWMPactivePathTimeout;	501	struct dentry *dot11MeshHWMPactivePathTimeout;
502	struct dentry *dot11MeshHWMPpreqMinInterval;	502	struct dentry *dot11MeshHWMPpreqMinInterval;
503	struct dentry *dot11MeshHWMPnetDiameterTraversalTime;	503	struct dentry *dot11MeshHWMPnetDiameterTraversalTime;
504	struct dentry *dot11MeshHWMPmaxPREQretries;	504	struct dentry *dot11MeshHWMPmaxPREQretries;
505	struct dentry *path_refresh_time;	505	struct dentry *path_refresh_time;
506	struct dentry *min_discovery_timeout;	506	struct dentry *min_discovery_timeout;
507	} mesh_config;	507	} mesh_config;
508	#endif	508	#endif
509		509
510	#endif	510	#endif
511	/* must be last, dynamically sized area in this! */	511	/* must be last, dynamically sized area in this! */
512	struct ieee80211_vif vif;	512	struct ieee80211_vif vif;
513	};	513	};
514		514
515	static inline	515	static inline
516	struct ieee80211_sub_if_data vif_to_sdata(struct ieee80211_vif p)	516	struct ieee80211_sub_if_data vif_to_sdata(struct ieee80211_vif p)
517	{	517	{
518	return container_of(p, struct ieee80211_sub_if_data, vif);	518	return container_of(p, struct ieee80211_sub_if_data, vif);
519	}	519	}
520		520
521	static inline void	521	static inline void
522	ieee80211_sdata_set_mesh_id(struct ieee80211_sub_if_data *sdata,	522	ieee80211_sdata_set_mesh_id(struct ieee80211_sub_if_data *sdata,
523	u8 mesh_id_len, u8 *mesh_id)	523	u8 mesh_id_len, u8 *mesh_id)
524	{	524	{
525	#ifdef CONFIG_MAC80211_MESH	525	#ifdef CONFIG_MAC80211_MESH
526	struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;	526	struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
527	ifmsh->mesh_id_len = mesh_id_len;	527	ifmsh->mesh_id_len = mesh_id_len;
528	memcpy(ifmsh->mesh_id, mesh_id, mesh_id_len);	528	memcpy(ifmsh->mesh_id, mesh_id, mesh_id_len);
529	#else	529	#else
530	WARN_ON(1);	530	WARN_ON(1);
531	#endif	531	#endif
532	}	532	}
533		533
534	enum {	534	enum {
535	IEEE80211_RX_MSG = 1,	535	IEEE80211_RX_MSG = 1,
536	IEEE80211_TX_STATUS_MSG = 2,	536	IEEE80211_TX_STATUS_MSG = 2,
537	IEEE80211_DELBA_MSG = 3,	537	IEEE80211_DELBA_MSG = 3,
538	IEEE80211_ADDBA_MSG = 4,	538	IEEE80211_ADDBA_MSG = 4,
539	};	539	};
540		540
541	/* maximum number of hardware queues we support. */	541	/* maximum number of hardware queues we support. */
542	#define QD_MAX_QUEUES (IEEE80211_MAX_AMPDU_QUEUES + IEEE80211_MAX_QUEUES)	542	#define QD_MAX_QUEUES (IEEE80211_MAX_AMPDU_QUEUES + IEEE80211_MAX_QUEUES)
543		543
544	struct ieee80211_master_priv {	544	struct ieee80211_master_priv {
545	struct ieee80211_local *local;	545	struct ieee80211_local *local;
546	};	546	};
547		547
548	struct ieee80211_local {	548	struct ieee80211_local {
549	/* embed the driver visible part.	549	/* embed the driver visible part.
550	* don't cast (use the static inlines below), but we keep	550	* don't cast (use the static inlines below), but we keep
551	* it first anyway so they become a no-op */	551	* it first anyway so they become a no-op */
552	struct ieee80211_hw hw;	552	struct ieee80211_hw hw;
553		553
554	const struct ieee80211_ops *ops;	554	const struct ieee80211_ops *ops;
555		555
556	unsigned long queue_pool[BITS_TO_LONGS(QD_MAX_QUEUES)];	556	unsigned long queue_pool[BITS_TO_LONGS(QD_MAX_QUEUES)];
557		557
558	struct net_device mdev; / wmaster# - "master" 802.11 device */	558	struct net_device mdev; / wmaster# - "master" 802.11 device */
559	int open_count;	559	int open_count;
560	int monitors, cooked_mntrs;	560	int monitors, cooked_mntrs;
561	/* number of interfaces with corresponding FIF_ flags */	561	/* number of interfaces with corresponding FIF_ flags */
562	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss;	562	int fif_fcsfail, fif_plcpfail, fif_control, fif_other_bss;
563	unsigned int filter_flags; /* FIF_* */	563	unsigned int filter_flags; /* FIF_* */
564	struct iw_statistics wstats;	564	struct iw_statistics wstats;
565	u8 wstats_flags;	565	u8 wstats_flags;
566	bool tim_in_locked_section; /* see ieee80211_beacon_get() */	566	bool tim_in_locked_section; /* see ieee80211_beacon_get() */
567	int tx_headroom; /* required headroom for hardware/radiotap */	567	int tx_headroom; /* required headroom for hardware/radiotap */
568		568
569	/* Tasklet and skb queue to process calls from IRQ mode. All frames	569	/* Tasklet and skb queue to process calls from IRQ mode. All frames
570	* added to skb_queue will be processed, but frames in	570	* added to skb_queue will be processed, but frames in
571	* skb_queue_unreliable may be dropped if the total length of these	571	* skb_queue_unreliable may be dropped if the total length of these
572	* queues increases over the limit. */	572	* queues increases over the limit. */
573	#define IEEE80211_IRQSAFE_QUEUE_LIMIT 128	573	#define IEEE80211_IRQSAFE_QUEUE_LIMIT 128
574	struct tasklet_struct tasklet;	574	struct tasklet_struct tasklet;
575	struct sk_buff_head skb_queue;	575	struct sk_buff_head skb_queue;
576	struct sk_buff_head skb_queue_unreliable;	576	struct sk_buff_head skb_queue_unreliable;
577		577
578	/* Station data */	578	/* Station data */
579	/*	579	/*
580	* The lock only protects the list, hash, timer and counter	580	* The lock only protects the list, hash, timer and counter
581	* against manipulation, reads are done in RCU. Additionally,	581	* against manipulation, reads are done in RCU. Additionally,
582	* the lock protects each BSS's TIM bitmap.	582	* the lock protects each BSS's TIM bitmap.
583	*/	583	*/
584	spinlock_t sta_lock;	584	spinlock_t sta_lock;
585	unsigned long num_sta;	585	unsigned long num_sta;
586	struct list_head sta_list;	586	struct list_head sta_list;
587	struct list_head sta_flush_list;	587	struct list_head sta_flush_list;
588	struct work_struct sta_flush_work;	588	struct work_struct sta_flush_work;
589	struct sta_info *sta_hash[STA_HASH_SIZE];	589	struct sta_info *sta_hash[STA_HASH_SIZE];
590	struct timer_list sta_cleanup;	590	struct timer_list sta_cleanup;
591		591
592	unsigned long queues_pending[BITS_TO_LONGS(IEEE80211_MAX_QUEUES)];	592	unsigned long queues_pending[BITS_TO_LONGS(IEEE80211_MAX_QUEUES)];
593	unsigned long queues_pending_run[BITS_TO_LONGS(IEEE80211_MAX_QUEUES)];	593	unsigned long queues_pending_run[BITS_TO_LONGS(IEEE80211_MAX_QUEUES)];
594	struct ieee80211_tx_stored_packet pending_packet[IEEE80211_MAX_QUEUES];	594	struct ieee80211_tx_stored_packet pending_packet[IEEE80211_MAX_QUEUES];
595	struct tasklet_struct tx_pending_tasklet;	595	struct tasklet_struct tx_pending_tasklet;
596		596
597	/* number of interfaces with corresponding IFF_ flags */	597	/* number of interfaces with corresponding IFF_ flags */
598	atomic_t iff_allmultis, iff_promiscs;	598	atomic_t iff_allmultis, iff_promiscs;
599		599
600	struct rate_control_ref *rate_ctrl;	600	struct rate_control_ref *rate_ctrl;
601		601
602	int rts_threshold;	602	int rts_threshold;
603	int fragmentation_threshold;	603	int fragmentation_threshold;
604		604
605	struct crypto_blkcipher *wep_tx_tfm;	605	struct crypto_blkcipher *wep_tx_tfm;
606	struct crypto_blkcipher *wep_rx_tfm;	606	struct crypto_blkcipher *wep_rx_tfm;
607	u32 wep_iv;	607	u32 wep_iv;
608		608
609	struct list_head interfaces;	609	struct list_head interfaces;
610		610
611	/*	611	/*
612	* Key lock, protects sdata's key_list and sta_info's	612	* Key lock, protects sdata's key_list and sta_info's
613	* key pointers (write access, they're RCU.)	613	* key pointers (write access, they're RCU.)
614	*/	614	*/
615	spinlock_t key_lock;	615	spinlock_t key_lock;
616		616
617		617
618	/* Scanning and BSS list */	618	/* Scanning and BSS list */
619	bool sw_scanning, hw_scanning;	619	bool sw_scanning, hw_scanning;
620	int scan_channel_idx;	620	int scan_channel_idx;
621	enum ieee80211_band scan_band;	621	enum ieee80211_band scan_band;
622		622
623	enum { SCAN_SET_CHANNEL, SCAN_SEND_PROBE } scan_state;	623	enum { SCAN_SET_CHANNEL, SCAN_SEND_PROBE } scan_state;
624	unsigned long last_scan_completed;	624	unsigned long last_scan_completed;
625	struct delayed_work scan_work;	625	struct delayed_work scan_work;
626	struct ieee80211_sub_if_data *scan_sdata;	626	struct ieee80211_sub_if_data *scan_sdata;
627	struct ieee80211_channel oper_channel, scan_channel;	627	struct ieee80211_channel oper_channel, scan_channel;
628	enum nl80211_sec_chan_offset oper_sec_chan_offset;	628	enum nl80211_channel_type oper_channel_type;
629	u8 scan_ssid[IEEE80211_MAX_SSID_LEN];	629	u8 scan_ssid[IEEE80211_MAX_SSID_LEN];
630	size_t scan_ssid_len;	630	size_t scan_ssid_len;
631	struct list_head bss_list;	631	struct list_head bss_list;
632	struct ieee80211_bss *bss_hash[STA_HASH_SIZE];	632	struct ieee80211_bss *bss_hash[STA_HASH_SIZE];
633	spinlock_t bss_lock;	633	spinlock_t bss_lock;
634		634
635	/* SNMP counters */	635	/* SNMP counters */
636	/* dot11CountersTable */	636	/* dot11CountersTable */
637	u32 dot11TransmittedFragmentCount;	637	u32 dot11TransmittedFragmentCount;
638	u32 dot11MulticastTransmittedFrameCount;	638	u32 dot11MulticastTransmittedFrameCount;
639	u32 dot11FailedCount;	639	u32 dot11FailedCount;
640	u32 dot11RetryCount;	640	u32 dot11RetryCount;
641	u32 dot11MultipleRetryCount;	641	u32 dot11MultipleRetryCount;
642	u32 dot11FrameDuplicateCount;	642	u32 dot11FrameDuplicateCount;
643	u32 dot11ReceivedFragmentCount;	643	u32 dot11ReceivedFragmentCount;
644	u32 dot11MulticastReceivedFrameCount;	644	u32 dot11MulticastReceivedFrameCount;
645	u32 dot11TransmittedFrameCount;	645	u32 dot11TransmittedFrameCount;
646	u32 dot11WEPUndecryptableCount;	646	u32 dot11WEPUndecryptableCount;
647		647
648	#ifdef CONFIG_MAC80211_LEDS	648	#ifdef CONFIG_MAC80211_LEDS
649	int tx_led_counter, rx_led_counter;	649	int tx_led_counter, rx_led_counter;
650	struct led_trigger tx_led, rx_led, assoc_led, radio_led;	650	struct led_trigger tx_led, rx_led, assoc_led, radio_led;
651	char tx_led_name[32], rx_led_name[32],	651	char tx_led_name[32], rx_led_name[32],
652	assoc_led_name[32], radio_led_name[32];	652	assoc_led_name[32], radio_led_name[32];
653	#endif	653	#endif
654		654
655	#ifdef CONFIG_MAC80211_DEBUGFS	655	#ifdef CONFIG_MAC80211_DEBUGFS
656	struct work_struct sta_debugfs_add;	656	struct work_struct sta_debugfs_add;
657	#endif	657	#endif
658		658
659	#ifdef CONFIG_MAC80211_DEBUG_COUNTERS	659	#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
660	/* TX/RX handler statistics */	660	/* TX/RX handler statistics */
661	unsigned int tx_handlers_drop;	661	unsigned int tx_handlers_drop;
662	unsigned int tx_handlers_queued;	662	unsigned int tx_handlers_queued;
663	unsigned int tx_handlers_drop_unencrypted;	663	unsigned int tx_handlers_drop_unencrypted;
664	unsigned int tx_handlers_drop_fragment;	664	unsigned int tx_handlers_drop_fragment;
665	unsigned int tx_handlers_drop_wep;	665	unsigned int tx_handlers_drop_wep;
666	unsigned int tx_handlers_drop_not_assoc;	666	unsigned int tx_handlers_drop_not_assoc;
667	unsigned int tx_handlers_drop_unauth_port;	667	unsigned int tx_handlers_drop_unauth_port;
668	unsigned int rx_handlers_drop;	668	unsigned int rx_handlers_drop;
669	unsigned int rx_handlers_queued;	669	unsigned int rx_handlers_queued;
670	unsigned int rx_handlers_drop_nullfunc;	670	unsigned int rx_handlers_drop_nullfunc;
671	unsigned int rx_handlers_drop_defrag;	671	unsigned int rx_handlers_drop_defrag;
672	unsigned int rx_handlers_drop_short;	672	unsigned int rx_handlers_drop_short;
673	unsigned int rx_handlers_drop_passive_scan;	673	unsigned int rx_handlers_drop_passive_scan;
674	unsigned int tx_expand_skb_head;	674	unsigned int tx_expand_skb_head;
675	unsigned int tx_expand_skb_head_cloned;	675	unsigned int tx_expand_skb_head_cloned;
676	unsigned int rx_expand_skb_head;	676	unsigned int rx_expand_skb_head;
677	unsigned int rx_expand_skb_head2;	677	unsigned int rx_expand_skb_head2;
678	unsigned int rx_handlers_fragments;	678	unsigned int rx_handlers_fragments;
679	unsigned int tx_status_drop;	679	unsigned int tx_status_drop;
680	#define I802_DEBUG_INC(c) (c)++	680	#define I802_DEBUG_INC(c) (c)++
681	#else /* CONFIG_MAC80211_DEBUG_COUNTERS */	681	#else /* CONFIG_MAC80211_DEBUG_COUNTERS */
682	#define I802_DEBUG_INC(c) do { } while (0)	682	#define I802_DEBUG_INC(c) do { } while (0)
683	#endif /* CONFIG_MAC80211_DEBUG_COUNTERS */	683	#endif /* CONFIG_MAC80211_DEBUG_COUNTERS */
684		684
685		685
686	int total_ps_buffered; /* total number of all buffered unicast and	686	int total_ps_buffered; /* total number of all buffered unicast and
687	* multicast packets for power saving stations	687	* multicast packets for power saving stations
688	*/	688	*/
689	int wifi_wme_noack_test;	689	int wifi_wme_noack_test;
690	unsigned int wmm_acm; /* bit field of ACM bits (BIT(802.1D tag)) */	690	unsigned int wmm_acm; /* bit field of ACM bits (BIT(802.1D tag)) */
691		691
692	#ifdef CONFIG_MAC80211_DEBUGFS	692	#ifdef CONFIG_MAC80211_DEBUGFS
693	struct local_debugfsdentries {	693	struct local_debugfsdentries {
694	struct dentry *rcdir;	694	struct dentry *rcdir;
695	struct dentry *rcname;	695	struct dentry *rcname;
696	struct dentry *frequency;	696	struct dentry *frequency;
697	struct dentry *rts_threshold;	697	struct dentry *rts_threshold;
698	struct dentry *fragmentation_threshold;	698	struct dentry *fragmentation_threshold;
699	struct dentry *short_retry_limit;	699	struct dentry *short_retry_limit;
700	struct dentry *long_retry_limit;	700	struct dentry *long_retry_limit;
701	struct dentry *total_ps_buffered;	701	struct dentry *total_ps_buffered;
702	struct dentry *wep_iv;	702	struct dentry *wep_iv;
703	struct dentry *statistics;	703	struct dentry *statistics;
704	struct local_debugfsdentries_statsdentries {	704	struct local_debugfsdentries_statsdentries {
705	struct dentry *transmitted_fragment_count;	705	struct dentry *transmitted_fragment_count;
706	struct dentry *multicast_transmitted_frame_count;	706	struct dentry *multicast_transmitted_frame_count;
707	struct dentry *failed_count;	707	struct dentry *failed_count;
708	struct dentry *retry_count;	708	struct dentry *retry_count;
709	struct dentry *multiple_retry_count;	709	struct dentry *multiple_retry_count;
710	struct dentry *frame_duplicate_count;	710	struct dentry *frame_duplicate_count;
711	struct dentry *received_fragment_count;	711	struct dentry *received_fragment_count;
712	struct dentry *multicast_received_frame_count;	712	struct dentry *multicast_received_frame_count;
713	struct dentry *transmitted_frame_count;	713	struct dentry *transmitted_frame_count;
714	struct dentry *wep_undecryptable_count;	714	struct dentry *wep_undecryptable_count;
715	struct dentry *num_scans;	715	struct dentry *num_scans;
716	#ifdef CONFIG_MAC80211_DEBUG_COUNTERS	716	#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
717	struct dentry *tx_handlers_drop;	717	struct dentry *tx_handlers_drop;
718	struct dentry *tx_handlers_queued;	718	struct dentry *tx_handlers_queued;
719	struct dentry *tx_handlers_drop_unencrypted;	719	struct dentry *tx_handlers_drop_unencrypted;
720	struct dentry *tx_handlers_drop_fragment;	720	struct dentry *tx_handlers_drop_fragment;
721	struct dentry *tx_handlers_drop_wep;	721	struct dentry *tx_handlers_drop_wep;
722	struct dentry *tx_handlers_drop_not_assoc;	722	struct dentry *tx_handlers_drop_not_assoc;
723	struct dentry *tx_handlers_drop_unauth_port;	723	struct dentry *tx_handlers_drop_unauth_port;
724	struct dentry *rx_handlers_drop;	724	struct dentry *rx_handlers_drop;
725	struct dentry *rx_handlers_queued;	725	struct dentry *rx_handlers_queued;
726	struct dentry *rx_handlers_drop_nullfunc;	726	struct dentry *rx_handlers_drop_nullfunc;
727	struct dentry *rx_handlers_drop_defrag;	727	struct dentry *rx_handlers_drop_defrag;
728	struct dentry *rx_handlers_drop_short;	728	struct dentry *rx_handlers_drop_short;
729	struct dentry *rx_handlers_drop_passive_scan;	729	struct dentry *rx_handlers_drop_passive_scan;
730	struct dentry *tx_expand_skb_head;	730	struct dentry *tx_expand_skb_head;
731	struct dentry *tx_expand_skb_head_cloned;	731	struct dentry *tx_expand_skb_head_cloned;
732	struct dentry *rx_expand_skb_head;	732	struct dentry *rx_expand_skb_head;
733	struct dentry *rx_expand_skb_head2;	733	struct dentry *rx_expand_skb_head2;
734	struct dentry *rx_handlers_fragments;	734	struct dentry *rx_handlers_fragments;
735	struct dentry *tx_status_drop;	735	struct dentry *tx_status_drop;
736	#endif	736	#endif
737	struct dentry *dot11ACKFailureCount;	737	struct dentry *dot11ACKFailureCount;
738	struct dentry *dot11RTSFailureCount;	738	struct dentry *dot11RTSFailureCount;
739	struct dentry *dot11FCSErrorCount;	739	struct dentry *dot11FCSErrorCount;
740	struct dentry *dot11RTSSuccessCount;	740	struct dentry *dot11RTSSuccessCount;
741	} stats;	741	} stats;
742	struct dentry *stations;	742	struct dentry *stations;
743	struct dentry *keys;	743	struct dentry *keys;
744	} debugfs;	744	} debugfs;
745	#endif	745	#endif
746	};	746	};
747		747
748	static inline struct ieee80211_sub_if_data *	748	static inline struct ieee80211_sub_if_data *
749	IEEE80211_DEV_TO_SUB_IF(struct net_device *dev)	749	IEEE80211_DEV_TO_SUB_IF(struct net_device *dev)
750	{	750	{
751	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);	751	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
752		752
753	BUG_ON(!local \|\| local->mdev == dev);	753	BUG_ON(!local \|\| local->mdev == dev);
754		754
755	return netdev_priv(dev);	755	return netdev_priv(dev);
756	}	756	}
757		757
758	/* this struct represents 802.11n's RA/TID combination */	758	/* this struct represents 802.11n's RA/TID combination */
759	struct ieee80211_ra_tid {	759	struct ieee80211_ra_tid {
760	u8 ra[ETH_ALEN];	760	u8 ra[ETH_ALEN];
761	u16 tid;	761	u16 tid;
762	};	762	};
763		763
764	/* Parsed Information Elements */	764	/* Parsed Information Elements */
765	struct ieee802_11_elems {	765	struct ieee802_11_elems {
766	u8 *ie_start;	766	u8 *ie_start;
767	size_t total_len;	767	size_t total_len;
768		768
769	/* pointers to IEs */	769	/* pointers to IEs */
770	u8 *ssid;	770	u8 *ssid;
771	u8 *supp_rates;	771	u8 *supp_rates;
772	u8 *fh_params;	772	u8 *fh_params;
773	u8 *ds_params;	773	u8 *ds_params;
774	u8 *cf_params;	774	u8 *cf_params;
775	u8 *tim;	775	u8 *tim;
776	u8 *ibss_params;	776	u8 *ibss_params;
777	u8 *challenge;	777	u8 *challenge;
778	u8 *wpa;	778	u8 *wpa;
779	u8 *rsn;	779	u8 *rsn;
780	u8 *erp_info;	780	u8 *erp_info;
781	u8 *ext_supp_rates;	781	u8 *ext_supp_rates;
782	u8 *wmm_info;	782	u8 *wmm_info;
783	u8 *wmm_param;	783	u8 *wmm_param;
784	struct ieee80211_ht_cap *ht_cap_elem;	784	struct ieee80211_ht_cap *ht_cap_elem;
785	struct ieee80211_ht_info *ht_info_elem;	785	struct ieee80211_ht_info *ht_info_elem;
786	u8 *mesh_config;	786	u8 *mesh_config;
787	u8 *mesh_id;	787	u8 *mesh_id;
788	u8 *peer_link;	788	u8 *peer_link;
789	u8 *preq;	789	u8 *preq;
790	u8 *prep;	790	u8 *prep;
791	u8 *perr;	791	u8 *perr;
792	u8 *ch_switch_elem;	792	u8 *ch_switch_elem;
793	u8 *country_elem;	793	u8 *country_elem;
794	u8 *pwr_constr_elem;	794	u8 *pwr_constr_elem;
795	u8 quiet_elem; / first quite element */	795	u8 quiet_elem; / first quite element */
796		796
797	/* length of them, respectively */	797	/* length of them, respectively */
798	u8 ssid_len;	798	u8 ssid_len;
799	u8 supp_rates_len;	799	u8 supp_rates_len;
800	u8 fh_params_len;	800	u8 fh_params_len;
801	u8 ds_params_len;	801	u8 ds_params_len;
802	u8 cf_params_len;	802	u8 cf_params_len;
803	u8 tim_len;	803	u8 tim_len;
804	u8 ibss_params_len;	804	u8 ibss_params_len;
805	u8 challenge_len;	805	u8 challenge_len;
806	u8 wpa_len;	806	u8 wpa_len;
807	u8 rsn_len;	807	u8 rsn_len;
808	u8 erp_info_len;	808	u8 erp_info_len;
809	u8 ext_supp_rates_len;	809	u8 ext_supp_rates_len;
810	u8 wmm_info_len;	810	u8 wmm_info_len;
811	u8 wmm_param_len;	811	u8 wmm_param_len;
812	u8 mesh_config_len;	812	u8 mesh_config_len;
813	u8 mesh_id_len;	813	u8 mesh_id_len;
814	u8 peer_link_len;	814	u8 peer_link_len;
815	u8 preq_len;	815	u8 preq_len;
816	u8 prep_len;	816	u8 prep_len;
817	u8 perr_len;	817	u8 perr_len;
818	u8 ch_switch_elem_len;	818	u8 ch_switch_elem_len;
819	u8 country_elem_len;	819	u8 country_elem_len;
820	u8 pwr_constr_elem_len;	820	u8 pwr_constr_elem_len;
821	u8 quiet_elem_len;	821	u8 quiet_elem_len;
822	u8 num_of_quiet_elem; /* can be more the one */	822	u8 num_of_quiet_elem; /* can be more the one */
823	};	823	};
824		824
825	static inline struct ieee80211_local *hw_to_local(	825	static inline struct ieee80211_local *hw_to_local(
826	struct ieee80211_hw *hw)	826	struct ieee80211_hw *hw)
827	{	827	{
828	return container_of(hw, struct ieee80211_local, hw);	828	return container_of(hw, struct ieee80211_local, hw);
829	}	829	}
830		830
831	static inline struct ieee80211_hw *local_to_hw(	831	static inline struct ieee80211_hw *local_to_hw(
832	struct ieee80211_local *local)	832	struct ieee80211_local *local)
833	{	833	{
834	return &local->hw;	834	return &local->hw;
835	}	835	}
836		836
837		837
838	static inline int ieee80211_bssid_match(const u8 raddr, const u8 addr)	838	static inline int ieee80211_bssid_match(const u8 raddr, const u8 addr)
839	{	839	{
840	return compare_ether_addr(raddr, addr) == 0 \|\|	840	return compare_ether_addr(raddr, addr) == 0 \|\|
841	is_broadcast_ether_addr(raddr);	841	is_broadcast_ether_addr(raddr);
842	}	842	}
843		843
844		844
845	int ieee80211_hw_config(struct ieee80211_local *local, u32 changed);	845	int ieee80211_hw_config(struct ieee80211_local *local, u32 changed);
846	int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed);	846	int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed);
847	void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);	847	void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx);
848	void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,	848	void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
849	u32 changed);	849	u32 changed);
850	void ieee80211_configure_filter(struct ieee80211_local *local);	850	void ieee80211_configure_filter(struct ieee80211_local *local);
851		851
852	/* wireless extensions */	852	/* wireless extensions */
853	extern const struct iw_handler_def ieee80211_iw_handler_def;	853	extern const struct iw_handler_def ieee80211_iw_handler_def;
854		854
855	/* STA/IBSS code */	855	/* STA/IBSS code */
856	void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata);	856	void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata);
857	void ieee80211_scan_work(struct work_struct *work);	857	void ieee80211_scan_work(struct work_struct *work);
858	void ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data sdata, struct sk_buff skb,	858	void ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data sdata, struct sk_buff skb,
859	struct ieee80211_rx_status *rx_status);	859	struct ieee80211_rx_status *rx_status);
860	int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data sdata, char ssid, size_t len);	860	int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data sdata, char ssid, size_t len);
861	int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data sdata, char ssid, size_t *len);	861	int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data sdata, char ssid, size_t *len);
862	int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data sdata, u8 bssid);	862	int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data sdata, u8 bssid);
863	void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata,	863	void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata,
864	struct ieee80211_if_sta *ifsta);	864	struct ieee80211_if_sta *ifsta);
865	struct sta_info ieee80211_ibss_add_sta(struct ieee80211_sub_if_data sdata,	865	struct sta_info ieee80211_ibss_add_sta(struct ieee80211_sub_if_data sdata,
866	u8 bssid, u8 addr, u64 supp_rates);	866	u8 bssid, u8 addr, u64 supp_rates);
867	int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason);	867	int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason);
868	int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason);	868	int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason);
869	u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);	869	u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata);
870	u64 ieee80211_sta_get_rates(struct ieee80211_local *local,	870	u64 ieee80211_sta_get_rates(struct ieee80211_local *local,
871	struct ieee802_11_elems *elems,	871	struct ieee802_11_elems *elems,
872	enum ieee80211_band band);	872	enum ieee80211_band band);
873	void ieee80211_send_probe_req(struct ieee80211_sub_if_data sdata, u8 dst,	873	void ieee80211_send_probe_req(struct ieee80211_sub_if_data sdata, u8 dst,
874	u8 *ssid, size_t ssid_len);	874	u8 *ssid, size_t ssid_len);
875		875
876	/* scan/BSS handling */	876	/* scan/BSS handling */
877	int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,	877	int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
878	u8 *ssid, size_t ssid_len);	878	u8 *ssid, size_t ssid_len);
879	int ieee80211_scan_results(struct ieee80211_local *local,	879	int ieee80211_scan_results(struct ieee80211_local *local,
880	struct iw_request_info *info,	880	struct iw_request_info *info,
881	char *buf, size_t len);	881	char *buf, size_t len);
882	ieee80211_rx_result	882	ieee80211_rx_result
883	ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata,	883	ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata,
884	struct sk_buff *skb,	884	struct sk_buff *skb,
885	struct ieee80211_rx_status *rx_status);	885	struct ieee80211_rx_status *rx_status);
886	void ieee80211_rx_bss_list_init(struct ieee80211_local *local);	886	void ieee80211_rx_bss_list_init(struct ieee80211_local *local);
887	void ieee80211_rx_bss_list_deinit(struct ieee80211_local *local);	887	void ieee80211_rx_bss_list_deinit(struct ieee80211_local *local);
888	int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata,	888	int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata,
889	char *ie, size_t len);	889	char *ie, size_t len);
890		890
891	void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);	891	void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local);
892	int ieee80211_start_scan(struct ieee80211_sub_if_data *scan_sdata,	892	int ieee80211_start_scan(struct ieee80211_sub_if_data *scan_sdata,
893	u8 *ssid, size_t ssid_len);	893	u8 *ssid, size_t ssid_len);
894	struct ieee80211_bss *	894	struct ieee80211_bss *
895	ieee80211_bss_info_update(struct ieee80211_local *local,	895	ieee80211_bss_info_update(struct ieee80211_local *local,
896	struct ieee80211_rx_status *rx_status,	896	struct ieee80211_rx_status *rx_status,
897	struct ieee80211_mgmt *mgmt,	897	struct ieee80211_mgmt *mgmt,
898	size_t len,	898	size_t len,
899	struct ieee802_11_elems *elems,	899	struct ieee802_11_elems *elems,
900	int freq, bool beacon);	900	int freq, bool beacon);
901	struct ieee80211_bss *	901	struct ieee80211_bss *
902	ieee80211_rx_bss_add(struct ieee80211_local local, u8 bssid, int freq,	902	ieee80211_rx_bss_add(struct ieee80211_local local, u8 bssid, int freq,
903	u8 *ssid, u8 ssid_len);	903	u8 *ssid, u8 ssid_len);
904	struct ieee80211_bss *	904	struct ieee80211_bss *
905	ieee80211_rx_bss_get(struct ieee80211_local local, u8 bssid, int freq,	905	ieee80211_rx_bss_get(struct ieee80211_local local, u8 bssid, int freq,
906	u8 *ssid, u8 ssid_len);	906	u8 *ssid, u8 ssid_len);
907	void ieee80211_rx_bss_put(struct ieee80211_local *local,	907	void ieee80211_rx_bss_put(struct ieee80211_local *local,
908	struct ieee80211_bss *bss);	908	struct ieee80211_bss *bss);
909		909
910	/* interface handling */	910	/* interface handling */
911	int ieee80211_if_add(struct ieee80211_local local, const char name,	911	int ieee80211_if_add(struct ieee80211_local local, const char name,
912	struct net_device **new_dev, enum nl80211_iftype type,	912	struct net_device **new_dev, enum nl80211_iftype type,
913	struct vif_params *params);	913	struct vif_params *params);
914	int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,	914	int ieee80211_if_change_type(struct ieee80211_sub_if_data *sdata,
915	enum nl80211_iftype type);	915	enum nl80211_iftype type);
916	void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);	916	void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
917	void ieee80211_remove_interfaces(struct ieee80211_local *local);	917	void ieee80211_remove_interfaces(struct ieee80211_local *local);
918		918
919	/* tx handling */	919	/* tx handling */
920	void ieee80211_clear_tx_pending(struct ieee80211_local *local);	920	void ieee80211_clear_tx_pending(struct ieee80211_local *local);
921	void ieee80211_tx_pending(unsigned long data);	921	void ieee80211_tx_pending(unsigned long data);
922	int ieee80211_master_start_xmit(struct sk_buff skb, struct net_device dev);	922	int ieee80211_master_start_xmit(struct sk_buff skb, struct net_device dev);
923	int ieee80211_monitor_start_xmit(struct sk_buff skb, struct net_device dev);	923	int ieee80211_monitor_start_xmit(struct sk_buff skb, struct net_device dev);
924	int ieee80211_subif_start_xmit(struct sk_buff skb, struct net_device dev);	924	int ieee80211_subif_start_xmit(struct sk_buff skb, struct net_device dev);
925		925
926	/* HT */	926	/* HT */
927	void ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_supported_band *sband,	927	void ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_supported_band *sband,
928	struct ieee80211_ht_cap *ht_cap_ie,	928	struct ieee80211_ht_cap *ht_cap_ie,
929	struct ieee80211_sta_ht_cap *ht_cap);	929	struct ieee80211_sta_ht_cap *ht_cap);
930	u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,	930	u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
931	struct ieee80211_ht_info *hti,	931	struct ieee80211_ht_info *hti,
932	u16 ap_ht_cap_flags);	932	u16 ap_ht_cap_flags);
933	void ieee80211_send_bar(struct ieee80211_sub_if_data sdata, u8 ra, u16 tid, u16 ssn);	933	void ieee80211_send_bar(struct ieee80211_sub_if_data sdata, u8 ra, u16 tid, u16 ssn);
934		934
935	void ieee80211_sta_stop_rx_ba_session(struct ieee80211_sub_if_data sdata, u8 da,	935	void ieee80211_sta_stop_rx_ba_session(struct ieee80211_sub_if_data sdata, u8 da,
936	u16 tid, u16 initiator, u16 reason);	936	u16 tid, u16 initiator, u16 reason);
937	void ieee80211_sta_tear_down_BA_sessions(struct ieee80211_sub_if_data sdata, u8 addr);	937	void ieee80211_sta_tear_down_BA_sessions(struct ieee80211_sub_if_data sdata, u8 addr);
938	void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata,	938	void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata,
939	struct sta_info *sta,	939	struct sta_info *sta,
940	struct ieee80211_mgmt *mgmt, size_t len);	940	struct ieee80211_mgmt *mgmt, size_t len);
941	void ieee80211_process_addba_resp(struct ieee80211_local *local,	941	void ieee80211_process_addba_resp(struct ieee80211_local *local,
942	struct sta_info *sta,	942	struct sta_info *sta,
943	struct ieee80211_mgmt *mgmt,	943	struct ieee80211_mgmt *mgmt,
944	size_t len);	944	size_t len);
945	void ieee80211_process_addba_request(struct ieee80211_local *local,	945	void ieee80211_process_addba_request(struct ieee80211_local *local,
946	struct sta_info *sta,	946	struct sta_info *sta,
947	struct ieee80211_mgmt *mgmt,	947	struct ieee80211_mgmt *mgmt,
948	size_t len);	948	size_t len);
949		949
950	/* Spectrum management */	950	/* Spectrum management */
951	void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,	951	void ieee80211_process_measurement_req(struct ieee80211_sub_if_data *sdata,
952	struct ieee80211_mgmt *mgmt,	952	struct ieee80211_mgmt *mgmt,
953	size_t len);	953	size_t len);
954		954
955	/* utility functions/constants */	955	/* utility functions/constants */
956	extern void mac80211_wiphy_privid; / for wiphy privid */	956	extern void mac80211_wiphy_privid; / for wiphy privid */
957	extern const unsigned char rfc1042_header[6];	957	extern const unsigned char rfc1042_header[6];
958	extern const unsigned char bridge_tunnel_header[6];	958	extern const unsigned char bridge_tunnel_header[6];
959	u8 ieee80211_get_bssid(struct ieee80211_hdr hdr, size_t len,	959	u8 ieee80211_get_bssid(struct ieee80211_hdr hdr, size_t len,
960	enum nl80211_iftype type);	960	enum nl80211_iftype type);
961	int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,	961	int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,
962	int rate, int erp, int short_preamble);	962	int rate, int erp, int short_preamble);
963	void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,	963	void mac80211_ev_michael_mic_failure(struct ieee80211_sub_if_data *sdata, int keyidx,
964	struct ieee80211_hdr *hdr);	964	struct ieee80211_hdr *hdr);
965	void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata);	965	void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata);
966	void ieee80211_tx_skb(struct ieee80211_sub_if_data sdata, struct sk_buff skb,	966	void ieee80211_tx_skb(struct ieee80211_sub_if_data sdata, struct sk_buff skb,
967	int encrypt);	967	int encrypt);
968	void ieee802_11_parse_elems(u8 *start, size_t len,	968	void ieee802_11_parse_elems(u8 *start, size_t len,
969	struct ieee802_11_elems *elems);	969	struct ieee802_11_elems *elems);
970	int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freq);	970	int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freq);
971	u64 ieee80211_mandatory_rates(struct ieee80211_local *local,	971	u64 ieee80211_mandatory_rates(struct ieee80211_local *local,
972	enum ieee80211_band band);	972	enum ieee80211_band band);
973		973
974	#ifdef CONFIG_MAC80211_NOINLINE	974	#ifdef CONFIG_MAC80211_NOINLINE
975	#define debug_noinline noinline	975	#define debug_noinline noinline
976	#else	976	#else
977	#define debug_noinline	977	#define debug_noinline
978	#endif	978	#endif
979		979
980	#endif /* IEEE80211_I_H */	980	#endif /* IEEE80211_I_H */
981		981

net/mac80211/main.c

Diff comments View file @ 094d05d

 /*
  * Copyright 2002-2005, Instant802 Networks, Inc.
  * Copyright 2005-2006, Devicescape Software, Inc.
  * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <net/mac80211.h>
 #include <net/ieee80211_radiotap.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/netdevice.h>
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/etherdevice.h>
 #include <linux/if_arp.h>
 #include <linux/wireless.h>
 #include <linux/rtnetlink.h>
 #include <linux/bitmap.h>
 #include <net/net_namespace.h>
 #include <net/cfg80211.h>
 #include "ieee80211_i.h"
 #include "rate.h"
 #include "mesh.h"
 #include "wep.h"
 #include "wme.h"
 #include "aes_ccm.h"
 #include "led.h"
 #include "cfg.h"
 #include "debugfs.h"
 #include "debugfs_netdev.h"
 /*
  * For seeing transmitted packets on monitor interfaces
  * we have a radiotap header too.
  */
 struct ieee80211_tx_status_rtap_hdr {
 	struct ieee80211_radiotap_header hdr;
 	u8 rate;
 	u8 padding_for_rate;
 	__le16 tx_flags;
 	u8 data_retries;
 } __attribute__ ((packed));
 /* must be called under mdev tx lock */
 void ieee80211_configure_filter(struct ieee80211_local *local)
 {
 	unsigned int changed_flags;
 	unsigned int new_flags = 0;
 	if (atomic_read(&local->iff_promiscs))
 		new_flags |= FIF_PROMISC_IN_BSS;
 	if (atomic_read(&local->iff_allmultis))
 		new_flags |= FIF_ALLMULTI;
 	if (local->monitors)
 		new_flags |= FIF_BCN_PRBRESP_PROMISC;
 	if (local->fif_fcsfail)
 		new_flags |= FIF_FCSFAIL;
 	if (local->fif_plcpfail)
 		new_flags |= FIF_PLCPFAIL;
 	if (local->fif_control)
 		new_flags |= FIF_CONTROL;
 	if (local->fif_other_bss)
 		new_flags |= FIF_OTHER_BSS;
 	changed_flags = local->filter_flags ^ new_flags;
 	/* be a bit nasty */
 	new_flags |= (1<<31);
 	local->ops->configure_filter(local_to_hw(local),
 				     changed_flags, &new_flags,
 				     local->mdev->mc_count,
 				     local->mdev->mc_list);
 	WARN_ON(new_flags & (1<<31));
 	local->filter_flags = new_flags & ~(1<<31);
 }
 /* master interface */
 static int header_parse_80211(const struct sk_buff *skb, unsigned char *haddr)
 {
 	memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */
 	return ETH_ALEN;
 }
 static const struct header_ops ieee80211_header_ops = {
 	.create		= eth_header,
 	.parse		= header_parse_80211,
 	.rebuild	= eth_rebuild_header,
 	.cache		= eth_header_cache,
 	.cache_update	= eth_header_cache_update,
 };
 static int ieee80211_master_open(struct net_device *dev)
 {
 	struct ieee80211_master_priv *mpriv = netdev_priv(dev);
 	struct ieee80211_local *local = mpriv->local;
 	struct ieee80211_sub_if_data *sdata;
 	int res = -EOPNOTSUPP;
 	/* we hold the RTNL here so can safely walk the list */
 	list_for_each_entry(sdata, &local->interfaces, list) {
 		if (netif_running(sdata->dev)) {
 			res = 0;
 			break;
 		}
 	}
 	if (res)
 		return res;
 	netif_tx_start_all_queues(local->mdev);
 	return 0;
 }
 static int ieee80211_master_stop(struct net_device *dev)
 {
 	struct ieee80211_master_priv *mpriv = netdev_priv(dev);
 	struct ieee80211_local *local = mpriv->local;
 	struct ieee80211_sub_if_data *sdata;
 	/* we hold the RTNL here so can safely walk the list */
 	list_for_each_entry(sdata, &local->interfaces, list)
 		if (netif_running(sdata->dev))
 			dev_close(sdata->dev);
 	return 0;
 }
 static void ieee80211_master_set_multicast_list(struct net_device *dev)
 {
 	struct ieee80211_master_priv *mpriv = netdev_priv(dev);
 	struct ieee80211_local *local = mpriv->local;
 	ieee80211_configure_filter(local);
 }
 /* everything else */
 int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_if_conf conf;
 	if (WARN_ON(!netif_running(sdata->dev)))
 		return 0;
 	if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
 		return -EINVAL;
 	if (!local->ops->config_interface)
 		return 0;
 	memset(&conf, 0, sizeof(conf));
 	conf.changed = changed;
 	if (sdata->vif.type == NL80211_IFTYPE_STATION ||
 	    sdata->vif.type == NL80211_IFTYPE_ADHOC)
 		conf.bssid = sdata->u.sta.bssid;
 	else if (sdata->vif.type == NL80211_IFTYPE_AP)
 		conf.bssid = sdata->dev->dev_addr;
 	else if (ieee80211_vif_is_mesh(&sdata->vif)) {
 		u8 zero[ETH_ALEN] = { 0 };
 		conf.bssid = zero;
 	} else {
 		WARN_ON(1);
 		return -EINVAL;
 	}
 	if (WARN_ON(!conf.bssid && (changed & IEEE80211_IFCC_BSSID)))
 		return -EINVAL;
 	return local->ops->config_interface(local_to_hw(local),
 					    &sdata->vif, &conf);
 }
 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
 {
 	struct ieee80211_channel *chan;
 	int ret = 0;
 	int power;
-	enum nl80211_sec_chan_offset sec_chan_offset;
+	enum nl80211_channel_type channel_type;
 	might_sleep();
 	if (local->sw_scanning) {
 		chan = local->scan_channel;
-		sec_chan_offset = NL80211_SEC_CHAN_NO_HT;
+		channel_type = NL80211_CHAN_NO_HT;
 	} else {
 		chan = local->oper_channel;
-		sec_chan_offset = local->oper_sec_chan_offset;
+		channel_type = local->oper_channel_type;
 	}
 	if (chan != local->hw.conf.channel ||
-	    sec_chan_offset != local->hw.conf.ht.sec_chan_offset) {
+	    channel_type != local->hw.conf.ht.channel_type) {
 		local->hw.conf.channel = chan;
-		switch (sec_chan_offset) {
+		local->hw.conf.ht.channel_type = channel_type;
-		case NL80211_SEC_CHAN_NO_HT:
+		switch (channel_type) {
+		case NL80211_CHAN_NO_HT:
 			local->hw.conf.ht.enabled = false;
-			local->hw.conf.ht.sec_chan_offset = 0;
 			break;
-		case NL80211_SEC_CHAN_DISABLED:
+		case NL80211_CHAN_HT20:
+		case NL80211_CHAN_HT40MINUS:
+		case NL80211_CHAN_HT40PLUS:
 			local->hw.conf.ht.enabled = true;
-			local->hw.conf.ht.sec_chan_offset = 0;
-			break;
-		case NL80211_SEC_CHAN_BELOW:
-			local->hw.conf.ht.enabled = true;
-			local->hw.conf.ht.sec_chan_offset = -1;
-			break;
-		case NL80211_SEC_CHAN_ABOVE:
-			local->hw.conf.ht.enabled = true;
-			local->hw.conf.ht.sec_chan_offset = 1;
 			break;
 		}
 		changed |= IEEE80211_CONF_CHANGE_CHANNEL;
 	}
 	if (!local->hw.conf.power_level)
 		power = chan->max_power;
 	else
 		power = min(chan->max_power, local->hw.conf.power_level);
 	if (local->hw.conf.power_level != power) {
 		changed |= IEEE80211_CONF_CHANGE_POWER;
 		local->hw.conf.power_level = power;
 	}
 	if (changed && local->open_count) {
 		ret = local->ops->config(local_to_hw(local), changed);
 		/*
 		 * Goal:
 		 * HW reconfiguration should never fail, the driver has told
 		 * us what it can support so it should live up to that promise.
 		 *
 		 * Current status:
 		 * rfkill is not integrated with mac80211 and a
 		 * configuration command can thus fail if hardware rfkill
 		 * is enabled
 		 *
 		 * FIXME: integrate rfkill with mac80211 and then add this
 		 * WARN_ON() back
 		 *
 		 */
 		/* WARN_ON(ret); */
 	}
 	return ret;
 }
 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
 				      u32 changed)
 {
 	struct ieee80211_local *local = sdata->local;
 	if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
 		return;
 	if (!changed)
 		return;
 	if (local->ops->bss_info_changed)
 		local->ops->bss_info_changed(local_to_hw(local),
 					     &sdata->vif,
 					     &sdata->vif.bss_conf,
 					     changed);
 }
 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
 {
 	sdata->vif.bss_conf.use_cts_prot = false;
 	sdata->vif.bss_conf.use_short_preamble = false;
 	sdata->vif.bss_conf.use_short_slot = false;
 	return BSS_CHANGED_ERP_CTS_PROT |
 	       BSS_CHANGED_ERP_PREAMBLE |
 	       BSS_CHANGED_ERP_SLOT;
 }
 void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
 				 struct sk_buff *skb)
 {
 	struct ieee80211_local *local = hw_to_local(hw);
 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 	int tmp;
 	skb->dev = local->mdev;
 	skb->pkt_type = IEEE80211_TX_STATUS_MSG;
 	skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ?
 		       &local->skb_queue : &local->skb_queue_unreliable, skb);
 	tmp = skb_queue_len(&local->skb_queue) +
 		skb_queue_len(&local->skb_queue_unreliable);
 	while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT &&
 	       (skb = skb_dequeue(&local->skb_queue_unreliable))) {
 		dev_kfree_skb_irq(skb);
 		tmp--;
 		I802_DEBUG_INC(local->tx_status_drop);
 	}
 	tasklet_schedule(&local->tasklet);
 }
 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
 static void ieee80211_tasklet_handler(unsigned long data)
 {
 	struct ieee80211_local *local = (struct ieee80211_local *) data;
 	struct sk_buff *skb;
 	struct ieee80211_rx_status rx_status;
 	struct ieee80211_ra_tid *ra_tid;
 	while ((skb = skb_dequeue(&local->skb_queue)) ||
 	       (skb = skb_dequeue(&local->skb_queue_unreliable))) {
 		switch (skb->pkt_type) {
 		case IEEE80211_RX_MSG:
 			/* status is in skb->cb */
 			memcpy(&rx_status, skb->cb, sizeof(rx_status));
 			/* Clear skb->pkt_type in order to not confuse kernel
 			 * netstack. */
 			skb->pkt_type = 0;
 			__ieee80211_rx(local_to_hw(local), skb, &rx_status);
 			break;
 		case IEEE80211_TX_STATUS_MSG:
 			skb->pkt_type = 0;
 			ieee80211_tx_status(local_to_hw(local), skb);
 			break;
 		case IEEE80211_DELBA_MSG:
 			ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
 			ieee80211_stop_tx_ba_cb(local_to_hw(local),
 						ra_tid->ra, ra_tid->tid);
 			dev_kfree_skb(skb);
 			break;
 		case IEEE80211_ADDBA_MSG:
 			ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
 			ieee80211_start_tx_ba_cb(local_to_hw(local),
 						 ra_tid->ra, ra_tid->tid);
 			dev_kfree_skb(skb);
 			break ;
 		default:
 			WARN_ON(1);
 			dev_kfree_skb(skb);
 			break;
 		}
 	}
 }
 /* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to
  * make a prepared TX frame (one that has been given to hw) to look like brand
  * new IEEE 802.11 frame that is ready to go through TX processing again.
  */
 static void ieee80211_remove_tx_extra(struct ieee80211_local *local,
 				      struct ieee80211_key *key,
 				      struct sk_buff *skb)
 {
 	unsigned int hdrlen, iv_len, mic_len;
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 	hdrlen = ieee80211_hdrlen(hdr->frame_control);
 	if (!key)
 		goto no_key;
 	switch (key->conf.alg) {
 	case ALG_WEP:
 		iv_len = WEP_IV_LEN;
 		mic_len = WEP_ICV_LEN;
 		break;
 	case ALG_TKIP:
 		iv_len = TKIP_IV_LEN;
 		mic_len = TKIP_ICV_LEN;
 		break;
 	case ALG_CCMP:
 		iv_len = CCMP_HDR_LEN;
 		mic_len = CCMP_MIC_LEN;
 		break;
 	default:
 		goto no_key;
 	}
 	if (skb->len >= hdrlen + mic_len &&
 	    !(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
 		skb_trim(skb, skb->len - mic_len);
 	if (skb->len >= hdrlen + iv_len) {
 		memmove(skb->data + iv_len, skb->data, hdrlen);
 		hdr = (struct ieee80211_hdr *)skb_pull(skb, iv_len);
 	}
 no_key:
 	if (ieee80211_is_data_qos(hdr->frame_control)) {
 		hdr->frame_control &= ~cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
 		memmove(skb->data + IEEE80211_QOS_CTL_LEN, skb->data,
 			hdrlen - IEEE80211_QOS_CTL_LEN);
 		skb_pull(skb, IEEE80211_QOS_CTL_LEN);
 	}
 }
 static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
 					    struct sta_info *sta,
 					    struct sk_buff *skb)
 {
 	sta->tx_filtered_count++;
 	/*
 	 * Clear the TX filter mask for this STA when sending the next
 	 * packet. If the STA went to power save mode, this will happen
 	 * when it wakes up for the next time.
 	 */
 	set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT);
 	/*
 	 * This code races in the following way:
 	 *
 	 *  (1) STA sends frame indicating it will go to sleep and does so
 	 *  (2) hardware/firmware adds STA to filter list, passes frame up
 	 *  (3) hardware/firmware processes TX fifo and suppresses a frame
 	 *  (4) we get TX status before having processed the frame and
 	 *	knowing that the STA has gone to sleep.
 	 *
 	 * This is actually quite unlikely even when both those events are
 	 * processed from interrupts coming in quickly after one another or
 	 * even at the same time because we queue both TX status events and
 	 * RX frames to be processed by a tasklet and process them in the
 	 * same order that they were received or TX status last. Hence, there
 	 * is no race as long as the frame RX is processed before the next TX
 	 * status, which drivers can ensure, see below.
 	 *
 	 * Note that this can only happen if the hardware or firmware can
 	 * actually add STAs to the filter list, if this is done by the
 	 * driver in response to set_tim() (which will only reduce the race
 	 * this whole filtering tries to solve, not completely solve it)
 	 * this situation cannot happen.
 	 *
 	 * To completely solve this race drivers need to make sure that they
 	 *  (a) don't mix the irq-safe/not irq-safe TX status/RX processing
 	 *	functions and
 	 *  (b) always process RX events before TX status events if ordering
 	 *      can be unknown, for example with different interrupt status
 	 *	bits.
 	 */
 	if (test_sta_flags(sta, WLAN_STA_PS) &&
 	    skb_queue_len(&sta->tx_filtered) < STA_MAX_TX_BUFFER) {
 		ieee80211_remove_tx_extra(local, sta->key, skb);
 		skb_queue_tail(&sta->tx_filtered, skb);
 		return;
 	}
 	if (!test_sta_flags(sta, WLAN_STA_PS) && !skb->requeue) {
 		/* Software retry the packet once */
 		skb->requeue = 1;
 		ieee80211_remove_tx_extra(local, sta->key, skb);
 		dev_queue_xmit(skb);
 		return;
 	}
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 	if (net_ratelimit())
 		printk(KERN_DEBUG "%s: dropped TX filtered frame, "
 		       "queue_len=%d PS=%d @%lu\n",
 		       wiphy_name(local->hw.wiphy),
 		       skb_queue_len(&sta->tx_filtered),
 		       !!test_sta_flags(sta, WLAN_STA_PS), jiffies);
 #endif
 	dev_kfree_skb(skb);
 }
 void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
 {
 	struct sk_buff *skb2;
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 	struct ieee80211_local *local = hw_to_local(hw);
 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 	u16 frag, type;
 	__le16 fc;
 	struct ieee80211_supported_band *sband;
 	struct ieee80211_tx_status_rtap_hdr *rthdr;
 	struct ieee80211_sub_if_data *sdata;
 	struct net_device *prev_dev = NULL;
 	struct sta_info *sta;
 	int retry_count = -1, i;
 	for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
 		/* the HW cannot have attempted that rate */
 		if (i >= hw->max_rates) {
 			info->status.rates[i].idx = -1;
 			info->status.rates[i].count = 0;
 		}
 		retry_count += info->status.rates[i].count;
 	}
 	if (retry_count < 0)
 		retry_count = 0;
 	rcu_read_lock();
 	sband = local->hw.wiphy->bands[info->band];
 	sta = sta_info_get(local, hdr->addr1);
 	if (sta) {
 		if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
 		    test_sta_flags(sta, WLAN_STA_PS)) {
 			/*
 			 * The STA is in power save mode, so assume
 			 * that this TX packet failed because of that.
 			 */
 			ieee80211_handle_filtered_frame(local, sta, skb);
 			rcu_read_unlock();
 			return;
 		}
 		fc = hdr->frame_control;
 		if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
 		    (ieee80211_is_data_qos(fc))) {
 			u16 tid, ssn;
 			u8 *qc;
 			qc = ieee80211_get_qos_ctl(hdr);
 			tid = qc[0] & 0xf;
 			ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
 						& IEEE80211_SCTL_SEQ);
 			ieee80211_send_bar(sta->sdata, hdr->addr1,
 					   tid, ssn);
 		}
 		if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
 			ieee80211_handle_filtered_frame(local, sta, skb);
 			rcu_read_unlock();
 			return;
 		} else {
 			if (!(info->flags & IEEE80211_TX_STAT_ACK))
 				sta->tx_retry_failed++;
 			sta->tx_retry_count += retry_count;
 		}
 		rate_control_tx_status(local, sband, sta, skb);
 	}
 	rcu_read_unlock();
 	ieee80211_led_tx(local, 0);
 	/* SNMP counters
 	 * Fragments are passed to low-level drivers as separate skbs, so these
 	 * are actually fragments, not frames. Update frame counters only for
 	 * the first fragment of the frame. */
 	frag = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG;
 	type = le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_FTYPE;
 	if (info->flags & IEEE80211_TX_STAT_ACK) {
 		if (frag == 0) {
 			local->dot11TransmittedFrameCount++;
 			if (is_multicast_ether_addr(hdr->addr1))
 				local->dot11MulticastTransmittedFrameCount++;
 			if (retry_count > 0)
 				local->dot11RetryCount++;
 			if (retry_count > 1)
 				local->dot11MultipleRetryCount++;
 		}
 		/* This counter shall be incremented for an acknowledged MPDU
 		 * with an individual address in the address 1 field or an MPDU
 		 * with a multicast address in the address 1 field of type Data
 		 * or Management. */
 		if (!is_multicast_ether_addr(hdr->addr1) ||
 		    type == IEEE80211_FTYPE_DATA ||
 		    type == IEEE80211_FTYPE_MGMT)
 			local->dot11TransmittedFragmentCount++;
 	} else {
 		if (frag == 0)
 			local->dot11FailedCount++;
 	}
 	/* this was a transmitted frame, but now we want to reuse it */
 	skb_orphan(skb);
 	/*
 	 * This is a bit racy but we can avoid a lot of work
 	 * with this test...
 	 */
 	if (!local->monitors && !local->cooked_mntrs) {
 		dev_kfree_skb(skb);
 		return;
 	}
 	/* send frame to monitor interfaces now */
 	if (skb_headroom(skb) < sizeof(*rthdr)) {
 		printk(KERN_ERR "ieee80211_tx_status: headroom too small\n");
 		dev_kfree_skb(skb);
 		return;
 	}
 	rthdr = (struct ieee80211_tx_status_rtap_hdr *)
 				skb_push(skb, sizeof(*rthdr));
 	memset(rthdr, 0, sizeof(*rthdr));
 	rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr));
 	rthdr->hdr.it_present =
 		cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
 			    (1 << IEEE80211_RADIOTAP_DATA_RETRIES) |
 			    (1 << IEEE80211_RADIOTAP_RATE));
 	if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
 	    !is_multicast_ether_addr(hdr->addr1))
 		rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL);
 	/*
 	 * XXX: Once radiotap gets the bitmap reset thing the vendor
 	 *	extensions proposal contains, we can actually report
 	 *	the whole set of tries we did.
 	 */
 	if ((info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
 	    (info->status.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT))
 		rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS);
 	else if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
 		rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS);
 	if (info->status.rates[0].idx >= 0 &&
 	    !(info->status.rates[0].flags & IEEE80211_TX_RC_MCS))
 		rthdr->rate = sband->bitrates[
 				info->status.rates[0].idx].bitrate / 5;
 	/* for now report the total retry_count */
 	rthdr->data_retries = retry_count;
 	/* XXX: is this sufficient for BPF? */
 	skb_set_mac_header(skb, 0);
 	skb->ip_summed = CHECKSUM_UNNECESSARY;
 	skb->pkt_type = PACKET_OTHERHOST;
 	skb->protocol = htons(ETH_P_802_2);
 	memset(skb->cb, 0, sizeof(skb->cb));
 	rcu_read_lock();
 	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 		if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
 			if (!netif_running(sdata->dev))
 				continue;
 			if (prev_dev) {
 				skb2 = skb_clone(skb, GFP_ATOMIC);
 				if (skb2) {
 					skb2->dev = prev_dev;
 					netif_rx(skb2);
 				}
 			}
 			prev_dev = sdata->dev;
 		}
 	}
 	if (prev_dev) {
 		skb->dev = prev_dev;
 		netif_rx(skb);
 		skb = NULL;
 	}
 	rcu_read_unlock();
 	dev_kfree_skb(skb);
 }
 EXPORT_SYMBOL(ieee80211_tx_status);
 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
 					const struct ieee80211_ops *ops)
 {
 	struct ieee80211_local *local;
 	int priv_size;
 	struct wiphy *wiphy;
 	/* Ensure 32-byte alignment of our private data and hw private data.
 	 * We use the wiphy priv data for both our ieee80211_local and for
 	 * the driver's private data
 	 *
 	 * In memory it'll be like this:
 	 *
 	 * +-------------------------+
 	 * | struct wiphy	    |
 	 * +-------------------------+
 	 * | struct ieee80211_local  |
 	 * +-------------------------+
 	 * | driver's private data   |
 	 * +-------------------------+
 	 *
 	 */
 	priv_size = ((sizeof(struct ieee80211_local) +
 		      NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) +
 		    priv_data_len;
 	wiphy = wiphy_new(&mac80211_config_ops, priv_size);
 	if (!wiphy)
 		return NULL;
 	wiphy->privid = mac80211_wiphy_privid;
 	local = wiphy_priv(wiphy);
 	local->hw.wiphy = wiphy;
 	local->hw.priv = (char *)local +
 			 ((sizeof(struct ieee80211_local) +
 			   NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
 	BUG_ON(!ops->tx);
 	BUG_ON(!ops->start);
 	BUG_ON(!ops->stop);
 	BUG_ON(!ops->config);
 	BUG_ON(!ops->add_interface);
 	BUG_ON(!ops->remove_interface);
 	BUG_ON(!ops->configure_filter);
 	local->ops = ops;
 	/* set up some defaults */
 	local->hw.queues = 1;
 	local->hw.max_rates = 1;
 	local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
 	local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
 	local->hw.conf.long_frame_max_tx_count = 4;
 	local->hw.conf.short_frame_max_tx_count = 7;
 	local->hw.conf.radio_enabled = true;
 	INIT_LIST_HEAD(&local->interfaces);
 	spin_lock_init(&local->key_lock);
 	INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
 	sta_info_init(local);
 	tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending,
 		     (unsigned long)local);
 	tasklet_disable(&local->tx_pending_tasklet);
 	tasklet_init(&local->tasklet,
 		     ieee80211_tasklet_handler,
 		     (unsigned long) local);
 	tasklet_disable(&local->tasklet);
 	skb_queue_head_init(&local->skb_queue);
 	skb_queue_head_init(&local->skb_queue_unreliable);
 	return local_to_hw(local);
 }
 EXPORT_SYMBOL(ieee80211_alloc_hw);
 int ieee80211_register_hw(struct ieee80211_hw *hw)
 {
 	struct ieee80211_local *local = hw_to_local(hw);
 	int result;
 	enum ieee80211_band band;
 	struct net_device *mdev;
 	struct ieee80211_master_priv *mpriv;
 	/*
 	 * generic code guarantees at least one band,
 	 * set this very early because much code assumes
 	 * that hw.conf.channel is assigned
 	 */
 	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
 		struct ieee80211_supported_band *sband;
 		sband = local->hw.wiphy->bands[band];
 		if (sband) {
 			/* init channel we're on */
 			local->hw.conf.channel =
 			local->oper_channel =
 			local->scan_channel = &sband->channels[0];
 			break;
 		}
 	}
 	/* if low-level driver supports AP, we also support VLAN */
 	if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP))
 		local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
 	/* mac80211 always supports monitor */
 	local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
 	result = wiphy_register(local->hw.wiphy);
 	if (result < 0)
 		return result;
 	/*
 	 * We use the number of queues for feature tests (QoS, HT) internally
 	 * so restrict them appropriately.
 	 */
 	if (hw->queues > IEEE80211_MAX_QUEUES)
 		hw->queues = IEEE80211_MAX_QUEUES;
 	if (hw->ampdu_queues > IEEE80211_MAX_AMPDU_QUEUES)
 		hw->ampdu_queues = IEEE80211_MAX_AMPDU_QUEUES;
 	if (hw->queues < 4)
 		hw->ampdu_queues = 0;
 	mdev = alloc_netdev_mq(sizeof(struct ieee80211_master_priv),
 			       "wmaster%d", ether_setup,
 			       ieee80211_num_queues(hw));
 	if (!mdev)
 		goto fail_mdev_alloc;
 	mpriv = netdev_priv(mdev);
 	mpriv->local = local;
 	local->mdev = mdev;
 	ieee80211_rx_bss_list_init(local);
 	mdev->hard_start_xmit = ieee80211_master_start_xmit;
 	mdev->open = ieee80211_master_open;
 	mdev->stop = ieee80211_master_stop;
 	mdev->type = ARPHRD_IEEE80211;
 	mdev->header_ops = &ieee80211_header_ops;
 	mdev->set_multicast_list = ieee80211_master_set_multicast_list;
 	local->hw.workqueue =
 		create_freezeable_workqueue(wiphy_name(local->hw.wiphy));
 	if (!local->hw.workqueue) {
 		result = -ENOMEM;
 		goto fail_workqueue;
 	}
 	/*
 	 * The hardware needs headroom for sending the frame,
 	 * and we need some headroom for passing the frame to monitor
 	 * interfaces, but never both at the same time.
 	 */
 	local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
 				   sizeof(struct ieee80211_tx_status_rtap_hdr));
 	debugfs_hw_add(local);
 	if (local->hw.conf.beacon_int < 10)
 		local->hw.conf.beacon_int = 100;
 	if (local->hw.max_listen_interval == 0)
 		local->hw.max_listen_interval = 1;
 	local->hw.conf.listen_interval = local->hw.max_listen_interval;
 	local->wstats_flags |= local->hw.flags & (IEEE80211_HW_SIGNAL_UNSPEC |
 						  IEEE80211_HW_SIGNAL_DB |
 						  IEEE80211_HW_SIGNAL_DBM) ?
 			       IW_QUAL_QUAL_UPDATED : IW_QUAL_QUAL_INVALID;
 	local->wstats_flags |= local->hw.flags & IEEE80211_HW_NOISE_DBM ?
 			       IW_QUAL_NOISE_UPDATED : IW_QUAL_NOISE_INVALID;
 	if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
 		local->wstats_flags |= IW_QUAL_DBM;
 	result = sta_info_start(local);
 	if (result < 0)
 		goto fail_sta_info;
 	rtnl_lock();
 	result = dev_alloc_name(local->mdev, local->mdev->name);
 	if (result < 0)
 		goto fail_dev;
 	memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
 	SET_NETDEV_DEV(local->mdev, wiphy_dev(local->hw.wiphy));
 	result = register_netdevice(local->mdev);
 	if (result < 0)
 		goto fail_dev;
 	result = ieee80211_init_rate_ctrl_alg(local,
 					      hw->rate_control_algorithm);
 	if (result < 0) {
 		printk(KERN_DEBUG "%s: Failed to initialize rate control "
 		       "algorithm\n", wiphy_name(local->hw.wiphy));
 		goto fail_rate;
 	}
 	result = ieee80211_wep_init(local);
 	if (result < 0) {
 		printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n",
 		       wiphy_name(local->hw.wiphy), result);
 		goto fail_wep;
 	}
 	local->mdev->select_queue = ieee80211_select_queue;
 	/* add one default STA interface if supported */
 	if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) {
 		result = ieee80211_if_add(local, "wlan%d", NULL,
 					  NL80211_IFTYPE_STATION, NULL);
 		if (result)
 			printk(KERN_WARNING "%s: Failed to add default virtual iface\n",
 			       wiphy_name(local->hw.wiphy));
 	}
 	rtnl_unlock();
 	ieee80211_led_init(local);
 	return 0;
 fail_wep:
 	rate_control_deinitialize(local);
 fail_rate:
 	unregister_netdevice(local->mdev);
 	local->mdev = NULL;
 fail_dev:
 	rtnl_unlock();
 	sta_info_stop(local);
 fail_sta_info:
 	debugfs_hw_del(local);
 	destroy_workqueue(local->hw.workqueue);
 fail_workqueue:
 	if (local->mdev)
 		free_netdev(local->mdev);
 fail_mdev_alloc:
 	wiphy_unregister(local->hw.wiphy);
 	return result;
 }
 EXPORT_SYMBOL(ieee80211_register_hw);
 void ieee80211_unregister_hw(struct ieee80211_hw *hw)
 {
 	struct ieee80211_local *local = hw_to_local(hw);
 	tasklet_kill(&local->tx_pending_tasklet);
 	tasklet_kill(&local->tasklet);
 	rtnl_lock();
 	/*
 	 * At this point, interface list manipulations are fine
 	 * because the driver cannot be handing us frames any
 	 * more and the tasklet is killed.
 	 */
 	/* First, we remove all virtual interfaces. */
 	ieee80211_remove_interfaces(local);
 	/* then, finally, remove the master interface */
 	unregister_netdevice(local->mdev);
 	rtnl_unlock();
 	ieee80211_rx_bss_list_deinit(local);
 	ieee80211_clear_tx_pending(local);
 	sta_info_stop(local);
 	rate_control_deinitialize(local);
 	debugfs_hw_del(local);
 	if (skb_queue_len(&local->skb_queue)
 			|| skb_queue_len(&local->skb_queue_unreliable))
 		printk(KERN_WARNING "%s: skb_queue not empty\n",
 		       wiphy_name(local->hw.wiphy));
 	skb_queue_purge(&local->skb_queue);
 	skb_queue_purge(&local->skb_queue_unreliable);
 	destroy_workqueue(local->hw.workqueue);
 	wiphy_unregister(local->hw.wiphy);
 	ieee80211_wep_free(local);
 	ieee80211_led_exit(local);
 	free_netdev(local->mdev);
 }
 EXPORT_SYMBOL(ieee80211_unregister_hw);
 void ieee80211_free_hw(struct ieee80211_hw *hw)
 {
 	struct ieee80211_local *local = hw_to_local(hw);
 	wiphy_free(local->hw.wiphy);
 }
 EXPORT_SYMBOL(ieee80211_free_hw);
 static int __init ieee80211_init(void)
 {
 	struct sk_buff *skb;
 	int ret;
 	BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
 	BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
 		     IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
 	ret = rc80211_minstrel_init();
 	if (ret)
 		return ret;
 	ret = rc80211_pid_init();
 	if (ret)
 		return ret;
 	ieee80211_debugfs_netdev_init();
 	return 0;
 }
 static void __exit ieee80211_exit(void)
 {
 	rc80211_pid_exit();
 	rc80211_minstrel_exit();
 	/*
 	 * For key todo, it'll be empty by now but the work
 	 * might still be scheduled.
 	 */
 	flush_scheduled_work();
 	if (mesh_allocated)
 		ieee80211s_stop();
 	ieee80211_debugfs_netdev_exit();
 }
 subsys_initcall(ieee80211_init);
 module_exit(ieee80211_exit);

net/mac80211/mlme.c

Diff comments View file @ 094d05d

 /*
  * BSS client mode implementation
  * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
  * Copyright 2004, Instant802 Networks, Inc.
  * Copyright 2005, Devicescape Software, Inc.
  * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
  * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/delay.h>
 #include <linux/if_ether.h>
 #include <linux/skbuff.h>
 #include <linux/if_arp.h>
 #include <linux/wireless.h>
 #include <linux/random.h>
 #include <linux/etherdevice.h>
 #include <linux/rtnetlink.h>
 #include <net/iw_handler.h>
 #include <net/mac80211.h>
 #include <asm/unaligned.h>
 #include "ieee80211_i.h"
 #include "rate.h"
 #include "led.h"
 #define IEEE80211_ASSOC_SCANS_MAX_TRIES 2
 #define IEEE80211_AUTH_TIMEOUT (HZ / 5)
 #define IEEE80211_AUTH_MAX_TRIES 3
 #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
 #define IEEE80211_ASSOC_MAX_TRIES 3
 #define IEEE80211_MONITORING_INTERVAL (2 * HZ)
 #define IEEE80211_PROBE_INTERVAL (60 * HZ)
 #define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ)
 #define IEEE80211_SCAN_INTERVAL (2 * HZ)
 #define IEEE80211_SCAN_INTERVAL_SLOW (15 * HZ)
 #define IEEE80211_IBSS_JOIN_TIMEOUT (7 * HZ)
 #define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
 #define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
 #define IEEE80211_IBSS_MAX_STA_ENTRIES 128
 /* utils */
 static int ecw2cw(int ecw)
 {
 	return (1 << ecw) - 1;
 }
 static u8 *ieee80211_bss_get_ie(struct ieee80211_bss *bss, u8 ie)
 {
 	u8 *end, *pos;
 	pos = bss->ies;
 	if (pos == NULL)
 		return NULL;
 	end = pos + bss->ies_len;
 	while (pos + 1 < end) {
 		if (pos + 2 + pos[1] > end)
 			break;
 		if (pos[0] == ie)
 			return pos;
 		pos += 2 + pos[1];
 	}
 	return NULL;
 }
 static int ieee80211_compatible_rates(struct ieee80211_bss *bss,
 				      struct ieee80211_supported_band *sband,
 				      u64 *rates)
 {
 	int i, j, count;
 	*rates = 0;
 	count = 0;
 	for (i = 0; i < bss->supp_rates_len; i++) {
 		int rate = (bss->supp_rates[i] & 0x7F) * 5;
 		for (j = 0; j < sband->n_bitrates; j++)
 			if (sband->bitrates[j].bitrate == rate) {
 				*rates |= BIT(j);
 				count++;
 				break;
 			}
 	}
 	return count;
 }
 /* also used by mesh code */
 u64 ieee80211_sta_get_rates(struct ieee80211_local *local,
 			    struct ieee802_11_elems *elems,
 			    enum ieee80211_band band)
 {
 	struct ieee80211_supported_band *sband;
 	struct ieee80211_rate *bitrates;
 	size_t num_rates;
 	u64 supp_rates;
 	int i, j;
 	sband = local->hw.wiphy->bands[band];
 	if (!sband) {
 		WARN_ON(1);
 		sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 	}
 	bitrates = sband->bitrates;
 	num_rates = sband->n_bitrates;
 	supp_rates = 0;
 	for (i = 0; i < elems->supp_rates_len +
 		     elems->ext_supp_rates_len; i++) {
 		u8 rate = 0;
 		int own_rate;
 		if (i < elems->supp_rates_len)
 			rate = elems->supp_rates[i];
 		else if (elems->ext_supp_rates)
 			rate = elems->ext_supp_rates
 				[i - elems->supp_rates_len];
 		own_rate = 5 * (rate & 0x7f);
 		for (j = 0; j < num_rates; j++)
 			if (bitrates[j].bitrate == own_rate)
 				supp_rates |= BIT(j);
 	}
 	return supp_rates;
 }
 /* frame sending functions */
 /* also used by scanning code */
 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
 			      u8 *ssid, size_t ssid_len)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_supported_band *sband;
 	struct sk_buff *skb;
 	struct ieee80211_mgmt *mgmt;
 	u8 *pos, *supp_rates, *esupp_rates = NULL;
 	int i;
 	skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 200);
 	if (!skb) {
 		printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
 		       "request\n", sdata->dev->name);
 		return;
 	}
 	skb_reserve(skb, local->hw.extra_tx_headroom);
 	mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
 	memset(mgmt, 0, 24);
 	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 					  IEEE80211_STYPE_PROBE_REQ);
 	memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
 	if (dst) {
 		memcpy(mgmt->da, dst, ETH_ALEN);
 		memcpy(mgmt->bssid, dst, ETH_ALEN);
 	} else {
 		memset(mgmt->da, 0xff, ETH_ALEN);
 		memset(mgmt->bssid, 0xff, ETH_ALEN);
 	}
 	pos = skb_put(skb, 2 + ssid_len);
 	*pos++ = WLAN_EID_SSID;
 	*pos++ = ssid_len;
 	memcpy(pos, ssid, ssid_len);
 	supp_rates = skb_put(skb, 2);
 	supp_rates[0] = WLAN_EID_SUPP_RATES;
 	supp_rates[1] = 0;
 	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 	for (i = 0; i < sband->n_bitrates; i++) {
 		struct ieee80211_rate *rate = &sband->bitrates[i];
 		if (esupp_rates) {
 			pos = skb_put(skb, 1);
 			esupp_rates[1]++;
 		} else if (supp_rates[1] == 8) {
 			esupp_rates = skb_put(skb, 3);
 			esupp_rates[0] = WLAN_EID_EXT_SUPP_RATES;
 			esupp_rates[1] = 1;
 			pos = &esupp_rates[2];
 		} else {
 			pos = skb_put(skb, 1);
 			supp_rates[1]++;
 		}
 		*pos = rate->bitrate / 5;
 	}
 	ieee80211_tx_skb(sdata, skb, 0);
 }
 static void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
 				struct ieee80211_if_sta *ifsta,
 				int transaction, u8 *extra, size_t extra_len,
 				int encrypt)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct sk_buff *skb;
 	struct ieee80211_mgmt *mgmt;
 	skb = dev_alloc_skb(local->hw.extra_tx_headroom +
 			    sizeof(*mgmt) + 6 + extra_len);
 	if (!skb) {
 		printk(KERN_DEBUG "%s: failed to allocate buffer for auth "
 		       "frame\n", sdata->dev->name);
 		return;
 	}
 	skb_reserve(skb, local->hw.extra_tx_headroom);
 	mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
 	memset(mgmt, 0, 24 + 6);
 	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 					  IEEE80211_STYPE_AUTH);
 	if (encrypt)
 		mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
 	memcpy(mgmt->da, ifsta->bssid, ETH_ALEN);
 	memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
 	memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
 	mgmt->u.auth.auth_alg = cpu_to_le16(ifsta->auth_alg);
 	mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
 	ifsta->auth_transaction = transaction + 1;
 	mgmt->u.auth.status_code = cpu_to_le16(0);
 	if (extra)
 		memcpy(skb_put(skb, extra_len), extra, extra_len);
 	ieee80211_tx_skb(sdata, skb, encrypt);
 }
 static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
 				 struct ieee80211_if_sta *ifsta)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct sk_buff *skb;
 	struct ieee80211_mgmt *mgmt;
 	u8 *pos, *ies, *ht_ie;
 	int i, len, count, rates_len, supp_rates_len;
 	u16 capab;
 	struct ieee80211_bss *bss;
 	int wmm = 0;
 	struct ieee80211_supported_band *sband;
 	u64 rates = 0;
 	skb = dev_alloc_skb(local->hw.extra_tx_headroom +
 			    sizeof(*mgmt) + 200 + ifsta->extra_ie_len +
 			    ifsta->ssid_len);
 	if (!skb) {
 		printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "
 		       "frame\n", sdata->dev->name);
 		return;
 	}
 	skb_reserve(skb, local->hw.extra_tx_headroom);
 	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 	capab = ifsta->capab;
 	if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) {
 		if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
 			capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
 		if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
 			capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
 	}
 	bss = ieee80211_rx_bss_get(local, ifsta->bssid,
 				   local->hw.conf.channel->center_freq,
 				   ifsta->ssid, ifsta->ssid_len);
 	if (bss) {
 		if (bss->capability & WLAN_CAPABILITY_PRIVACY)
 			capab |= WLAN_CAPABILITY_PRIVACY;
 		if (bss->wmm_used)
 			wmm = 1;
 		/* get all rates supported by the device and the AP as
 		 * some APs don't like getting a superset of their rates
 		 * in the association request (e.g. D-Link DAP 1353 in
 		 * b-only mode) */
 		rates_len = ieee80211_compatible_rates(bss, sband, &rates);
 		if ((bss->capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
 		    (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
 			capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
 		ieee80211_rx_bss_put(local, bss);
 	} else {
 		rates = ~0;
 		rates_len = sband->n_bitrates;
 	}
 	mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
 	memset(mgmt, 0, 24);
 	memcpy(mgmt->da, ifsta->bssid, ETH_ALEN);
 	memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
 	memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
 	if (ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) {
 		skb_put(skb, 10);
 		mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 						  IEEE80211_STYPE_REASSOC_REQ);
 		mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
 		mgmt->u.reassoc_req.listen_interval =
 				cpu_to_le16(local->hw.conf.listen_interval);
 		memcpy(mgmt->u.reassoc_req.current_ap, ifsta->prev_bssid,
 		       ETH_ALEN);
 	} else {
 		skb_put(skb, 4);
 		mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 						  IEEE80211_STYPE_ASSOC_REQ);
 		mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
 		mgmt->u.reassoc_req.listen_interval =
 				cpu_to_le16(local->hw.conf.listen_interval);
 	}
 	/* SSID */
 	ies = pos = skb_put(skb, 2 + ifsta->ssid_len);
 	*pos++ = WLAN_EID_SSID;
 	*pos++ = ifsta->ssid_len;
 	memcpy(pos, ifsta->ssid, ifsta->ssid_len);
 	/* add all rates which were marked to be used above */
 	supp_rates_len = rates_len;
 	if (supp_rates_len > 8)
 		supp_rates_len = 8;
 	len = sband->n_bitrates;
 	pos = skb_put(skb, supp_rates_len + 2);
 	*pos++ = WLAN_EID_SUPP_RATES;
 	*pos++ = supp_rates_len;
 	count = 0;
 	for (i = 0; i < sband->n_bitrates; i++) {
 		if (BIT(i) & rates) {
 			int rate = sband->bitrates[i].bitrate;
 			*pos++ = (u8) (rate / 5);
 			if (++count == 8)
 				break;
 		}
 	}
 	if (rates_len > count) {
 		pos = skb_put(skb, rates_len - count + 2);
 		*pos++ = WLAN_EID_EXT_SUPP_RATES;
 		*pos++ = rates_len - count;
 		for (i++; i < sband->n_bitrates; i++) {
 			if (BIT(i) & rates) {
 				int rate = sband->bitrates[i].bitrate;
 				*pos++ = (u8) (rate / 5);
 			}
 		}
 	}
 	if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
 		/* 1. power capabilities */
 		pos = skb_put(skb, 4);
 		*pos++ = WLAN_EID_PWR_CAPABILITY;
 		*pos++ = 2;
 		*pos++ = 0; /* min tx power */
 		*pos++ = local->hw.conf.channel->max_power; /* max tx power */
 		/* 2. supported channels */
 		/* TODO: get this in reg domain format */
 		pos = skb_put(skb, 2 * sband->n_channels + 2);
 		*pos++ = WLAN_EID_SUPPORTED_CHANNELS;
 		*pos++ = 2 * sband->n_channels;
 		for (i = 0; i < sband->n_channels; i++) {
 			*pos++ = ieee80211_frequency_to_channel(
 					sband->channels[i].center_freq);
 			*pos++ = 1; /* one channel in the subband*/
 		}
 	}
 	if (ifsta->extra_ie) {
 		pos = skb_put(skb, ifsta->extra_ie_len);
 		memcpy(pos, ifsta->extra_ie, ifsta->extra_ie_len);
 	}
 	if (wmm && (ifsta->flags & IEEE80211_STA_WMM_ENABLED)) {
 		pos = skb_put(skb, 9);
 		*pos++ = WLAN_EID_VENDOR_SPECIFIC;
 		*pos++ = 7; /* len */
 		*pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
 		*pos++ = 0x50;
 		*pos++ = 0xf2;
 		*pos++ = 2; /* WME */
 		*pos++ = 0; /* WME info */
 		*pos++ = 1; /* WME ver */
 		*pos++ = 0;
 	}
 	/* wmm support is a must to HT */
 	if (wmm && (ifsta->flags & IEEE80211_STA_WMM_ENABLED) &&
 	    sband->ht_cap.ht_supported &&
 	    (ht_ie = ieee80211_bss_get_ie(bss, WLAN_EID_HT_INFORMATION)) &&
 	    ht_ie[1] >= sizeof(struct ieee80211_ht_info)) {
 		struct ieee80211_ht_info *ht_info =
 			(struct ieee80211_ht_info *)(ht_ie + 2);
 		u16 cap = sband->ht_cap.cap;
 		__le16 tmp;
 		u32 flags = local->hw.conf.channel->flags;
 		switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
 		case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
 			if (flags & IEEE80211_CHAN_NO_FAT_ABOVE) {
 				cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
 				cap &= ~IEEE80211_HT_CAP_SGI_40;
 			}
 			break;
 		case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
 			if (flags & IEEE80211_CHAN_NO_FAT_BELOW) {
 				cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
 				cap &= ~IEEE80211_HT_CAP_SGI_40;
 			}
 			break;
 		}
 		tmp = cpu_to_le16(cap);
 		pos = skb_put(skb, sizeof(struct ieee80211_ht_cap)+2);
 		*pos++ = WLAN_EID_HT_CAPABILITY;
 		*pos++ = sizeof(struct ieee80211_ht_cap);
 		memset(pos, 0, sizeof(struct ieee80211_ht_cap));
 		memcpy(pos, &tmp, sizeof(u16));
 		pos += sizeof(u16);
 		/* TODO: needs a define here for << 2 */
 		*pos++ = sband->ht_cap.ampdu_factor |
 			 (sband->ht_cap.ampdu_density << 2);
 		memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));
 	}
 	kfree(ifsta->assocreq_ies);
 	ifsta->assocreq_ies_len = (skb->data + skb->len) - ies;
 	ifsta->assocreq_ies = kmalloc(ifsta->assocreq_ies_len, GFP_KERNEL);
 	if (ifsta->assocreq_ies)
 		memcpy(ifsta->assocreq_ies, ies, ifsta->assocreq_ies_len);
 	ieee80211_tx_skb(sdata, skb, 0);
 }
 static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
 					   u16 stype, u16 reason)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_if_sta *ifsta = &sdata->u.sta;
 	struct sk_buff *skb;
 	struct ieee80211_mgmt *mgmt;
 	skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));
 	if (!skb) {
 		printk(KERN_DEBUG "%s: failed to allocate buffer for "
 		       "deauth/disassoc frame\n", sdata->dev->name);
 		return;
 	}
 	skb_reserve(skb, local->hw.extra_tx_headroom);
 	mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
 	memset(mgmt, 0, 24);
 	memcpy(mgmt->da, ifsta->bssid, ETH_ALEN);
 	memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
 	memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
 	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
 	skb_put(skb, 2);
 	/* u.deauth.reason_code == u.disassoc.reason_code */
 	mgmt->u.deauth.reason_code = cpu_to_le16(reason);
 	ieee80211_tx_skb(sdata, skb, 0);
 }
 /* MLME */
 static void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
 					 struct ieee80211_bss *bss)
 {
 	struct ieee80211_local *local = sdata->local;
 	int i, have_higher_than_11mbit = 0;
 	/* cf. IEEE 802.11 9.2.12 */
 	for (i = 0; i < bss->supp_rates_len; i++)
 		if ((bss->supp_rates[i] & 0x7f) * 5 > 110)
 			have_higher_than_11mbit = 1;
 	if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
 	    have_higher_than_11mbit)
 		sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
 	else
 		sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
 	ieee80211_set_wmm_default(sdata);
 }
 static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
 				     struct ieee80211_if_sta *ifsta,
 				     u8 *wmm_param, size_t wmm_param_len)
 {
 	struct ieee80211_tx_queue_params params;
 	size_t left;
 	int count;
 	u8 *pos;
 	if (!(ifsta->flags & IEEE80211_STA_WMM_ENABLED))
 		return;
 	if (!wmm_param)
 		return;
 	if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
 		return;
 	count = wmm_param[6] & 0x0f;
 	if (count == ifsta->wmm_last_param_set)
 		return;
 	ifsta->wmm_last_param_set = count;
 	pos = wmm_param + 8;
 	left = wmm_param_len - 8;
 	memset(&params, 0, sizeof(params));
 	if (!local->ops->conf_tx)
 		return;
 	local->wmm_acm = 0;
 	for (; left >= 4; left -= 4, pos += 4) {
 		int aci = (pos[0] >> 5) & 0x03;
 		int acm = (pos[0] >> 4) & 0x01;
 		int queue;
 		switch (aci) {
 		case 1:
 			queue = 3;
 			if (acm)
 				local->wmm_acm |= BIT(0) | BIT(3);
 			break;
 		case 2:
 			queue = 1;
 			if (acm)
 				local->wmm_acm |= BIT(4) | BIT(5);
 			break;
 		case 3:
 			queue = 0;
 			if (acm)
 				local->wmm_acm |= BIT(6) | BIT(7);
 			break;
 		case 0:
 		default:
 			queue = 2;
 			if (acm)
 				local->wmm_acm |= BIT(1) | BIT(2);
 			break;
 		}
 		params.aifs = pos[0] & 0x0f;
 		params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
 		params.cw_min = ecw2cw(pos[1] & 0x0f);
 		params.txop = get_unaligned_le16(pos + 2);
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 		printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d "
 		       "cWmin=%d cWmax=%d txop=%d\n",
 		       local->mdev->name, queue, aci, acm, params.aifs, params.cw_min,
 		       params.cw_max, params.txop);
 #endif
 		/* TODO: handle ACM (block TX, fallback to next lowest allowed
 		 * AC for now) */
 		if (local->ops->conf_tx(local_to_hw(local), queue, &params)) {
 			printk(KERN_DEBUG "%s: failed to set TX queue "
 			       "parameters for queue %d\n", local->mdev->name, queue);
 		}
 	}
 }
 static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
 					   u16 capab, bool erp_valid, u8 erp)
 {
 	struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 	struct ieee80211_if_sta *ifsta = &sdata->u.sta;
 #endif
 	u32 changed = 0;
 	bool use_protection;
 	bool use_short_preamble;
 	bool use_short_slot;
 	if (erp_valid) {
 		use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
 		use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
 	} else {
 		use_protection = false;
 		use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
 	}
 	use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
 	if (use_protection != bss_conf->use_cts_prot) {
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 		if (net_ratelimit()) {
 			printk(KERN_DEBUG "%s: CTS protection %s (BSSID=%pM)\n",
 			       sdata->dev->name,
 			       use_protection ? "enabled" : "disabled",
 			       ifsta->bssid);
 		}
 #endif
 		bss_conf->use_cts_prot = use_protection;
 		changed |= BSS_CHANGED_ERP_CTS_PROT;
 	}
 	if (use_short_preamble != bss_conf->use_short_preamble) {
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 		if (net_ratelimit()) {
 			printk(KERN_DEBUG "%s: switched to %s barker preamble"
 			       " (BSSID=%pM)\n",
 			       sdata->dev->name,
 			       use_short_preamble ? "short" : "long",
 			       ifsta->bssid);
 		}
 #endif
 		bss_conf->use_short_preamble = use_short_preamble;
 		changed |= BSS_CHANGED_ERP_PREAMBLE;
 	}
 	if (use_short_slot != bss_conf->use_short_slot) {
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 		if (net_ratelimit()) {
 			printk(KERN_DEBUG "%s: switched to %s slot"
 			       " (BSSID=%s)\n",
 			       sdata->dev->name,
 			       use_short_slot ? "short" : "long",
 			       ifsta->bssid);
 		}
 #endif
 		bss_conf->use_short_slot = use_short_slot;
 		changed |= BSS_CHANGED_ERP_SLOT;
 	}
 	return changed;
 }
 static void ieee80211_sta_send_apinfo(struct ieee80211_sub_if_data *sdata,
 					struct ieee80211_if_sta *ifsta)
 {
 	union iwreq_data wrqu;
 	memset(&wrqu, 0, sizeof(wrqu));
 	if (ifsta->flags & IEEE80211_STA_ASSOCIATED)
 		memcpy(wrqu.ap_addr.sa_data, sdata->u.sta.bssid, ETH_ALEN);
 	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
 	wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL);
 }
 static void ieee80211_sta_send_associnfo(struct ieee80211_sub_if_data *sdata,
 					 struct ieee80211_if_sta *ifsta)
 {
 	char *buf;
 	size_t len;
 	int i;
 	union iwreq_data wrqu;
 	if (!ifsta->assocreq_ies && !ifsta->assocresp_ies)
 		return;
 	buf = kmalloc(50 + 2 * (ifsta->assocreq_ies_len +
 				ifsta->assocresp_ies_len), GFP_KERNEL);
 	if (!buf)
 		return;
 	len = sprintf(buf, "ASSOCINFO(");
 	if (ifsta->assocreq_ies) {
 		len += sprintf(buf + len, "ReqIEs=");
 		for (i = 0; i < ifsta->assocreq_ies_len; i++) {
 			len += sprintf(buf + len, "%02x",
 				       ifsta->assocreq_ies[i]);
 		}
 	}
 	if (ifsta->assocresp_ies) {
 		if (ifsta->assocreq_ies)
 			len += sprintf(buf + len, " ");
 		len += sprintf(buf + len, "RespIEs=");
 		for (i = 0; i < ifsta->assocresp_ies_len; i++) {
 			len += sprintf(buf + len, "%02x",
 				       ifsta->assocresp_ies[i]);
 		}
 	}
 	len += sprintf(buf + len, ")");
 	if (len > IW_CUSTOM_MAX) {
 		len = sprintf(buf, "ASSOCRESPIE=");
 		for (i = 0; i < ifsta->assocresp_ies_len; i++) {
 			len += sprintf(buf + len, "%02x",
 				       ifsta->assocresp_ies[i]);
 		}
 	}
 	if (len <= IW_CUSTOM_MAX) {
 		memset(&wrqu, 0, sizeof(wrqu));
 		wrqu.data.length = len;
 		wireless_send_event(sdata->dev, IWEVCUSTOM, &wrqu, buf);
 	}
 	kfree(buf);
 }
 static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_if_sta *ifsta,
 				     u32 bss_info_changed)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_conf *conf = &local_to_hw(local)->conf;
 	struct ieee80211_bss *bss;
 	bss_info_changed |= BSS_CHANGED_ASSOC;
 	ifsta->flags |= IEEE80211_STA_ASSOCIATED;
 	if (sdata->vif.type != NL80211_IFTYPE_STATION)
 		return;
 	bss = ieee80211_rx_bss_get(local, ifsta->bssid,
 				   conf->channel->center_freq,
 				   ifsta->ssid, ifsta->ssid_len);
 	if (bss) {
 		/* set timing information */
 		sdata->vif.bss_conf.beacon_int = bss->beacon_int;
 		sdata->vif.bss_conf.timestamp = bss->timestamp;
 		sdata->vif.bss_conf.dtim_period = bss->dtim_period;
 		bss_info_changed |= ieee80211_handle_bss_capability(sdata,
 			bss->capability, bss->has_erp_value, bss->erp_value);
 		ieee80211_rx_bss_put(local, bss);
 	}
 	ifsta->flags |= IEEE80211_STA_PREV_BSSID_SET;
 	memcpy(ifsta->prev_bssid, sdata->u.sta.bssid, ETH_ALEN);
 	ieee80211_sta_send_associnfo(sdata, ifsta);
 	ifsta->last_probe = jiffies;
 	ieee80211_led_assoc(local, 1);
 	sdata->vif.bss_conf.assoc = 1;
 	/*
 	 * For now just always ask the driver to update the basic rateset
 	 * when we have associated, we aren't checking whether it actually
 	 * changed or not.
 	 */
 	bss_info_changed |= BSS_CHANGED_BASIC_RATES;
 	ieee80211_bss_info_change_notify(sdata, bss_info_changed);
 	netif_tx_start_all_queues(sdata->dev);
 	netif_carrier_on(sdata->dev);
 	ieee80211_sta_send_apinfo(sdata, ifsta);
 }
 static void ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata,
 				   struct ieee80211_if_sta *ifsta)
 {
 	ifsta->direct_probe_tries++;
 	if (ifsta->direct_probe_tries > IEEE80211_AUTH_MAX_TRIES) {
 		printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",
 		       sdata->dev->name, ifsta->bssid);
 		ifsta->state = IEEE80211_STA_MLME_DISABLED;
 		ieee80211_sta_send_apinfo(sdata, ifsta);
 		return;
 	}
 	printk(KERN_DEBUG "%s: direct probe to AP %pM try %d\n",
 			sdata->dev->name, ifsta->bssid,
 			ifsta->direct_probe_tries);
 	ifsta->state = IEEE80211_STA_MLME_DIRECT_PROBE;
 	set_bit(IEEE80211_STA_REQ_DIRECT_PROBE, &ifsta->request);
 	/* Direct probe is sent to broadcast address as some APs
 	 * will not answer to direct packet in unassociated state.
 	 */
 	ieee80211_send_probe_req(sdata, NULL,
 				 ifsta->ssid, ifsta->ssid_len);
 	mod_timer(&ifsta->timer, jiffies + IEEE80211_AUTH_TIMEOUT);
 }
 static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata,
 				   struct ieee80211_if_sta *ifsta)
 {
 	ifsta->auth_tries++;
 	if (ifsta->auth_tries > IEEE80211_AUTH_MAX_TRIES) {
 		printk(KERN_DEBUG "%s: authentication with AP %pM"
 		       " timed out\n",
 		       sdata->dev->name, ifsta->bssid);
 		ifsta->state = IEEE80211_STA_MLME_DISABLED;
 		ieee80211_sta_send_apinfo(sdata, ifsta);
 		return;
 	}
 	ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE;
 	printk(KERN_DEBUG "%s: authenticate with AP %pM\n",
 	       sdata->dev->name, ifsta->bssid);
 	ieee80211_send_auth(sdata, ifsta, 1, NULL, 0, 0);
 	mod_timer(&ifsta->timer, jiffies + IEEE80211_AUTH_TIMEOUT);
 }
 /*
  * The disassoc 'reason' argument can be either our own reason
  * if self disconnected or a reason code from the AP.
  */
 static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
 				   struct ieee80211_if_sta *ifsta, bool deauth,
 				   bool self_disconnected, u16 reason)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct sta_info *sta;
 	u32 changed = 0;
 	rcu_read_lock();
 	sta = sta_info_get(local, ifsta->bssid);
 	if (!sta) {
 		rcu_read_unlock();
 		return;
 	}
 	if (deauth) {
 		ifsta->direct_probe_tries = 0;
 		ifsta->auth_tries = 0;
 	}
 	ifsta->assoc_scan_tries = 0;
 	ifsta->assoc_tries = 0;
 	netif_tx_stop_all_queues(sdata->dev);
 	netif_carrier_off(sdata->dev);
 	ieee80211_sta_tear_down_BA_sessions(sdata, sta->sta.addr);
 	if (self_disconnected) {
 		if (deauth)
 			ieee80211_send_deauth_disassoc(sdata,
 				IEEE80211_STYPE_DEAUTH, reason);
 		else
 			ieee80211_send_deauth_disassoc(sdata,
 				IEEE80211_STYPE_DISASSOC, reason);
 	}
 	ifsta->flags &= ~IEEE80211_STA_ASSOCIATED;
 	changed |= ieee80211_reset_erp_info(sdata);
 	ieee80211_led_assoc(local, 0);
 	changed |= BSS_CHANGED_ASSOC;
 	sdata->vif.bss_conf.assoc = false;
 	ieee80211_sta_send_apinfo(sdata, ifsta);
 	if (self_disconnected || reason == WLAN_REASON_DISASSOC_STA_HAS_LEFT)
 		ifsta->state = IEEE80211_STA_MLME_DISABLED;
 	rcu_read_unlock();
 	local->hw.conf.ht.enabled = false;
+	local->oper_channel_type = NL80211_CHAN_NO_HT;
 	ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_HT);
 	ieee80211_bss_info_change_notify(sdata, changed);
 	rcu_read_lock();
 	sta = sta_info_get(local, ifsta->bssid);
 	if (!sta) {
 		rcu_read_unlock();
 		return;
 	}
 	sta_info_unlink(&sta);
 	rcu_read_unlock();
 	sta_info_destroy(sta);
 }
 static int ieee80211_sta_wep_configured(struct ieee80211_sub_if_data *sdata)
 {
 	if (!sdata || !sdata->default_key ||
 	    sdata->default_key->conf.alg != ALG_WEP)
 		return 0;
 	return 1;
 }
 static int ieee80211_privacy_mismatch(struct ieee80211_sub_if_data *sdata,
 				      struct ieee80211_if_sta *ifsta)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_bss *bss;
 	int bss_privacy;
 	int wep_privacy;
 	int privacy_invoked;
 	if (!ifsta || (ifsta->flags & IEEE80211_STA_MIXED_CELL))
 		return 0;
 	bss = ieee80211_rx_bss_get(local, ifsta->bssid,
 				   local->hw.conf.channel->center_freq,
 				   ifsta->ssid, ifsta->ssid_len);
 	if (!bss)
 		return 0;
 	bss_privacy = !!(bss->capability & WLAN_CAPABILITY_PRIVACY);
 	wep_privacy = !!ieee80211_sta_wep_configured(sdata);
 	privacy_invoked = !!(ifsta->flags & IEEE80211_STA_PRIVACY_INVOKED);
 	ieee80211_rx_bss_put(local, bss);
 	if ((bss_privacy == wep_privacy) || (bss_privacy == privacy_invoked))
 		return 0;
 	return 1;
 }
 static void ieee80211_associate(struct ieee80211_sub_if_data *sdata,
 				struct ieee80211_if_sta *ifsta)
 {
 	ifsta->assoc_tries++;
 	if (ifsta->assoc_tries > IEEE80211_ASSOC_MAX_TRIES) {
 		printk(KERN_DEBUG "%s: association with AP %pM"
 		       " timed out\n",
 		       sdata->dev->name, ifsta->bssid);
 		ifsta->state = IEEE80211_STA_MLME_DISABLED;
 		ieee80211_sta_send_apinfo(sdata, ifsta);
 		return;
 	}
 	ifsta->state = IEEE80211_STA_MLME_ASSOCIATE;
 	printk(KERN_DEBUG "%s: associate with AP %pM\n",
 	       sdata->dev->name, ifsta->bssid);
 	if (ieee80211_privacy_mismatch(sdata, ifsta)) {
 		printk(KERN_DEBUG "%s: mismatch in privacy configuration and "
 		       "mixed-cell disabled - abort association\n", sdata->dev->name);
 		ifsta->state = IEEE80211_STA_MLME_DISABLED;
 		return;
 	}
 	ieee80211_send_assoc(sdata, ifsta);
 	mod_timer(&ifsta->timer, jiffies + IEEE80211_ASSOC_TIMEOUT);
 }
 static void ieee80211_associated(struct ieee80211_sub_if_data *sdata,
 				 struct ieee80211_if_sta *ifsta)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct sta_info *sta;
 	int disassoc;
 	/* TODO: start monitoring current AP signal quality and number of
 	 * missed beacons. Scan other channels every now and then and search
 	 * for better APs. */
 	/* TODO: remove expired BSSes */
 	ifsta->state = IEEE80211_STA_MLME_ASSOCIATED;
 	rcu_read_lock();
 	sta = sta_info_get(local, ifsta->bssid);
 	if (!sta) {
 		printk(KERN_DEBUG "%s: No STA entry for own AP %pM\n",
 		       sdata->dev->name, ifsta->bssid);
 		disassoc = 1;
 	} else {
 		disassoc = 0;
 		if (time_after(jiffies,
 			       sta->last_rx + IEEE80211_MONITORING_INTERVAL)) {
 			if (ifsta->flags & IEEE80211_STA_PROBEREQ_POLL) {
 				printk(KERN_DEBUG "%s: No ProbeResp from "
 				       "current AP %pM - assume out of "
 				       "range\n",
 				       sdata->dev->name, ifsta->bssid);
 				disassoc = 1;
 			} else
 				ieee80211_send_probe_req(sdata, ifsta->bssid,
 							 ifsta->ssid,
 							 ifsta->ssid_len);
 			ifsta->flags ^= IEEE80211_STA_PROBEREQ_POLL;
 		} else {
 			ifsta->flags &= ~IEEE80211_STA_PROBEREQ_POLL;
 			if (time_after(jiffies, ifsta->last_probe +
 				       IEEE80211_PROBE_INTERVAL)) {
 				ifsta->last_probe = jiffies;
 				ieee80211_send_probe_req(sdata, ifsta->bssid,
 							 ifsta->ssid,
 							 ifsta->ssid_len);
 			}
 		}
 	}
 	rcu_read_unlock();
 	if (disassoc)
 		ieee80211_set_disassoc(sdata, ifsta, true, true,
 					WLAN_REASON_PREV_AUTH_NOT_VALID);
 	else
 		mod_timer(&ifsta->timer, jiffies +
 				      IEEE80211_MONITORING_INTERVAL);
 }
 static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_if_sta *ifsta)
 {
 	printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name);
 	ifsta->flags |= IEEE80211_STA_AUTHENTICATED;
 	ieee80211_associate(sdata, ifsta);
 }
 static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_if_sta *ifsta,
 				     struct ieee80211_mgmt *mgmt,
 				     size_t len)
 {
 	u8 *pos;
 	struct ieee802_11_elems elems;
 	pos = mgmt->u.auth.variable;
 	ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
 	if (!elems.challenge)
 		return;
 	ieee80211_send_auth(sdata, ifsta, 3, elems.challenge - 2,
 			    elems.challenge_len + 2, 1);
 }
 static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
 				   struct ieee80211_if_sta *ifsta,
 				   struct ieee80211_mgmt *mgmt,
 				   size_t len)
 {
 	u16 auth_alg, auth_transaction, status_code;
 	if (ifsta->state != IEEE80211_STA_MLME_AUTHENTICATE &&
 	    sdata->vif.type != NL80211_IFTYPE_ADHOC)
 		return;
 	if (len < 24 + 6)
 		return;
 	if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
 	    memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN) != 0)
 		return;
 	if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
 	    memcmp(ifsta->bssid, mgmt->bssid, ETH_ALEN) != 0)
 		return;
 	auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
 	auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
 	status_code = le16_to_cpu(mgmt->u.auth.status_code);
 	if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
 		/*
 		 * IEEE 802.11 standard does not require authentication in IBSS
 		 * networks and most implementations do not seem to use it.
 		 * However, try to reply to authentication attempts if someone
 		 * has actually implemented this.
 		 */
 		if (auth_alg != WLAN_AUTH_OPEN || auth_transaction != 1)
 			return;
 		ieee80211_send_auth(sdata, ifsta, 2, NULL, 0, 0);
 	}
 	if (auth_alg != ifsta->auth_alg ||
 	    auth_transaction != ifsta->auth_transaction)
 		return;
 	if (status_code != WLAN_STATUS_SUCCESS) {
 		if (status_code == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG) {
 			u8 algs[3];
 			const int num_algs = ARRAY_SIZE(algs);
 			int i, pos;
 			algs[0] = algs[1] = algs[2] = 0xff;
 			if (ifsta->auth_algs & IEEE80211_AUTH_ALG_OPEN)
 				algs[0] = WLAN_AUTH_OPEN;
 			if (ifsta->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY)
 				algs[1] = WLAN_AUTH_SHARED_KEY;
 			if (ifsta->auth_algs & IEEE80211_AUTH_ALG_LEAP)
 				algs[2] = WLAN_AUTH_LEAP;
 			if (ifsta->auth_alg == WLAN_AUTH_OPEN)
 				pos = 0;
 			else if (ifsta->auth_alg == WLAN_AUTH_SHARED_KEY)
 				pos = 1;
 			else
 				pos = 2;
 			for (i = 0; i < num_algs; i++) {
 				pos++;
 				if (pos >= num_algs)
 					pos = 0;
 				if (algs[pos] == ifsta->auth_alg ||
 				    algs[pos] == 0xff)
 					continue;
 				if (algs[pos] == WLAN_AUTH_SHARED_KEY &&
 				    !ieee80211_sta_wep_configured(sdata))
 					continue;
 				ifsta->auth_alg = algs[pos];
 				break;
 			}
 		}
 		return;
 	}
 	switch (ifsta->auth_alg) {
 	case WLAN_AUTH_OPEN:
 	case WLAN_AUTH_LEAP:
 		ieee80211_auth_completed(sdata, ifsta);
 		break;
 	case WLAN_AUTH_SHARED_KEY:
 		if (ifsta->auth_transaction == 4)
 			ieee80211_auth_completed(sdata, ifsta);
 		else
 			ieee80211_auth_challenge(sdata, ifsta, mgmt, len);
 		break;
 	}
 }
 static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_if_sta *ifsta,
 				     struct ieee80211_mgmt *mgmt,
 				     size_t len)
 {
 	u16 reason_code;
 	if (len < 24 + 2)
 		return;
 	if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN))
 		return;
 	reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
 	if (ifsta->flags & IEEE80211_STA_AUTHENTICATED)
 		printk(KERN_DEBUG "%s: deauthenticated (Reason: %u)\n",
 				sdata->dev->name, reason_code);
 	if (ifsta->state == IEEE80211_STA_MLME_AUTHENTICATE ||
 	    ifsta->state == IEEE80211_STA_MLME_ASSOCIATE ||
 	    ifsta->state == IEEE80211_STA_MLME_ASSOCIATED) {
 		ifsta->state = IEEE80211_STA_MLME_DIRECT_PROBE;
 		mod_timer(&ifsta->timer, jiffies +
 				      IEEE80211_RETRY_AUTH_INTERVAL);
 	}
 	ieee80211_set_disassoc(sdata, ifsta, true, false, 0);
 	ifsta->flags &= ~IEEE80211_STA_AUTHENTICATED;
 }
 static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
 				       struct ieee80211_if_sta *ifsta,
 				       struct ieee80211_mgmt *mgmt,
 				       size_t len)
 {
 	u16 reason_code;
 	if (len < 24 + 2)
 		return;
 	if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN))
 		return;
 	reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
 	if (ifsta->flags & IEEE80211_STA_ASSOCIATED)
 		printk(KERN_DEBUG "%s: disassociated (Reason: %u)\n",
 				sdata->dev->name, reason_code);
 	if (ifsta->state == IEEE80211_STA_MLME_ASSOCIATED) {
 		ifsta->state = IEEE80211_STA_MLME_ASSOCIATE;
 		mod_timer(&ifsta->timer, jiffies +
 				      IEEE80211_RETRY_AUTH_INTERVAL);
 	}
 	ieee80211_set_disassoc(sdata, ifsta, false, false, reason_code);
 }
 static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
 					 struct ieee80211_if_sta *ifsta,
 					 struct ieee80211_mgmt *mgmt,
 					 size_t len,
 					 int reassoc)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_supported_band *sband;
 	struct sta_info *sta;
 	u64 rates, basic_rates;
 	u16 capab_info, status_code, aid;
 	struct ieee802_11_elems elems;
 	struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
 	u8 *pos;
 	u32 changed = 0;
 	int i, j;
 	bool have_higher_than_11mbit = false, newsta = false;
 	u16 ap_ht_cap_flags;
 	/* AssocResp and ReassocResp have identical structure, so process both
 	 * of them in this function. */
 	if (ifsta->state != IEEE80211_STA_MLME_ASSOCIATE)
 		return;
 	if (len < 24 + 6)
 		return;
 	if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN) != 0)
 		return;
 	capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
 	status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
 	aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
 	printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "
 	       "status=%d aid=%d)\n",
 	       sdata->dev->name, reassoc ? "Rea" : "A", mgmt->sa,
 	       capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
 	if (status_code != WLAN_STATUS_SUCCESS) {
 		printk(KERN_DEBUG "%s: AP denied association (code=%d)\n",
 		       sdata->dev->name, status_code);
 		/* if this was a reassociation, ensure we try a "full"
 		 * association next time. This works around some broken APs
 		 * which do not correctly reject reassociation requests. */
 		ifsta->flags &= ~IEEE80211_STA_PREV_BSSID_SET;
 		return;
 	}
 	if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
 		printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not "
 		       "set\n", sdata->dev->name, aid);
 	aid &= ~(BIT(15) | BIT(14));
 	pos = mgmt->u.assoc_resp.variable;
 	ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
 	if (!elems.supp_rates) {
 		printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",
 		       sdata->dev->name);
 		return;
 	}
 	printk(KERN_DEBUG "%s: associated\n", sdata->dev->name);
 	ifsta->aid = aid;
 	ifsta->ap_capab = capab_info;
 	kfree(ifsta->assocresp_ies);
 	ifsta->assocresp_ies_len = len - (pos - (u8 *) mgmt);
 	ifsta->assocresp_ies = kmalloc(ifsta->assocresp_ies_len, GFP_KERNEL);
 	if (ifsta->assocresp_ies)
 		memcpy(ifsta->assocresp_ies, pos, ifsta->assocresp_ies_len);
 	rcu_read_lock();
 	/* Add STA entry for the AP */
 	sta = sta_info_get(local, ifsta->bssid);
 	if (!sta) {
 		struct ieee80211_bss *bss;
 		newsta = true;
 		sta = sta_info_alloc(sdata, ifsta->bssid, GFP_ATOMIC);
 		if (!sta) {
 			printk(KERN_DEBUG "%s: failed to alloc STA entry for"
 			       " the AP\n", sdata->dev->name);
 			rcu_read_unlock();
 			return;
 		}
 		bss = ieee80211_rx_bss_get(local, ifsta->bssid,
 					   local->hw.conf.channel->center_freq,
 					   ifsta->ssid, ifsta->ssid_len);
 		if (bss) {
 			sta->last_signal = bss->signal;
 			sta->last_qual = bss->qual;
 			sta->last_noise = bss->noise;
 			ieee80211_rx_bss_put(local, bss);
 		}
 		/* update new sta with its last rx activity */
 		sta->last_rx = jiffies;
 	}
 	/*
 	 * FIXME: Do we really need to update the sta_info's information here?
 	 *	  We already know about the AP (we found it in our list) so it
 	 *	  should already be filled with the right info, no?
 	 *	  As is stands, all this is racy because typically we assume
 	 *	  the information that is filled in here (except flags) doesn't
 	 *	  change while a STA structure is alive. As such, it should move
 	 *	  to between the sta_info_alloc() and sta_info_insert() above.
 	 */
 	set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC | WLAN_STA_ASSOC_AP |
 			   WLAN_STA_AUTHORIZED);
 	rates = 0;
 	basic_rates = 0;
 	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 	for (i = 0; i < elems.supp_rates_len; i++) {
 		int rate = (elems.supp_rates[i] & 0x7f) * 5;
 		bool is_basic = !!(elems.supp_rates[i] & 0x80);
 		if (rate > 110)
 			have_higher_than_11mbit = true;
 		for (j = 0; j < sband->n_bitrates; j++) {
 			if (sband->bitrates[j].bitrate == rate) {
 				rates |= BIT(j);
 				if (is_basic)
 					basic_rates |= BIT(j);
 				break;
 			}
 		}
 	}
 	for (i = 0; i < elems.ext_supp_rates_len; i++) {
 		int rate = (elems.ext_supp_rates[i] & 0x7f) * 5;
 		bool is_basic = !!(elems.supp_rates[i] & 0x80);
 		if (rate > 110)
 			have_higher_than_11mbit = true;
 		for (j = 0; j < sband->n_bitrates; j++) {
 			if (sband->bitrates[j].bitrate == rate) {
 				rates |= BIT(j);
 				if (is_basic)
 					basic_rates |= BIT(j);
 				break;
 			}
 		}
 	}
 	sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
 	sdata->vif.bss_conf.basic_rates = basic_rates;
 	/* cf. IEEE 802.11 9.2.12 */
 	if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
 	    have_higher_than_11mbit)
 		sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
 	else
 		sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
 	if (elems.ht_cap_elem)
 		ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
 				elems.ht_cap_elem, &sta->sta.ht_cap);
 	ap_ht_cap_flags = sta->sta.ht_cap.cap;
 	rate_control_rate_init(sta);
 	if (elems.wmm_param)
 		set_sta_flags(sta, WLAN_STA_WME);
 	if (newsta) {
 		int err = sta_info_insert(sta);
 		if (err) {
 			printk(KERN_DEBUG "%s: failed to insert STA entry for"
 			       " the AP (error %d)\n", sdata->dev->name, err);
 			rcu_read_unlock();
 			return;
 		}
 	}
 	rcu_read_unlock();
 	if (elems.wmm_param)
 		ieee80211_sta_wmm_params(local, ifsta, elems.wmm_param,
 					 elems.wmm_param_len);
 	if (elems.ht_info_elem && elems.wmm_param &&
 	    (ifsta->flags & IEEE80211_STA_WMM_ENABLED))
 		changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
 					       ap_ht_cap_flags);
 	/* set AID and assoc capability,
 	 * ieee80211_set_associated() will tell the driver */
 	bss_conf->aid = aid;
 	bss_conf->assoc_capability = capab_info;
 	ieee80211_set_associated(sdata, ifsta, changed);
 	ieee80211_associated(sdata, ifsta);
 }
 static int ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
 				   struct ieee80211_if_sta *ifsta,
 				   struct ieee80211_bss *bss)
 {
 	struct ieee80211_local *local = sdata->local;
 	int res, rates, i, j;
 	struct sk_buff *skb;
 	struct ieee80211_mgmt *mgmt;
 	u8 *pos;
 	struct ieee80211_supported_band *sband;
 	union iwreq_data wrqu;
 	skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
 	if (!skb) {
 		printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
 		       "response\n", sdata->dev->name);
 		return -ENOMEM;
 	}
 	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 	/* Remove possible STA entries from other IBSS networks. */
 	sta_info_flush_delayed(sdata);
 	if (local->ops->reset_tsf) {
 		/* Reset own TSF to allow time synchronization work. */
 		local->ops->reset_tsf(local_to_hw(local));
 	}
 	memcpy(ifsta->bssid, bss->bssid, ETH_ALEN);
 	res = ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID);
 	if (res)
 		return res;
 	local->hw.conf.beacon_int = bss->beacon_int >= 10 ? bss->beacon_int : 10;
 	sdata->drop_unencrypted = bss->capability &
 		WLAN_CAPABILITY_PRIVACY ? 1 : 0;
 	res = ieee80211_set_freq(sdata, bss->freq);
 	if (res)
 		return res;
 	/* Build IBSS probe response */
 	skb_reserve(skb, local->hw.extra_tx_headroom);
 	mgmt = (struct ieee80211_mgmt *)
 		skb_put(skb, 24 + sizeof(mgmt->u.beacon));
 	memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon));
 	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 						IEEE80211_STYPE_PROBE_RESP);
 	memset(mgmt->da, 0xff, ETH_ALEN);
 	memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
 	memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
 	mgmt->u.beacon.beacon_int =
 		cpu_to_le16(local->hw.conf.beacon_int);
 	mgmt->u.beacon.timestamp = cpu_to_le64(bss->timestamp);
 	mgmt->u.beacon.capab_info = cpu_to_le16(bss->capability);
 	pos = skb_put(skb, 2 + ifsta->ssid_len);
 	*pos++ = WLAN_EID_SSID;
 	*pos++ = ifsta->ssid_len;
 	memcpy(pos, ifsta->ssid, ifsta->ssid_len);
 	rates = bss->supp_rates_len;
 	if (rates > 8)
 		rates = 8;
 	pos = skb_put(skb, 2 + rates);
 	*pos++ = WLAN_EID_SUPP_RATES;
 	*pos++ = rates;
 	memcpy(pos, bss->supp_rates, rates);
 	if (bss->band == IEEE80211_BAND_2GHZ) {
 		pos = skb_put(skb, 2 + 1);
 		*pos++ = WLAN_EID_DS_PARAMS;
 		*pos++ = 1;
 		*pos++ = ieee80211_frequency_to_channel(bss->freq);
 	}
 	pos = skb_put(skb, 2 + 2);
 	*pos++ = WLAN_EID_IBSS_PARAMS;
 	*pos++ = 2;
 	/* FIX: set ATIM window based on scan results */
 	*pos++ = 0;
 	*pos++ = 0;
 	if (bss->supp_rates_len > 8) {
 		rates = bss->supp_rates_len - 8;
 		pos = skb_put(skb, 2 + rates);
 		*pos++ = WLAN_EID_EXT_SUPP_RATES;
 		*pos++ = rates;
 		memcpy(pos, &bss->supp_rates[8], rates);
 	}
 	ifsta->probe_resp = skb;
 	ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON);
 	rates = 0;
 	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 	for (i = 0; i < bss->supp_rates_len; i++) {
 		int bitrate = (bss->supp_rates[i] & 0x7f) * 5;
 		for (j = 0; j < sband->n_bitrates; j++)
 			if (sband->bitrates[j].bitrate == bitrate)
 				rates |= BIT(j);
 	}
 	ifsta->supp_rates_bits[local->hw.conf.channel->band] = rates;
 	ieee80211_sta_def_wmm_params(sdata, bss);
 	ifsta->state = IEEE80211_STA_MLME_IBSS_JOINED;
 	mod_timer(&ifsta->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
 	ieee80211_led_assoc(local, true);
 	memset(&wrqu, 0, sizeof(wrqu));
 	memcpy(wrqu.ap_addr.sa_data, bss->bssid, ETH_ALEN);
 	wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL);
 	return res;
 }
 static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
 				  struct ieee80211_mgmt *mgmt,
 				  size_t len,
 				  struct ieee80211_rx_status *rx_status,
 				  struct ieee802_11_elems *elems,
 				  bool beacon)
 {
 	struct ieee80211_local *local = sdata->local;
 	int freq;
 	struct ieee80211_bss *bss;
 	struct sta_info *sta;
 	struct ieee80211_channel *channel;
 	u64 beacon_timestamp, rx_timestamp;
 	u64 supp_rates = 0;
 	enum ieee80211_band band = rx_status->band;
 	if (elems->ds_params && elems->ds_params_len == 1)
 		freq = ieee80211_channel_to_frequency(elems->ds_params[0]);
 	else
 		freq = rx_status->freq;
 	channel = ieee80211_get_channel(local->hw.wiphy, freq);
 	if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
 		return;
 	if (sdata->vif.type == NL80211_IFTYPE_ADHOC && elems->supp_rates &&
 	    memcmp(mgmt->bssid, sdata->u.sta.bssid, ETH_ALEN) == 0) {
 		supp_rates = ieee80211_sta_get_rates(local, elems, band);
 		rcu_read_lock();
 		sta = sta_info_get(local, mgmt->sa);
 		if (sta) {
 			u64 prev_rates;
 			prev_rates = sta->sta.supp_rates[band];
 			/* make sure mandatory rates are always added */
 			sta->sta.supp_rates[band] = supp_rates |
 				ieee80211_mandatory_rates(local, band);
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
 			if (sta->sta.supp_rates[band] != prev_rates)
 				printk(KERN_DEBUG "%s: updated supp_rates set "
 				    "for %pM based on beacon info (0x%llx | "
 				    "0x%llx -> 0x%llx)\n",
 				    sdata->dev->name,
 				    sta->sta.addr,
 				    (unsigned long long) prev_rates,
 				    (unsigned long long) supp_rates,
 				    (unsigned long long) sta->sta.supp_rates[band]);
 #endif
 		} else {
 			ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa, supp_rates);
 		}
 		rcu_read_unlock();
 	}
 	bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
 					freq, beacon);
 	if (!bss)
 		return;
 	/* was just updated in ieee80211_bss_info_update */
 	beacon_timestamp = bss->timestamp;
 	/*
 	 * In STA mode, the remaining parameters should not be overridden
 	 * by beacons because they're not necessarily accurate there.
 	 */
 	if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
 	    bss->last_probe_resp && beacon) {
 		ieee80211_rx_bss_put(local, bss);
 		return;
 	}
 	/* check if we need to merge IBSS */
 	if (sdata->vif.type == NL80211_IFTYPE_ADHOC && beacon &&
 	    bss->capability & WLAN_CAPABILITY_IBSS &&
 	    bss->freq == local->oper_channel->center_freq &&
 	    elems->ssid_len == sdata->u.sta.ssid_len &&
 	    memcmp(elems->ssid, sdata->u.sta.ssid,
 				sdata->u.sta.ssid_len) == 0) {
 		if (rx_status->flag & RX_FLAG_TSFT) {
 			/* in order for correct IBSS merging we need mactime
 			 *
 			 * since mactime is defined as the time the first data
 			 * symbol of the frame hits the PHY, and the timestamp
 			 * of the beacon is defined as "the time that the data
 			 * symbol containing the first bit of the timestamp is
 			 * transmitted to the PHY plus the transmitting STA’s
 			 * delays through its local PHY from the MAC-PHY
 			 * interface to its interface with the WM"
 			 * (802.11 11.1.2) - equals the time this bit arrives at
 			 * the receiver - we have to take into account the
 			 * offset between the two.
 			 * e.g: at 1 MBit that means mactime is 192 usec earlier
 			 * (=24 bytes * 8 usecs/byte) than the beacon timestamp.
 			 */
 			int rate = local->hw.wiphy->bands[band]->
 					bitrates[rx_status->rate_idx].bitrate;
 			rx_timestamp = rx_status->mactime + (24 * 8 * 10 / rate);
 		} else if (local && local->ops && local->ops->get_tsf)
 			/* second best option: get current TSF */
 			rx_timestamp = local->ops->get_tsf(local_to_hw(local));
 		else
 			/* can't merge without knowing the TSF */
 			rx_timestamp = -1LLU;
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
 		printk(KERN_DEBUG "RX beacon SA=%pM BSSID="
 		       "%pM TSF=0x%llx BCN=0x%llx diff=%lld @%lu\n",
 		       mgmt->sa, mgmt->bssid,
 		       (unsigned long long)rx_timestamp,
 		       (unsigned long long)beacon_timestamp,
 		       (unsigned long long)(rx_timestamp - beacon_timestamp),
 		       jiffies);
 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
 		if (beacon_timestamp > rx_timestamp) {
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
 			printk(KERN_DEBUG "%s: beacon TSF higher than "
 			       "local TSF - IBSS merge with BSSID %pM\n",
 			       sdata->dev->name, mgmt->bssid);
 #endif
 			ieee80211_sta_join_ibss(sdata, &sdata->u.sta, bss);
 			ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa, supp_rates);
 		}
 	}
 	ieee80211_rx_bss_put(local, bss);
 }
 static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
 					 struct ieee80211_mgmt *mgmt,
 					 size_t len,
 					 struct ieee80211_rx_status *rx_status)
 {
 	size_t baselen;
 	struct ieee802_11_elems elems;
 	struct ieee80211_if_sta *ifsta = &sdata->u.sta;
 	if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
 		return; /* ignore ProbeResp to foreign address */
 	baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
 	if (baselen > len)
 		return;
 	ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
 				&elems);
 	ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
 	/* direct probe may be part of the association flow */
 	if (test_and_clear_bit(IEEE80211_STA_REQ_DIRECT_PROBE,
 							&ifsta->request)) {
 		printk(KERN_DEBUG "%s direct probe responded\n",
 		       sdata->dev->name);
 		ieee80211_authenticate(sdata, ifsta);
 	}
 }
 static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_mgmt *mgmt,
 				     size_t len,
 				     struct ieee80211_rx_status *rx_status)
 {
 	struct ieee80211_if_sta *ifsta;
 	size_t baselen;
 	struct ieee802_11_elems elems;
 	struct ieee80211_local *local = sdata->local;
 	u32 changed = 0;
 	bool erp_valid;
 	u8 erp_value = 0;
 	/* Process beacon from the current BSS */
 	baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
 	if (baselen > len)
 		return;
 	ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen, &elems);
 	ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, true);
 	if (sdata->vif.type != NL80211_IFTYPE_STATION)
 		return;
 	ifsta = &sdata->u.sta;
 	if (!(ifsta->flags & IEEE80211_STA_ASSOCIATED) ||
 	    memcmp(ifsta->bssid, mgmt->bssid, ETH_ALEN) != 0)
 		return;
 	ieee80211_sta_wmm_params(local, ifsta, elems.wmm_param,
 				 elems.wmm_param_len);
 	if (elems.erp_info && elems.erp_info_len >= 1) {
 		erp_valid = true;
 		erp_value = elems.erp_info[0];
 	} else {
 		erp_valid = false;
 	}
 	changed |= ieee80211_handle_bss_capability(sdata,
 			le16_to_cpu(mgmt->u.beacon.capab_info),
 			erp_valid, erp_value);
 	if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param) {
 		struct sta_info *sta;
 		struct ieee80211_supported_band *sband;
 		u16 ap_ht_cap_flags;
 		rcu_read_lock();
 		sta = sta_info_get(local, ifsta->bssid);
 		if (!sta) {
 			rcu_read_unlock();
 			return;
 		}
 		sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
 		ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
 				elems.ht_cap_elem, &sta->sta.ht_cap);
 		ap_ht_cap_flags = sta->sta.ht_cap.cap;
 		rcu_read_unlock();
 		changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
 					       ap_ht_cap_flags);
 	}
 	if (elems.country_elem) {
 		/* Note we are only reviewing this on beacons
 		 * for the BSSID we are associated to */
 		regulatory_hint_11d(local->hw.wiphy,
 			elems.country_elem, elems.country_elem_len);
 	}
 	ieee80211_bss_info_change_notify(sdata, changed);
 }
 static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata,
 					struct ieee80211_if_sta *ifsta,
 					struct ieee80211_mgmt *mgmt,
 					size_t len,
 					struct ieee80211_rx_status *rx_status)
 {
 	struct ieee80211_local *local = sdata->local;
 	int tx_last_beacon;
 	struct sk_buff *skb;
 	struct ieee80211_mgmt *resp;
 	u8 *pos, *end;
 	if (sdata->vif.type != NL80211_IFTYPE_ADHOC ||
 	    ifsta->state != IEEE80211_STA_MLME_IBSS_JOINED ||
 	    len < 24 + 2 || !ifsta->probe_resp)
 		return;
 	if (local->ops->tx_last_beacon)
 		tx_last_beacon = local->ops->tx_last_beacon(local_to_hw(local));
 	else
 		tx_last_beacon = 1;
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
 	printk(KERN_DEBUG "%s: RX ProbeReq SA=%pM DA=%pM BSSID=%pM"
 	       " (tx_last_beacon=%d)\n",
 	       sdata->dev->name, mgmt->sa, mgmt->da,
 	       mgmt->bssid, tx_last_beacon);
 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
 	if (!tx_last_beacon)
 		return;
 	if (memcmp(mgmt->bssid, ifsta->bssid, ETH_ALEN) != 0 &&
 	    memcmp(mgmt->bssid, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) != 0)
 		return;
 	end = ((u8 *) mgmt) + len;
 	pos = mgmt->u.probe_req.variable;
 	if (pos[0] != WLAN_EID_SSID ||
 	    pos + 2 + pos[1] > end) {
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
 		printk(KERN_DEBUG "%s: Invalid SSID IE in ProbeReq "
 		       "from %pM\n",
 		       sdata->dev->name, mgmt->sa);
 #endif
 		return;
 	}
 	if (pos[1] != 0 &&
 	    (pos[1] != ifsta->ssid_len ||
 	     memcmp(pos + 2, ifsta->ssid, ifsta->ssid_len) != 0)) {
 		/* Ignore ProbeReq for foreign SSID */
 		return;
 	}
 	/* Reply with ProbeResp */
 	skb = skb_copy(ifsta->probe_resp, GFP_KERNEL);
 	if (!skb)
 		return;
 	resp = (struct ieee80211_mgmt *) skb->data;
 	memcpy(resp->da, mgmt->sa, ETH_ALEN);
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
 	printk(KERN_DEBUG "%s: Sending ProbeResp to %pM\n",
 	       sdata->dev->name, resp->da);
 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
 	ieee80211_tx_skb(sdata, skb, 0);
 }
 void ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
 			   struct ieee80211_rx_status *rx_status)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_if_sta *ifsta;
 	struct ieee80211_mgmt *mgmt;
 	u16 fc;
 	if (skb->len < 24)
 		goto fail;
 	ifsta = &sdata->u.sta;
 	mgmt = (struct ieee80211_mgmt *) skb->data;
 	fc = le16_to_cpu(mgmt->frame_control);
 	switch (fc & IEEE80211_FCTL_STYPE) {
 	case IEEE80211_STYPE_PROBE_REQ:
 	case IEEE80211_STYPE_PROBE_RESP:
 	case IEEE80211_STYPE_BEACON:
 		memcpy(skb->cb, rx_status, sizeof(*rx_status));
 	case IEEE80211_STYPE_AUTH:
 	case IEEE80211_STYPE_ASSOC_RESP:
 	case IEEE80211_STYPE_REASSOC_RESP:
 	case IEEE80211_STYPE_DEAUTH:
 	case IEEE80211_STYPE_DISASSOC:
 		skb_queue_tail(&ifsta->skb_queue, skb);
 		queue_work(local->hw.workqueue, &ifsta->work);
 		return;
 	}
  fail:
 	kfree_skb(skb);
 }
 static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
 					 struct sk_buff *skb)
 {
 	struct ieee80211_rx_status *rx_status;
 	struct ieee80211_if_sta *ifsta;
 	struct ieee80211_mgmt *mgmt;
 	u16 fc;
 	ifsta = &sdata->u.sta;
 	rx_status = (struct ieee80211_rx_status *) skb->cb;
 	mgmt = (struct ieee80211_mgmt *) skb->data;
 	fc = le16_to_cpu(mgmt->frame_control);
 	switch (fc & IEEE80211_FCTL_STYPE) {
 	case IEEE80211_STYPE_PROBE_REQ:
 		ieee80211_rx_mgmt_probe_req(sdata, ifsta, mgmt, skb->len,
 					    rx_status);
 		break;
 	case IEEE80211_STYPE_PROBE_RESP:
 		ieee80211_rx_mgmt_probe_resp(sdata, mgmt, skb->len, rx_status);
 		break;
 	case IEEE80211_STYPE_BEACON:
 		ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, rx_status);
 		break;
 	case IEEE80211_STYPE_AUTH:
 		ieee80211_rx_mgmt_auth(sdata, ifsta, mgmt, skb->len);
 		break;
 	case IEEE80211_STYPE_ASSOC_RESP:
 		ieee80211_rx_mgmt_assoc_resp(sdata, ifsta, mgmt, skb->len, 0);
 		break;
 	case IEEE80211_STYPE_REASSOC_RESP:
 		ieee80211_rx_mgmt_assoc_resp(sdata, ifsta, mgmt, skb->len, 1);
 		break;
 	case IEEE80211_STYPE_DEAUTH:
 		ieee80211_rx_mgmt_deauth(sdata, ifsta, mgmt, skb->len);
 		break;
 	case IEEE80211_STYPE_DISASSOC:
 		ieee80211_rx_mgmt_disassoc(sdata, ifsta, mgmt, skb->len);
 		break;
 	}
 	kfree_skb(skb);
 }
 static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data *sdata)
 {
 	struct ieee80211_local *local = sdata->local;
 	int active = 0;
 	struct sta_info *sta;
 	rcu_read_lock();
 	list_for_each_entry_rcu(sta, &local->sta_list, list) {
 		if (sta->sdata == sdata &&
 		    time_after(sta->last_rx + IEEE80211_IBSS_MERGE_INTERVAL,
 			       jiffies)) {
 			active++;
 			break;
 		}
 	}
 	rcu_read_unlock();
 	return active;
 }
 static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_if_sta *ifsta)
 {
 	mod_timer(&ifsta->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
 	ieee80211_sta_expire(sdata, IEEE80211_IBSS_INACTIVITY_LIMIT);
 	if (ieee80211_sta_active_ibss(sdata))
 		return;
 	printk(KERN_DEBUG "%s: No active IBSS STAs - trying to scan for other "
 	       "IBSS networks with same SSID (merge)\n", sdata->dev->name);
 	ieee80211_request_scan(sdata, ifsta->ssid, ifsta->ssid_len);
 }
 static void ieee80211_sta_timer(unsigned long data)
 {
 	struct ieee80211_sub_if_data *sdata =
 		(struct ieee80211_sub_if_data *) data;
 	struct ieee80211_if_sta *ifsta = &sdata->u.sta;
 	struct ieee80211_local *local = sdata->local;
 	set_bit(IEEE80211_STA_REQ_RUN, &ifsta->request);
 	queue_work(local->hw.workqueue, &ifsta->work);
 }
 static void ieee80211_sta_reset_auth(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_if_sta *ifsta)
 {
 	struct ieee80211_local *local = sdata->local;
 	if (local->ops->reset_tsf) {
 		/* Reset own TSF to allow time synchronization work. */
 		local->ops->reset_tsf(local_to_hw(local));
 	}
 	ifsta->wmm_last_param_set = -1; /* allow any WMM update */
 	if (ifsta->auth_algs & IEEE80211_AUTH_ALG_OPEN)
 		ifsta->auth_alg = WLAN_AUTH_OPEN;
 	else if (ifsta->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY)
 		ifsta->auth_alg = WLAN_AUTH_SHARED_KEY;
 	else if (ifsta->auth_algs & IEEE80211_AUTH_ALG_LEAP)
 		ifsta->auth_alg = WLAN_AUTH_LEAP;
 	else
 		ifsta->auth_alg = WLAN_AUTH_OPEN;
 	ifsta->auth_transaction = -1;
 	ifsta->flags &= ~IEEE80211_STA_ASSOCIATED;
 	ifsta->assoc_scan_tries = 0;
 	ifsta->direct_probe_tries = 0;
 	ifsta->auth_tries = 0;
 	ifsta->assoc_tries = 0;
 	netif_tx_stop_all_queues(sdata->dev);
 	netif_carrier_off(sdata->dev);
 }
 static int ieee80211_sta_match_ssid(struct ieee80211_if_sta *ifsta,
 				    const char *ssid, int ssid_len)
 {
 	int tmp, hidden_ssid;
 	if (ssid_len == ifsta->ssid_len &&
 	    !memcmp(ifsta->ssid, ssid, ssid_len))
 		return 1;
 	if (ifsta->flags & IEEE80211_STA_AUTO_BSSID_SEL)
 		return 0;
 	hidden_ssid = 1;
 	tmp = ssid_len;
 	while (tmp--) {
 		if (ssid[tmp] != '\0') {
 			hidden_ssid = 0;
 			break;
 		}
 	}
 	if (hidden_ssid && (ifsta->ssid_len == ssid_len || ssid_len == 0))
 		return 1;
 	if (ssid_len == 1 && ssid[0] == ' ')
 		return 1;
 	return 0;
 }
 static int ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_if_sta *ifsta)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_bss *bss;
 	struct ieee80211_supported_band *sband;
 	u8 bssid[ETH_ALEN], *pos;
 	int i;
 	int ret;
 #if 0
 	/* Easier testing, use fixed BSSID. */
 	memset(bssid, 0xfe, ETH_ALEN);
 #else
 	/* Generate random, not broadcast, locally administered BSSID. Mix in
 	 * own MAC address to make sure that devices that do not have proper
 	 * random number generator get different BSSID. */
 	get_random_bytes(bssid, ETH_ALEN);
 	for (i = 0; i < ETH_ALEN; i++)
 		bssid[i] ^= sdata->dev->dev_addr[i];
 	bssid[0] &= ~0x01;
 	bssid[0] |= 0x02;
 #endif
 	printk(KERN_DEBUG "%s: Creating new IBSS network, BSSID %pM\n",
 	       sdata->dev->name, bssid);
 	bss = ieee80211_rx_bss_add(local, bssid,
 				   local->hw.conf.channel->center_freq,
 				   sdata->u.sta.ssid, sdata->u.sta.ssid_len);
 	if (!bss)
 		return -ENOMEM;
 	bss->band = local->hw.conf.channel->band;
 	sband = local->hw.wiphy->bands[bss->band];
 	if (local->hw.conf.beacon_int == 0)
 		local->hw.conf.beacon_int = 100;
 	bss->beacon_int = local->hw.conf.beacon_int;
 	bss->last_update = jiffies;
 	bss->capability = WLAN_CAPABILITY_IBSS;
 	if (sdata->default_key)
 		bss->capability |= WLAN_CAPABILITY_PRIVACY;
 	else
 		sdata->drop_unencrypted = 0;
 	bss->supp_rates_len = sband->n_bitrates;
 	pos = bss->supp_rates;
 	for (i = 0; i < sband->n_bitrates; i++) {
 		int rate = sband->bitrates[i].bitrate;
 		*pos++ = (u8) (rate / 5);
 	}
 	ret = ieee80211_sta_join_ibss(sdata, ifsta, bss);
 	ieee80211_rx_bss_put(local, bss);
 	return ret;
 }
 static int ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata,
 				   struct ieee80211_if_sta *ifsta)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_bss *bss;
 	int found = 0;
 	u8 bssid[ETH_ALEN];
 	int active_ibss;
 	if (ifsta->ssid_len == 0)
 		return -EINVAL;
 	active_ibss = ieee80211_sta_active_ibss(sdata);
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
 	printk(KERN_DEBUG "%s: sta_find_ibss (active_ibss=%d)\n",
 	       sdata->dev->name, active_ibss);
 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
 	spin_lock_bh(&local->bss_lock);
 	list_for_each_entry(bss, &local->bss_list, list) {
 		if (ifsta->ssid_len != bss->ssid_len ||
 		    memcmp(ifsta->ssid, bss->ssid, bss->ssid_len) != 0
 		    || !(bss->capability & WLAN_CAPABILITY_IBSS))
 			continue;
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
 		printk(KERN_DEBUG "   bssid=%pM found\n", bss->bssid);
 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
 		memcpy(bssid, bss->bssid, ETH_ALEN);
 		found = 1;
 		if (active_ibss || memcmp(bssid, ifsta->bssid, ETH_ALEN) != 0)
 			break;
 	}
 	spin_unlock_bh(&local->bss_lock);
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
 	if (found)
 		printk(KERN_DEBUG "   sta_find_ibss: selected %pM current "
 		       "%pM\n", bssid, ifsta->bssid);
 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
 	if (found && memcmp(ifsta->bssid, bssid, ETH_ALEN) != 0) {
 		int ret;
 		int search_freq;
 		if (ifsta->flags & IEEE80211_STA_AUTO_CHANNEL_SEL)
 			search_freq = bss->freq;
 		else
 			search_freq = local->hw.conf.channel->center_freq;
 		bss = ieee80211_rx_bss_get(local, bssid, search_freq,
 					   ifsta->ssid, ifsta->ssid_len);
 		if (!bss)
 			goto dont_join;
 		printk(KERN_DEBUG "%s: Selected IBSS BSSID %pM"
 		       " based on configured SSID\n",
 		       sdata->dev->name, bssid);
 		ret = ieee80211_sta_join_ibss(sdata, ifsta, bss);
 		ieee80211_rx_bss_put(local, bss);
 		return ret;
 	}
 dont_join:
 #ifdef CONFIG_MAC80211_IBSS_DEBUG
 	printk(KERN_DEBUG "   did not try to join ibss\n");
 #endif /* CONFIG_MAC80211_IBSS_DEBUG */
 	/* Selected IBSS not found in current scan results - try to scan */
 	if (ifsta->state == IEEE80211_STA_MLME_IBSS_JOINED &&
 	    !ieee80211_sta_active_ibss(sdata)) {
 		mod_timer(&ifsta->timer, jiffies +
 				      IEEE80211_IBSS_MERGE_INTERVAL);
 	} else if (time_after(jiffies, local->last_scan_completed +
 			      IEEE80211_SCAN_INTERVAL)) {
 		printk(KERN_DEBUG "%s: Trigger new scan to find an IBSS to "
 		       "join\n", sdata->dev->name);
 		return ieee80211_request_scan(sdata, ifsta->ssid,
 					      ifsta->ssid_len);
 	} else if (ifsta->state != IEEE80211_STA_MLME_IBSS_JOINED) {
 		int interval = IEEE80211_SCAN_INTERVAL;
 		if (time_after(jiffies, ifsta->ibss_join_req +
 			       IEEE80211_IBSS_JOIN_TIMEOUT)) {
 			if ((ifsta->flags & IEEE80211_STA_CREATE_IBSS) &&
 			    (!(local->oper_channel->flags &
 					IEEE80211_CHAN_NO_IBSS)))
 				return ieee80211_sta_create_ibss(sdata, ifsta);
 			if (ifsta->flags & IEEE80211_STA_CREATE_IBSS) {
 				printk(KERN_DEBUG "%s: IBSS not allowed on"
 				       " %d MHz\n", sdata->dev->name,
 				       local->hw.conf.channel->center_freq);
 			}
 			/* No IBSS found - decrease scan interval and continue
 			 * scanning. */
 			interval = IEEE80211_SCAN_INTERVAL_SLOW;
 		}
 		ifsta->state = IEEE80211_STA_MLME_IBSS_SEARCH;
 		mod_timer(&ifsta->timer, jiffies + interval);
 		return 0;
 	}
 	return 0;
 }
 static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
 				     struct ieee80211_if_sta *ifsta)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_bss *bss, *selected = NULL;
 	int top_rssi = 0, freq;
 	spin_lock_bh(&local->bss_lock);
 	freq = local->oper_channel->center_freq;
 	list_for_each_entry(bss, &local->bss_list, list) {
 		if (!(bss->capability & WLAN_CAPABILITY_ESS))
 			continue;
 		if ((ifsta->flags & (IEEE80211_STA_AUTO_SSID_SEL |
 			IEEE80211_STA_AUTO_BSSID_SEL |
 			IEEE80211_STA_AUTO_CHANNEL_SEL)) &&
 		    (!!(bss->capability & WLAN_CAPABILITY_PRIVACY) ^
 		     !!sdata->default_key))
 			continue;
 		if (!(ifsta->flags & IEEE80211_STA_AUTO_CHANNEL_SEL) &&
 		    bss->freq != freq)
 			continue;
 		if (!(ifsta->flags & IEEE80211_STA_AUTO_BSSID_SEL) &&
 		    memcmp(bss->bssid, ifsta->bssid, ETH_ALEN))
 			continue;
 		if (!(ifsta->flags & IEEE80211_STA_AUTO_SSID_SEL) &&
 		    !ieee80211_sta_match_ssid(ifsta, bss->ssid, bss->ssid_len))
 			continue;
 		if (!selected || top_rssi < bss->signal) {
 			selected = bss;
 			top_rssi = bss->signal;
 		}
 	}
 	if (selected)
 		atomic_inc(&selected->users);
 	spin_unlock_bh(&local->bss_lock);
 	if (selected) {
 		ieee80211_set_freq(sdata, selected->freq);
 		if (!(ifsta->flags & IEEE80211_STA_SSID_SET))
 			ieee80211_sta_set_ssid(sdata, selected->ssid,
 					       selected->ssid_len);
 		ieee80211_sta_set_bssid(sdata, selected->bssid);
 		ieee80211_sta_def_wmm_params(sdata, selected);
 		/* Send out direct probe if no probe resp was received or
 		 * the one we have is outdated
 		 */
 		if (!selected->last_probe_resp ||
 		    time_after(jiffies, selected->last_probe_resp
 					+ IEEE80211_SCAN_RESULT_EXPIRE))
 			ifsta->state = IEEE80211_STA_MLME_DIRECT_PROBE;
 		else
 			ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE;
 		ieee80211_rx_bss_put(local, selected);
 		ieee80211_sta_reset_auth(sdata, ifsta);
 		return 0;
 	} else {
 		if (ifsta->assoc_scan_tries < IEEE80211_ASSOC_SCANS_MAX_TRIES) {
 			ifsta->assoc_scan_tries++;
 			if (ifsta->flags & IEEE80211_STA_AUTO_SSID_SEL)
 				ieee80211_start_scan(sdata, NULL, 0);
 			else
 				ieee80211_start_scan(sdata, ifsta->ssid,
 							 ifsta->ssid_len);
 			ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE;
 			set_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request);
 		} else
 			ifsta->state = IEEE80211_STA_MLME_DISABLED;
 	}
 	return -1;
 }
 static void ieee80211_sta_work(struct work_struct *work)
 {
 	struct ieee80211_sub_if_data *sdata =
 		container_of(work, struct ieee80211_sub_if_data, u.sta.work);
 	struct ieee80211_local *local = sdata->local;
 	struct ieee80211_if_sta *ifsta;
 	struct sk_buff *skb;
 	if (!netif_running(sdata->dev))
 		return;
 	if (local->sw_scanning || local->hw_scanning)
 		return;
 	if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION &&
 		    sdata->vif.type != NL80211_IFTYPE_ADHOC))
 		return;
 	ifsta = &sdata->u.sta;
 	while ((skb = skb_dequeue(&ifsta->skb_queue)))
 		ieee80211_sta_rx_queued_mgmt(sdata, skb);
 	if (ifsta->state != IEEE80211_STA_MLME_DIRECT_PROBE &&
 	    ifsta->state != IEEE80211_STA_MLME_AUTHENTICATE &&
 	    ifsta->state != IEEE80211_STA_MLME_ASSOCIATE &&
 	    test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifsta->request)) {
 		ieee80211_start_scan(sdata, ifsta->scan_ssid,
 				     ifsta->scan_ssid_len);
 		return;
 	}
 	if (test_and_clear_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request)) {
 		if (ieee80211_sta_config_auth(sdata, ifsta))
 			return;
 		clear_bit(IEEE80211_STA_REQ_RUN, &ifsta->request);
 	} else if (!test_and_clear_bit(IEEE80211_STA_REQ_RUN, &ifsta->request))
 		return;
 	switch (ifsta->state) {
 	case IEEE80211_STA_MLME_DISABLED:
 		break;
 	case IEEE80211_STA_MLME_DIRECT_PROBE:
 		ieee80211_direct_probe(sdata, ifsta);
 		break;
 	case IEEE80211_STA_MLME_AUTHENTICATE:
 		ieee80211_authenticate(sdata, ifsta);
 		break;
 	case IEEE80211_STA_MLME_ASSOCIATE:
 		ieee80211_associate(sdata, ifsta);
 		break;
 	case IEEE80211_STA_MLME_ASSOCIATED:
 		ieee80211_associated(sdata, ifsta);
 		break;
 	case IEEE80211_STA_MLME_IBSS_SEARCH:
 		ieee80211_sta_find_ibss(sdata, ifsta);
 		break;
 	case IEEE80211_STA_MLME_IBSS_JOINED:
 		ieee80211_sta_merge_ibss(sdata, ifsta);
 		break;
 	default:
 		WARN_ON(1);
 		break;
 	}
 	if (ieee80211_privacy_mismatch(sdata, ifsta)) {
 		printk(KERN_DEBUG "%s: privacy configuration mismatch and "
 		       "mixed-cell disabled - disassociate\n", sdata->dev->name);
 		ieee80211_set_disassoc(sdata, ifsta, false, true,
 					WLAN_REASON_UNSPECIFIED);
 	}
 }
 static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
 {
 	if (sdata->vif.type == NL80211_IFTYPE_STATION)
 		queue_work(sdata->local->hw.workqueue,
 			   &sdata->u.sta.work);
 }
 /* interface setup */
 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
 {
 	struct ieee80211_if_sta *ifsta;
 	ifsta = &sdata->u.sta;
 	INIT_WORK(&ifsta->work, ieee80211_sta_work);
 	setup_timer(&ifsta->timer, ieee80211_sta_timer,
 		    (unsigned long) sdata);
 	skb_queue_head_init(&ifsta->skb_queue);
 	ifsta->capab = WLAN_CAPABILITY_ESS;
 	ifsta->auth_algs = IEEE80211_AUTH_ALG_OPEN |
 		IEEE80211_AUTH_ALG_SHARED_KEY;
 	ifsta->flags |= IEEE80211_STA_CREATE_IBSS |
 		IEEE80211_STA_AUTO_BSSID_SEL |
 		IEEE80211_STA_AUTO_CHANNEL_SEL;
 	if (ieee80211_num_regular_queues(&sdata->local->hw) >= 4)
 		ifsta->flags |= IEEE80211_STA_WMM_ENABLED;
 }
 /*
  * Add a new IBSS station, will also be called by the RX code when,
  * in IBSS mode, receiving a frame from a yet-unknown station, hence
  * must be callable in atomic context.
  */
 struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
 					u8 *bssid,u8 *addr, u64 supp_rates)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct sta_info *sta;
 	int band = local->hw.conf.channel->band;
 	/* TODO: Could consider removing the least recently used entry and
 	 * allow new one to be added. */
 	if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
 		if (net_ratelimit()) {
 			printk(KERN_DEBUG "%s: No room for a new IBSS STA "
 			       "entry %pM\n", sdata->dev->name, addr);
 		}
 		return NULL;
 	}
 	if (compare_ether_addr(bssid, sdata->u.sta.bssid))
 		return NULL;
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 	printk(KERN_DEBUG "%s: Adding new IBSS station %pM (dev=%s)\n",
 	       wiphy_name(local->hw.wiphy), addr, sdata->dev->name);
 #endif
 	sta = sta_info_alloc(sdata, addr, GFP_ATOMIC);
 	if (!sta)
 		return NULL;
 	set_sta_flags(sta, WLAN_STA_AUTHORIZED);
 	/* make sure mandatory rates are always added */
 	sta->sta.supp_rates[band] = supp_rates |
 			ieee80211_mandatory_rates(local, band);
 	rate_control_rate_init(sta);
 	if (sta_info_insert(sta))
 		return NULL;
 	return sta;
 }
 /* configuration hooks */
 void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata,
 			    struct ieee80211_if_sta *ifsta)
 {
 	struct ieee80211_local *local = sdata->local;
 	if (sdata->vif.type != NL80211_IFTYPE_STATION)
 		return;
 	if ((ifsta->flags & (IEEE80211_STA_BSSID_SET |
 			     IEEE80211_STA_AUTO_BSSID_SEL)) &&
 	    (ifsta->flags & (IEEE80211_STA_SSID_SET |
 			     IEEE80211_STA_AUTO_SSID_SEL))) {
 		if (ifsta->state == IEEE80211_STA_MLME_ASSOCIATED)
 			ieee80211_set_disassoc(sdata, ifsta, true, true,
 					       WLAN_REASON_DEAUTH_LEAVING);
 		set_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request);
 		queue_work(local->hw.workqueue, &ifsta->work);
 	}
 }
 int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len)
 {
 	struct ieee80211_if_sta *ifsta;
 	if (len > IEEE80211_MAX_SSID_LEN)
 		return -EINVAL;
 	ifsta = &sdata->u.sta;
 	if (ifsta->ssid_len != len || memcmp(ifsta->ssid, ssid, len) != 0) {
 		memset(ifsta->ssid, 0, sizeof(ifsta->ssid));
 		memcpy(ifsta->ssid, ssid, len);
 		ifsta->ssid_len = len;
 		ifsta->flags &= ~IEEE80211_STA_PREV_BSSID_SET;
 	}
 	if (len)
 		ifsta->flags |= IEEE80211_STA_SSID_SET;
 	else
 		ifsta->flags &= ~IEEE80211_STA_SSID_SET;
 	if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
 	    !(ifsta->flags & IEEE80211_STA_BSSID_SET)) {
 		ifsta->ibss_join_req = jiffies;
 		ifsta->state = IEEE80211_STA_MLME_IBSS_SEARCH;
 		return ieee80211_sta_find_ibss(sdata, ifsta);
 	}
 	return 0;
 }
 int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len)
 {
 	struct ieee80211_if_sta *ifsta = &sdata->u.sta;
 	memcpy(ssid, ifsta->ssid, ifsta->ssid_len);
 	*len = ifsta->ssid_len;
 	return 0;
 }
 int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid)
 {
 	struct ieee80211_if_sta *ifsta;
 	int res;
 	ifsta = &sdata->u.sta;
 	if (memcmp(ifsta->bssid, bssid, ETH_ALEN) != 0) {
 		memcpy(ifsta->bssid, bssid, ETH_ALEN);
 		res = 0;
 		/*
 		 * Hack! See also ieee80211_sta_set_ssid.
 		 */
 		if (netif_running(sdata->dev))
 			res = ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID);
 		if (res) {
 			printk(KERN_DEBUG "%s: Failed to config new BSSID to "
 			       "the low-level driver\n", sdata->dev->name);
 			return res;
 		}
 	}
 	if (is_valid_ether_addr(bssid))
 		ifsta->flags |= IEEE80211_STA_BSSID_SET;
 	else
 		ifsta->flags &= ~IEEE80211_STA_BSSID_SET;
 	return 0;
 }
 int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata, char *ie, size_t len)
 {
 	struct ieee80211_if_sta *ifsta = &sdata->u.sta;
 	kfree(ifsta->extra_ie);
 	if (len == 0) {
 		ifsta->extra_ie = NULL;
 		ifsta->extra_ie_len = 0;
 		return 0;
 	}
 	ifsta->extra_ie = kmalloc(len, GFP_KERNEL);
 	if (!ifsta->extra_ie) {
 		ifsta->extra_ie_len = 0;
 		return -ENOMEM;
 	}
 	memcpy(ifsta->extra_ie, ie, len);
 	ifsta->extra_ie_len = len;
 	return 0;
 }
 int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason)
 {
 	struct ieee80211_if_sta *ifsta = &sdata->u.sta;
 	printk(KERN_DEBUG "%s: deauthenticating by local choice (reason=%d)\n",
 	       sdata->dev->name, reason);
 	if (sdata->vif.type != NL80211_IFTYPE_STATION &&
 	    sdata->vif.type != NL80211_IFTYPE_ADHOC)
 		return -EINVAL;
 	ieee80211_set_disassoc(sdata, ifsta, true, true, reason);
 	return 0;
 }
 int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason)
 {
 	struct ieee80211_if_sta *ifsta = &sdata->u.sta;
 	printk(KERN_DEBUG "%s: disassociating by local choice (reason=%d)\n",
 	       sdata->dev->name, reason);
 	if (sdata->vif.type != NL80211_IFTYPE_STATION)
 		return -EINVAL;
 	if (!(ifsta->flags & IEEE80211_STA_ASSOCIATED))
 		return -1;
 	ieee80211_set_disassoc(sdata, ifsta, false, true, reason);
 	return 0;
 }
 /* scan finished notification */
 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
 {
 	struct ieee80211_sub_if_data *sdata = local->scan_sdata;
 	struct ieee80211_if_sta *ifsta;
 	if (sdata && sdata->vif.type == NL80211_IFTYPE_ADHOC) {
 		ifsta = &sdata->u.sta;
 		if (!(ifsta->flags & IEEE80211_STA_BSSID_SET) ||
 		    (!(ifsta->state == IEEE80211_STA_MLME_IBSS_JOINED) &&
 		    !ieee80211_sta_active_ibss(sdata)))
 			ieee80211_sta_find_ibss(sdata, ifsta);
 	}
 	/* Restart STA timers */
 	rcu_read_lock();
 	list_for_each_entry_rcu(sdata, &local->interfaces, list)
 		ieee80211_restart_sta_timer(sdata);
 	rcu_read_unlock();
 }

net/mac80211/util.c

Diff comments View file @ 094d05d

1	/*	1	/*
2	* Copyright 2002-2005, Instant802 Networks, Inc.	2	* Copyright 2002-2005, Instant802 Networks, Inc.
3	* Copyright 2005-2006, Devicescape Software, Inc.	3	* Copyright 2005-2006, Devicescape Software, Inc.
4	* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>	4	* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
5	* Copyright 2007 Johannes Berg <johannes@sipsolutions.net>	5	* Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
6	*	6	*
7	* This program is free software; you can redistribute it and/or modify	7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License version 2 as	8	* it under the terms of the GNU General Public License version 2 as
9	* published by the Free Software Foundation.	9	* published by the Free Software Foundation.
10	*	10	*
11	* utilities for mac80211	11	* utilities for mac80211
12	*/	12	*/
13		13
14	#include <net/mac80211.h>	14	#include <net/mac80211.h>
15	#include <linux/netdevice.h>	15	#include <linux/netdevice.h>
16	#include <linux/types.h>	16	#include <linux/types.h>
17	#include <linux/slab.h>	17	#include <linux/slab.h>
18	#include <linux/skbuff.h>	18	#include <linux/skbuff.h>
19	#include <linux/etherdevice.h>	19	#include <linux/etherdevice.h>
20	#include <linux/if_arp.h>	20	#include <linux/if_arp.h>
21	#include <linux/wireless.h>	21	#include <linux/wireless.h>
22	#include <linux/bitmap.h>	22	#include <linux/bitmap.h>
23	#include <net/net_namespace.h>	23	#include <net/net_namespace.h>
24	#include <net/cfg80211.h>	24	#include <net/cfg80211.h>
25	#include <net/rtnetlink.h>	25	#include <net/rtnetlink.h>
26		26
27	#include "ieee80211_i.h"	27	#include "ieee80211_i.h"
28	#include "rate.h"	28	#include "rate.h"
29	#include "mesh.h"	29	#include "mesh.h"
30	#include "wme.h"	30	#include "wme.h"
31		31
32	/* privid for wiphys to determine whether they belong to us or not */	32	/* privid for wiphys to determine whether they belong to us or not */
33	void *mac80211_wiphy_privid = &mac80211_wiphy_privid;	33	void *mac80211_wiphy_privid = &mac80211_wiphy_privid;
34		34
35	/* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */	35	/* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */
36	/* Ethernet-II snap header (RFC1042 for most EtherTypes) */	36	/* Ethernet-II snap header (RFC1042 for most EtherTypes) */
37	const unsigned char rfc1042_header[] __aligned(2) =	37	const unsigned char rfc1042_header[] __aligned(2) =
38	{ 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };	38	{ 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
39		39
40	/* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */	40	/* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
41	const unsigned char bridge_tunnel_header[] __aligned(2) =	41	const unsigned char bridge_tunnel_header[] __aligned(2) =
42	{ 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };	42	{ 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
43		43
44		44
45	u8 ieee80211_get_bssid(struct ieee80211_hdr hdr, size_t len,	45	u8 ieee80211_get_bssid(struct ieee80211_hdr hdr, size_t len,
46	enum nl80211_iftype type)	46	enum nl80211_iftype type)
47	{	47	{
48	__le16 fc = hdr->frame_control;	48	__le16 fc = hdr->frame_control;
49		49
50	/* drop ACK/CTS frames and incorrect hdr len (ctrl) */	50	/* drop ACK/CTS frames and incorrect hdr len (ctrl) */
51	if (len < 16)	51	if (len < 16)
52	return NULL;	52	return NULL;
53		53
54	if (ieee80211_is_data(fc)) {	54	if (ieee80211_is_data(fc)) {
55	if (len < 24) /* drop incorrect hdr len (data) */	55	if (len < 24) /* drop incorrect hdr len (data) */
56	return NULL;	56	return NULL;
57		57
58	if (ieee80211_has_a4(fc))	58	if (ieee80211_has_a4(fc))
59	return NULL;	59	return NULL;
60	if (ieee80211_has_tods(fc))	60	if (ieee80211_has_tods(fc))
61	return hdr->addr1;	61	return hdr->addr1;
62	if (ieee80211_has_fromds(fc))	62	if (ieee80211_has_fromds(fc))
63	return hdr->addr2;	63	return hdr->addr2;
64		64
65	return hdr->addr3;	65	return hdr->addr3;
66	}	66	}
67		67
68	if (ieee80211_is_mgmt(fc)) {	68	if (ieee80211_is_mgmt(fc)) {
69	if (len < 24) /* drop incorrect hdr len (mgmt) */	69	if (len < 24) /* drop incorrect hdr len (mgmt) */
70	return NULL;	70	return NULL;
71	return hdr->addr3;	71	return hdr->addr3;
72	}	72	}
73		73
74	if (ieee80211_is_ctl(fc)) {	74	if (ieee80211_is_ctl(fc)) {
75	if(ieee80211_is_pspoll(fc))	75	if(ieee80211_is_pspoll(fc))
76	return hdr->addr1;	76	return hdr->addr1;
77		77
78	if (ieee80211_is_back_req(fc)) {	78	if (ieee80211_is_back_req(fc)) {
79	switch (type) {	79	switch (type) {
80	case NL80211_IFTYPE_STATION:	80	case NL80211_IFTYPE_STATION:
81	return hdr->addr2;	81	return hdr->addr2;
82	case NL80211_IFTYPE_AP:	82	case NL80211_IFTYPE_AP:
83	case NL80211_IFTYPE_AP_VLAN:	83	case NL80211_IFTYPE_AP_VLAN:
84	return hdr->addr1;	84	return hdr->addr1;
85	default:	85	default:
86	break; /* fall through to the return */	86	break; /* fall through to the return */
87	}	87	}
88	}	88	}
89	}	89	}
90		90
91	return NULL;	91	return NULL;
92	}	92	}
93		93
94	unsigned int ieee80211_hdrlen(__le16 fc)	94	unsigned int ieee80211_hdrlen(__le16 fc)
95	{	95	{
96	unsigned int hdrlen = 24;	96	unsigned int hdrlen = 24;
97		97
98	if (ieee80211_is_data(fc)) {	98	if (ieee80211_is_data(fc)) {
99	if (ieee80211_has_a4(fc))	99	if (ieee80211_has_a4(fc))
100	hdrlen = 30;	100	hdrlen = 30;
101	if (ieee80211_is_data_qos(fc))	101	if (ieee80211_is_data_qos(fc))
102	hdrlen += IEEE80211_QOS_CTL_LEN;	102	hdrlen += IEEE80211_QOS_CTL_LEN;
103	goto out;	103	goto out;
104	}	104	}
105		105
106	if (ieee80211_is_ctl(fc)) {	106	if (ieee80211_is_ctl(fc)) {
107	/*	107	/*
108	* ACK and CTS are 10 bytes, all others 16. To see how	108	* ACK and CTS are 10 bytes, all others 16. To see how
109	* to get this condition consider	109	* to get this condition consider
110	* subtype mask: 0b0000000011110000 (0x00F0)	110	* subtype mask: 0b0000000011110000 (0x00F0)
111	* ACK subtype: 0b0000000011010000 (0x00D0)	111	* ACK subtype: 0b0000000011010000 (0x00D0)
112	* CTS subtype: 0b0000000011000000 (0x00C0)	112	* CTS subtype: 0b0000000011000000 (0x00C0)
113	* bits that matter: ^^^ (0x00E0)	113	* bits that matter: ^^^ (0x00E0)
114	* value of those: 0b0000000011000000 (0x00C0)	114	* value of those: 0b0000000011000000 (0x00C0)
115	*/	115	*/
116	if ((fc & cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0))	116	if ((fc & cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0))
117	hdrlen = 10;	117	hdrlen = 10;
118	else	118	else
119	hdrlen = 16;	119	hdrlen = 16;
120	}	120	}
121	out:	121	out:
122	return hdrlen;	122	return hdrlen;
123	}	123	}
124	EXPORT_SYMBOL(ieee80211_hdrlen);	124	EXPORT_SYMBOL(ieee80211_hdrlen);
125		125
126	unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb)	126	unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb)
127	{	127	{
128	const struct ieee80211_hdr hdr = (const struct ieee80211_hdr )skb->data;	128	const struct ieee80211_hdr hdr = (const struct ieee80211_hdr )skb->data;
129	unsigned int hdrlen;	129	unsigned int hdrlen;
130		130
131	if (unlikely(skb->len < 10))	131	if (unlikely(skb->len < 10))
132	return 0;	132	return 0;
133	hdrlen = ieee80211_hdrlen(hdr->frame_control);	133	hdrlen = ieee80211_hdrlen(hdr->frame_control);
134	if (unlikely(hdrlen > skb->len))	134	if (unlikely(hdrlen > skb->len))
135	return 0;	135	return 0;
136	return hdrlen;	136	return hdrlen;
137	}	137	}
138	EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb);	138	EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb);
139		139
140	int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr)	140	int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr)
141	{	141	{
142	int ae = meshhdr->flags & IEEE80211S_FLAGS_AE;	142	int ae = meshhdr->flags & IEEE80211S_FLAGS_AE;
143	/* 7.1.3.5a.2 */	143	/* 7.1.3.5a.2 */
144	switch (ae) {	144	switch (ae) {
145	case 0:	145	case 0:
146	return 6;	146	return 6;
147	case 1:	147	case 1:
148	return 12;	148	return 12;
149	case 2:	149	case 2:
150	return 18;	150	return 18;
151	case 3:	151	case 3:
152	return 24;	152	return 24;
153	default:	153	default:
154	return 6;	154	return 6;
155	}	155	}
156	}	156	}
157		157
158	void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)	158	void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
159	{	159	{
160	struct ieee80211_hdr hdr = (struct ieee80211_hdr ) tx->skb->data;	160	struct ieee80211_hdr hdr = (struct ieee80211_hdr ) tx->skb->data;
161		161
162	hdr->frame_control \|= cpu_to_le16(IEEE80211_FCTL_PROTECTED);	162	hdr->frame_control \|= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
163	if (tx->extra_frag) {	163	if (tx->extra_frag) {
164	struct ieee80211_hdr *fhdr;	164	struct ieee80211_hdr *fhdr;
165	int i;	165	int i;
166	for (i = 0; i < tx->num_extra_frag; i++) {	166	for (i = 0; i < tx->num_extra_frag; i++) {
167	fhdr = (struct ieee80211_hdr *)	167	fhdr = (struct ieee80211_hdr *)
168	tx->extra_frag[i]->data;	168	tx->extra_frag[i]->data;
169	fhdr->frame_control \|= cpu_to_le16(IEEE80211_FCTL_PROTECTED);	169	fhdr->frame_control \|= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
170	}	170	}
171	}	171	}
172	}	172	}
173		173
174	int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,	174	int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,
175	int rate, int erp, int short_preamble)	175	int rate, int erp, int short_preamble)
176	{	176	{
177	int dur;	177	int dur;
178		178
179	/* calculate duration (in microseconds, rounded up to next higher	179	/* calculate duration (in microseconds, rounded up to next higher
180	* integer if it includes a fractional microsecond) to send frame of	180	* integer if it includes a fractional microsecond) to send frame of
181	* len bytes (does not include FCS) at the given rate. Duration will	181	* len bytes (does not include FCS) at the given rate. Duration will
182	* also include SIFS.	182	* also include SIFS.
183	*	183	*
184	* rate is in 100 kbps, so divident is multiplied by 10 in the	184	* rate is in 100 kbps, so divident is multiplied by 10 in the
185	* DIV_ROUND_UP() operations.	185	* DIV_ROUND_UP() operations.
186	*/	186	*/
187		187
188	if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ \|\| erp) {	188	if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ \|\| erp) {
189	/*	189	/*
190	* OFDM:	190	* OFDM:
191	*	191	*
192	* N_DBPS = DATARATE x 4	192	* N_DBPS = DATARATE x 4
193	* N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)	193	* N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
194	* (16 = SIGNAL time, 6 = tail bits)	194	* (16 = SIGNAL time, 6 = tail bits)
195	* TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext	195	* TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
196	*	196	*
197	* T_SYM = 4 usec	197	* T_SYM = 4 usec
198	* 802.11a - 17.5.2: aSIFSTime = 16 usec	198	* 802.11a - 17.5.2: aSIFSTime = 16 usec
199	* 802.11g - 19.8.4: aSIFSTime = 10 usec +	199	* 802.11g - 19.8.4: aSIFSTime = 10 usec +
200	* signal ext = 6 usec	200	* signal ext = 6 usec
201	*/	201	*/
202	dur = 16; /* SIFS + signal ext */	202	dur = 16; /* SIFS + signal ext */
203	dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */	203	dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */
204	dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */	204	dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */
205	dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,	205	dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
206	4 * rate); /* T_SYM x N_SYM */	206	4 * rate); /* T_SYM x N_SYM */
207	} else {	207	} else {
208	/*	208	/*
209	* 802.11b or 802.11g with 802.11b compatibility:	209	* 802.11b or 802.11g with 802.11b compatibility:
210	* 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +	210	* 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
211	* Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.	211	* Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
212	*	212	*
213	* 802.11 (DS): 15.3.3, 802.11b: 18.3.4	213	* 802.11 (DS): 15.3.3, 802.11b: 18.3.4
214	* aSIFSTime = 10 usec	214	* aSIFSTime = 10 usec
215	* aPreambleLength = 144 usec or 72 usec with short preamble	215	* aPreambleLength = 144 usec or 72 usec with short preamble
216	* aPLCPHeaderLength = 48 usec or 24 usec with short preamble	216	* aPLCPHeaderLength = 48 usec or 24 usec with short preamble
217	*/	217	*/
218	dur = 10; /* aSIFSTime = 10 usec */	218	dur = 10; /* aSIFSTime = 10 usec */
219	dur += short_preamble ? (72 + 24) : (144 + 48);	219	dur += short_preamble ? (72 + 24) : (144 + 48);
220		220
221	dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);	221	dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
222	}	222	}
223		223
224	return dur;	224	return dur;
225	}	225	}
226		226
227	/* Exported duration function for driver use */	227	/* Exported duration function for driver use */
228	__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,	228	__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
229	struct ieee80211_vif *vif,	229	struct ieee80211_vif *vif,
230	size_t frame_len,	230	size_t frame_len,
231	struct ieee80211_rate *rate)	231	struct ieee80211_rate *rate)
232	{	232	{
233	struct ieee80211_local *local = hw_to_local(hw);	233	struct ieee80211_local *local = hw_to_local(hw);
234	struct ieee80211_sub_if_data *sdata;	234	struct ieee80211_sub_if_data *sdata;
235	u16 dur;	235	u16 dur;
236	int erp;	236	int erp;
237	bool short_preamble = false;	237	bool short_preamble = false;
238		238
239	erp = 0;	239	erp = 0;
240	if (vif) {	240	if (vif) {
241	sdata = vif_to_sdata(vif);	241	sdata = vif_to_sdata(vif);
242	short_preamble = sdata->vif.bss_conf.use_short_preamble;	242	short_preamble = sdata->vif.bss_conf.use_short_preamble;
243	if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)	243	if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
244	erp = rate->flags & IEEE80211_RATE_ERP_G;	244	erp = rate->flags & IEEE80211_RATE_ERP_G;
245	}	245	}
246		246
247	dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, erp,	247	dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, erp,
248	short_preamble);	248	short_preamble);
249		249
250	return cpu_to_le16(dur);	250	return cpu_to_le16(dur);
251	}	251	}
252	EXPORT_SYMBOL(ieee80211_generic_frame_duration);	252	EXPORT_SYMBOL(ieee80211_generic_frame_duration);
253		253
254	__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,	254	__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
255	struct ieee80211_vif *vif, size_t frame_len,	255	struct ieee80211_vif *vif, size_t frame_len,
256	const struct ieee80211_tx_info *frame_txctl)	256	const struct ieee80211_tx_info *frame_txctl)
257	{	257	{
258	struct ieee80211_local *local = hw_to_local(hw);	258	struct ieee80211_local *local = hw_to_local(hw);
259	struct ieee80211_rate *rate;	259	struct ieee80211_rate *rate;
260	struct ieee80211_sub_if_data *sdata;	260	struct ieee80211_sub_if_data *sdata;
261	bool short_preamble;	261	bool short_preamble;
262	int erp;	262	int erp;
263	u16 dur;	263	u16 dur;
264	struct ieee80211_supported_band *sband;	264	struct ieee80211_supported_band *sband;
265		265
266	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];	266	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
267		267
268	short_preamble = false;	268	short_preamble = false;
269		269
270	rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];	270	rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
271		271
272	erp = 0;	272	erp = 0;
273	if (vif) {	273	if (vif) {
274	sdata = vif_to_sdata(vif);	274	sdata = vif_to_sdata(vif);
275	short_preamble = sdata->vif.bss_conf.use_short_preamble;	275	short_preamble = sdata->vif.bss_conf.use_short_preamble;
276	if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)	276	if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
277	erp = rate->flags & IEEE80211_RATE_ERP_G;	277	erp = rate->flags & IEEE80211_RATE_ERP_G;
278	}	278	}
279		279
280	/* CTS duration */	280	/* CTS duration */
281	dur = ieee80211_frame_duration(local, 10, rate->bitrate,	281	dur = ieee80211_frame_duration(local, 10, rate->bitrate,
282	erp, short_preamble);	282	erp, short_preamble);
283	/* Data frame duration */	283	/* Data frame duration */
284	dur += ieee80211_frame_duration(local, frame_len, rate->bitrate,	284	dur += ieee80211_frame_duration(local, frame_len, rate->bitrate,
285	erp, short_preamble);	285	erp, short_preamble);
286	/* ACK duration */	286	/* ACK duration */
287	dur += ieee80211_frame_duration(local, 10, rate->bitrate,	287	dur += ieee80211_frame_duration(local, 10, rate->bitrate,
288	erp, short_preamble);	288	erp, short_preamble);
289		289
290	return cpu_to_le16(dur);	290	return cpu_to_le16(dur);
291	}	291	}
292	EXPORT_SYMBOL(ieee80211_rts_duration);	292	EXPORT_SYMBOL(ieee80211_rts_duration);
293		293
294	__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,	294	__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
295	struct ieee80211_vif *vif,	295	struct ieee80211_vif *vif,
296	size_t frame_len,	296	size_t frame_len,
297	const struct ieee80211_tx_info *frame_txctl)	297	const struct ieee80211_tx_info *frame_txctl)
298	{	298	{
299	struct ieee80211_local *local = hw_to_local(hw);	299	struct ieee80211_local *local = hw_to_local(hw);
300	struct ieee80211_rate *rate;	300	struct ieee80211_rate *rate;
301	struct ieee80211_sub_if_data *sdata;	301	struct ieee80211_sub_if_data *sdata;
302	bool short_preamble;	302	bool short_preamble;
303	int erp;	303	int erp;
304	u16 dur;	304	u16 dur;
305	struct ieee80211_supported_band *sband;	305	struct ieee80211_supported_band *sband;
306		306
307	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];	307	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
308		308
309	short_preamble = false;	309	short_preamble = false;
310		310
311	rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];	311	rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
312	erp = 0;	312	erp = 0;
313	if (vif) {	313	if (vif) {
314	sdata = vif_to_sdata(vif);	314	sdata = vif_to_sdata(vif);
315	short_preamble = sdata->vif.bss_conf.use_short_preamble;	315	short_preamble = sdata->vif.bss_conf.use_short_preamble;
316	if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)	316	if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
317	erp = rate->flags & IEEE80211_RATE_ERP_G;	317	erp = rate->flags & IEEE80211_RATE_ERP_G;
318	}	318	}
319		319
320	/* Data frame duration */	320	/* Data frame duration */
321	dur = ieee80211_frame_duration(local, frame_len, rate->bitrate,	321	dur = ieee80211_frame_duration(local, frame_len, rate->bitrate,
322	erp, short_preamble);	322	erp, short_preamble);
323	if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {	323	if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
324	/* ACK duration */	324	/* ACK duration */
325	dur += ieee80211_frame_duration(local, 10, rate->bitrate,	325	dur += ieee80211_frame_duration(local, 10, rate->bitrate,
326	erp, short_preamble);	326	erp, short_preamble);
327	}	327	}
328		328
329	return cpu_to_le16(dur);	329	return cpu_to_le16(dur);
330	}	330	}
331	EXPORT_SYMBOL(ieee80211_ctstoself_duration);	331	EXPORT_SYMBOL(ieee80211_ctstoself_duration);
332		332
333	void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)	333	void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
334	{	334	{
335	struct ieee80211_local *local = hw_to_local(hw);	335	struct ieee80211_local *local = hw_to_local(hw);
336		336
337	if (test_bit(queue, local->queues_pending)) {	337	if (test_bit(queue, local->queues_pending)) {
338	set_bit(queue, local->queues_pending_run);	338	set_bit(queue, local->queues_pending_run);
339	tasklet_schedule(&local->tx_pending_tasklet);	339	tasklet_schedule(&local->tx_pending_tasklet);
340	} else {	340	} else {
341	netif_wake_subqueue(local->mdev, queue);	341	netif_wake_subqueue(local->mdev, queue);
342	}	342	}
343	}	343	}
344	EXPORT_SYMBOL(ieee80211_wake_queue);	344	EXPORT_SYMBOL(ieee80211_wake_queue);
345		345
346	void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)	346	void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
347	{	347	{
348	struct ieee80211_local *local = hw_to_local(hw);	348	struct ieee80211_local *local = hw_to_local(hw);
349		349
350	netif_stop_subqueue(local->mdev, queue);	350	netif_stop_subqueue(local->mdev, queue);
351	}	351	}
352	EXPORT_SYMBOL(ieee80211_stop_queue);	352	EXPORT_SYMBOL(ieee80211_stop_queue);
353		353
354	void ieee80211_stop_queues(struct ieee80211_hw *hw)	354	void ieee80211_stop_queues(struct ieee80211_hw *hw)
355	{	355	{
356	int i;	356	int i;
357		357
358	for (i = 0; i < ieee80211_num_queues(hw); i++)	358	for (i = 0; i < ieee80211_num_queues(hw); i++)
359	ieee80211_stop_queue(hw, i);	359	ieee80211_stop_queue(hw, i);
360	}	360	}
361	EXPORT_SYMBOL(ieee80211_stop_queues);	361	EXPORT_SYMBOL(ieee80211_stop_queues);
362		362
363	int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)	363	int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
364	{	364	{
365	struct ieee80211_local *local = hw_to_local(hw);	365	struct ieee80211_local *local = hw_to_local(hw);
366	return __netif_subqueue_stopped(local->mdev, queue);	366	return __netif_subqueue_stopped(local->mdev, queue);
367	}	367	}
368	EXPORT_SYMBOL(ieee80211_queue_stopped);	368	EXPORT_SYMBOL(ieee80211_queue_stopped);
369		369
370	void ieee80211_wake_queues(struct ieee80211_hw *hw)	370	void ieee80211_wake_queues(struct ieee80211_hw *hw)
371	{	371	{
372	int i;	372	int i;
373		373
374	for (i = 0; i < hw->queues + hw->ampdu_queues; i++)	374	for (i = 0; i < hw->queues + hw->ampdu_queues; i++)
375	ieee80211_wake_queue(hw, i);	375	ieee80211_wake_queue(hw, i);
376	}	376	}
377	EXPORT_SYMBOL(ieee80211_wake_queues);	377	EXPORT_SYMBOL(ieee80211_wake_queues);
378		378
379	void ieee80211_iterate_active_interfaces(	379	void ieee80211_iterate_active_interfaces(
380	struct ieee80211_hw *hw,	380	struct ieee80211_hw *hw,
381	void (iterator)(void data, u8 *mac,	381	void (iterator)(void data, u8 *mac,
382	struct ieee80211_vif *vif),	382	struct ieee80211_vif *vif),
383	void *data)	383	void *data)
384	{	384	{
385	struct ieee80211_local *local = hw_to_local(hw);	385	struct ieee80211_local *local = hw_to_local(hw);
386	struct ieee80211_sub_if_data *sdata;	386	struct ieee80211_sub_if_data *sdata;
387		387
388	rtnl_lock();	388	rtnl_lock();
389		389
390	list_for_each_entry(sdata, &local->interfaces, list) {	390	list_for_each_entry(sdata, &local->interfaces, list) {
391	switch (sdata->vif.type) {	391	switch (sdata->vif.type) {
392	case __NL80211_IFTYPE_AFTER_LAST:	392	case __NL80211_IFTYPE_AFTER_LAST:
393	case NL80211_IFTYPE_UNSPECIFIED:	393	case NL80211_IFTYPE_UNSPECIFIED:
394	case NL80211_IFTYPE_MONITOR:	394	case NL80211_IFTYPE_MONITOR:
395	case NL80211_IFTYPE_AP_VLAN:	395	case NL80211_IFTYPE_AP_VLAN:
396	continue;	396	continue;
397	case NL80211_IFTYPE_AP:	397	case NL80211_IFTYPE_AP:
398	case NL80211_IFTYPE_STATION:	398	case NL80211_IFTYPE_STATION:
399	case NL80211_IFTYPE_ADHOC:	399	case NL80211_IFTYPE_ADHOC:
400	case NL80211_IFTYPE_WDS:	400	case NL80211_IFTYPE_WDS:
401	case NL80211_IFTYPE_MESH_POINT:	401	case NL80211_IFTYPE_MESH_POINT:
402	break;	402	break;
403	}	403	}
404	if (netif_running(sdata->dev))	404	if (netif_running(sdata->dev))
405	iterator(data, sdata->dev->dev_addr,	405	iterator(data, sdata->dev->dev_addr,
406	&sdata->vif);	406	&sdata->vif);
407	}	407	}
408		408
409	rtnl_unlock();	409	rtnl_unlock();
410	}	410	}
411	EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces);	411	EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces);
412		412
413	void ieee80211_iterate_active_interfaces_atomic(	413	void ieee80211_iterate_active_interfaces_atomic(
414	struct ieee80211_hw *hw,	414	struct ieee80211_hw *hw,
415	void (iterator)(void data, u8 *mac,	415	void (iterator)(void data, u8 *mac,
416	struct ieee80211_vif *vif),	416	struct ieee80211_vif *vif),
417	void *data)	417	void *data)
418	{	418	{
419	struct ieee80211_local *local = hw_to_local(hw);	419	struct ieee80211_local *local = hw_to_local(hw);
420	struct ieee80211_sub_if_data *sdata;	420	struct ieee80211_sub_if_data *sdata;
421		421
422	rcu_read_lock();	422	rcu_read_lock();
423		423
424	list_for_each_entry_rcu(sdata, &local->interfaces, list) {	424	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
425	switch (sdata->vif.type) {	425	switch (sdata->vif.type) {
426	case __NL80211_IFTYPE_AFTER_LAST:	426	case __NL80211_IFTYPE_AFTER_LAST:
427	case NL80211_IFTYPE_UNSPECIFIED:	427	case NL80211_IFTYPE_UNSPECIFIED:
428	case NL80211_IFTYPE_MONITOR:	428	case NL80211_IFTYPE_MONITOR:
429	case NL80211_IFTYPE_AP_VLAN:	429	case NL80211_IFTYPE_AP_VLAN:
430	continue;	430	continue;
431	case NL80211_IFTYPE_AP:	431	case NL80211_IFTYPE_AP:
432	case NL80211_IFTYPE_STATION:	432	case NL80211_IFTYPE_STATION:
433	case NL80211_IFTYPE_ADHOC:	433	case NL80211_IFTYPE_ADHOC:
434	case NL80211_IFTYPE_WDS:	434	case NL80211_IFTYPE_WDS:
435	case NL80211_IFTYPE_MESH_POINT:	435	case NL80211_IFTYPE_MESH_POINT:
436	break;	436	break;
437	}	437	}
438	if (netif_running(sdata->dev))	438	if (netif_running(sdata->dev))
439	iterator(data, sdata->dev->dev_addr,	439	iterator(data, sdata->dev->dev_addr,
440	&sdata->vif);	440	&sdata->vif);
441	}	441	}
442		442
443	rcu_read_unlock();	443	rcu_read_unlock();
444	}	444	}
445	EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);	445	EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
446		446
447	void ieee802_11_parse_elems(u8 *start, size_t len,	447	void ieee802_11_parse_elems(u8 *start, size_t len,
448	struct ieee802_11_elems *elems)	448	struct ieee802_11_elems *elems)
449	{	449	{
450	size_t left = len;	450	size_t left = len;
451	u8 *pos = start;	451	u8 *pos = start;
452		452
453	memset(elems, 0, sizeof(*elems));	453	memset(elems, 0, sizeof(*elems));
454	elems->ie_start = start;	454	elems->ie_start = start;
455	elems->total_len = len;	455	elems->total_len = len;
456		456
457	while (left >= 2) {	457	while (left >= 2) {
458	u8 id, elen;	458	u8 id, elen;
459		459
460	id = *pos++;	460	id = *pos++;
461	elen = *pos++;	461	elen = *pos++;
462	left -= 2;	462	left -= 2;
463		463
464	if (elen > left)	464	if (elen > left)
465	return;	465	return;
466		466
467	switch (id) {	467	switch (id) {
468	case WLAN_EID_SSID:	468	case WLAN_EID_SSID:
469	elems->ssid = pos;	469	elems->ssid = pos;
470	elems->ssid_len = elen;	470	elems->ssid_len = elen;
471	break;	471	break;
472	case WLAN_EID_SUPP_RATES:	472	case WLAN_EID_SUPP_RATES:
473	elems->supp_rates = pos;	473	elems->supp_rates = pos;
474	elems->supp_rates_len = elen;	474	elems->supp_rates_len = elen;
475	break;	475	break;
476	case WLAN_EID_FH_PARAMS:	476	case WLAN_EID_FH_PARAMS:
477	elems->fh_params = pos;	477	elems->fh_params = pos;
478	elems->fh_params_len = elen;	478	elems->fh_params_len = elen;
479	break;	479	break;
480	case WLAN_EID_DS_PARAMS:	480	case WLAN_EID_DS_PARAMS:
481	elems->ds_params = pos;	481	elems->ds_params = pos;
482	elems->ds_params_len = elen;	482	elems->ds_params_len = elen;
483	break;	483	break;
484	case WLAN_EID_CF_PARAMS:	484	case WLAN_EID_CF_PARAMS:
485	elems->cf_params = pos;	485	elems->cf_params = pos;
486	elems->cf_params_len = elen;	486	elems->cf_params_len = elen;
487	break;	487	break;
488	case WLAN_EID_TIM:	488	case WLAN_EID_TIM:
489	elems->tim = pos;	489	elems->tim = pos;
490	elems->tim_len = elen;	490	elems->tim_len = elen;
491	break;	491	break;
492	case WLAN_EID_IBSS_PARAMS:	492	case WLAN_EID_IBSS_PARAMS:
493	elems->ibss_params = pos;	493	elems->ibss_params = pos;
494	elems->ibss_params_len = elen;	494	elems->ibss_params_len = elen;
495	break;	495	break;
496	case WLAN_EID_CHALLENGE:	496	case WLAN_EID_CHALLENGE:
497	elems->challenge = pos;	497	elems->challenge = pos;
498	elems->challenge_len = elen;	498	elems->challenge_len = elen;
499	break;	499	break;
500	case WLAN_EID_WPA:	500	case WLAN_EID_WPA:
501	if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&	501	if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
502	pos[2] == 0xf2) {	502	pos[2] == 0xf2) {
503	/* Microsoft OUI (00:50:F2) */	503	/* Microsoft OUI (00:50:F2) */
504	if (pos[3] == 1) {	504	if (pos[3] == 1) {
505	/* OUI Type 1 - WPA IE */	505	/* OUI Type 1 - WPA IE */
506	elems->wpa = pos;	506	elems->wpa = pos;
507	elems->wpa_len = elen;	507	elems->wpa_len = elen;
508	} else if (elen >= 5 && pos[3] == 2) {	508	} else if (elen >= 5 && pos[3] == 2) {
509	if (pos[4] == 0) {	509	if (pos[4] == 0) {
510	elems->wmm_info = pos;	510	elems->wmm_info = pos;
511	elems->wmm_info_len = elen;	511	elems->wmm_info_len = elen;
512	} else if (pos[4] == 1) {	512	} else if (pos[4] == 1) {
513	elems->wmm_param = pos;	513	elems->wmm_param = pos;
514	elems->wmm_param_len = elen;	514	elems->wmm_param_len = elen;
515	}	515	}
516	}	516	}
517	}	517	}
518	break;	518	break;
519	case WLAN_EID_RSN:	519	case WLAN_EID_RSN:
520	elems->rsn = pos;	520	elems->rsn = pos;
521	elems->rsn_len = elen;	521	elems->rsn_len = elen;
522	break;	522	break;
523	case WLAN_EID_ERP_INFO:	523	case WLAN_EID_ERP_INFO:
524	elems->erp_info = pos;	524	elems->erp_info = pos;
525	elems->erp_info_len = elen;	525	elems->erp_info_len = elen;
526	break;	526	break;
527	case WLAN_EID_EXT_SUPP_RATES:	527	case WLAN_EID_EXT_SUPP_RATES:
528	elems->ext_supp_rates = pos;	528	elems->ext_supp_rates = pos;
529	elems->ext_supp_rates_len = elen;	529	elems->ext_supp_rates_len = elen;
530	break;	530	break;
531	case WLAN_EID_HT_CAPABILITY:	531	case WLAN_EID_HT_CAPABILITY:
532	if (elen >= sizeof(struct ieee80211_ht_cap))	532	if (elen >= sizeof(struct ieee80211_ht_cap))
533	elems->ht_cap_elem = (void *)pos;	533	elems->ht_cap_elem = (void *)pos;
534	break;	534	break;
535	case WLAN_EID_HT_INFORMATION:	535	case WLAN_EID_HT_INFORMATION:
536	if (elen >= sizeof(struct ieee80211_ht_info))	536	if (elen >= sizeof(struct ieee80211_ht_info))
537	elems->ht_info_elem = (void *)pos;	537	elems->ht_info_elem = (void *)pos;
538	break;	538	break;
539	case WLAN_EID_MESH_ID:	539	case WLAN_EID_MESH_ID:
540	elems->mesh_id = pos;	540	elems->mesh_id = pos;
541	elems->mesh_id_len = elen;	541	elems->mesh_id_len = elen;
542	break;	542	break;
543	case WLAN_EID_MESH_CONFIG:	543	case WLAN_EID_MESH_CONFIG:
544	elems->mesh_config = pos;	544	elems->mesh_config = pos;
545	elems->mesh_config_len = elen;	545	elems->mesh_config_len = elen;
546	break;	546	break;
547	case WLAN_EID_PEER_LINK:	547	case WLAN_EID_PEER_LINK:
548	elems->peer_link = pos;	548	elems->peer_link = pos;
549	elems->peer_link_len = elen;	549	elems->peer_link_len = elen;
550	break;	550	break;
551	case WLAN_EID_PREQ:	551	case WLAN_EID_PREQ:
552	elems->preq = pos;	552	elems->preq = pos;
553	elems->preq_len = elen;	553	elems->preq_len = elen;
554	break;	554	break;
555	case WLAN_EID_PREP:	555	case WLAN_EID_PREP:
556	elems->prep = pos;	556	elems->prep = pos;
557	elems->prep_len = elen;	557	elems->prep_len = elen;
558	break;	558	break;
559	case WLAN_EID_PERR:	559	case WLAN_EID_PERR:
560	elems->perr = pos;	560	elems->perr = pos;
561	elems->perr_len = elen;	561	elems->perr_len = elen;
562	break;	562	break;
563	case WLAN_EID_CHANNEL_SWITCH:	563	case WLAN_EID_CHANNEL_SWITCH:
564	elems->ch_switch_elem = pos;	564	elems->ch_switch_elem = pos;
565	elems->ch_switch_elem_len = elen;	565	elems->ch_switch_elem_len = elen;
566	break;	566	break;
567	case WLAN_EID_QUIET:	567	case WLAN_EID_QUIET:
568	if (!elems->quiet_elem) {	568	if (!elems->quiet_elem) {
569	elems->quiet_elem = pos;	569	elems->quiet_elem = pos;
570	elems->quiet_elem_len = elen;	570	elems->quiet_elem_len = elen;
571	}	571	}
572	elems->num_of_quiet_elem++;	572	elems->num_of_quiet_elem++;
573	break;	573	break;
574	case WLAN_EID_COUNTRY:	574	case WLAN_EID_COUNTRY:
575	elems->country_elem = pos;	575	elems->country_elem = pos;
576	elems->country_elem_len = elen;	576	elems->country_elem_len = elen;
577	break;	577	break;
578	case WLAN_EID_PWR_CONSTRAINT:	578	case WLAN_EID_PWR_CONSTRAINT:
579	elems->pwr_constr_elem = pos;	579	elems->pwr_constr_elem = pos;
580	elems->pwr_constr_elem_len = elen;	580	elems->pwr_constr_elem_len = elen;
581	break;	581	break;
582	default:	582	default:
583	break;	583	break;
584	}	584	}
585		585
586	left -= elen;	586	left -= elen;
587	pos += elen;	587	pos += elen;
588	}	588	}
589	}	589	}
590		590
591	void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata)	591	void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata)
592	{	592	{
593	struct ieee80211_local *local = sdata->local;	593	struct ieee80211_local *local = sdata->local;
594	struct ieee80211_tx_queue_params qparam;	594	struct ieee80211_tx_queue_params qparam;
595	int i;	595	int i;
596		596
597	if (!local->ops->conf_tx)	597	if (!local->ops->conf_tx)
598	return;	598	return;
599		599
600	memset(&qparam, 0, sizeof(qparam));	600	memset(&qparam, 0, sizeof(qparam));
601		601
602	qparam.aifs = 2;	602	qparam.aifs = 2;
603		603
604	if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&	604	if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
605	!(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE))	605	!(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE))
606	qparam.cw_min = 31;	606	qparam.cw_min = 31;
607	else	607	else
608	qparam.cw_min = 15;	608	qparam.cw_min = 15;
609		609
610	qparam.cw_max = 1023;	610	qparam.cw_max = 1023;
611	qparam.txop = 0;	611	qparam.txop = 0;
612		612
613	for (i = 0; i < local_to_hw(local)->queues; i++)	613	for (i = 0; i < local_to_hw(local)->queues; i++)
614	local->ops->conf_tx(local_to_hw(local), i, &qparam);	614	local->ops->conf_tx(local_to_hw(local), i, &qparam);
615	}	615	}
616		616
617	void ieee80211_tx_skb(struct ieee80211_sub_if_data sdata, struct sk_buff skb,	617	void ieee80211_tx_skb(struct ieee80211_sub_if_data sdata, struct sk_buff skb,
618	int encrypt)	618	int encrypt)
619	{	619	{
620	skb->dev = sdata->local->mdev;	620	skb->dev = sdata->local->mdev;
621	skb_set_mac_header(skb, 0);	621	skb_set_mac_header(skb, 0);
622	skb_set_network_header(skb, 0);	622	skb_set_network_header(skb, 0);
623	skb_set_transport_header(skb, 0);	623	skb_set_transport_header(skb, 0);
624		624
625	skb->iif = sdata->dev->ifindex;	625	skb->iif = sdata->dev->ifindex;
626	skb->do_not_encrypt = !encrypt;	626	skb->do_not_encrypt = !encrypt;
627		627
628	dev_queue_xmit(skb);	628	dev_queue_xmit(skb);
629	}	629	}
630		630
631	int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freqMHz)	631	int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freqMHz)
632	{	632	{
633	int ret = -EINVAL;	633	int ret = -EINVAL;
634	struct ieee80211_channel *chan;	634	struct ieee80211_channel *chan;
635	struct ieee80211_local *local = sdata->local;	635	struct ieee80211_local *local = sdata->local;
636		636
637	chan = ieee80211_get_channel(local->hw.wiphy, freqMHz);	637	chan = ieee80211_get_channel(local->hw.wiphy, freqMHz);
638		638
639	if (chan && !(chan->flags & IEEE80211_CHAN_DISABLED)) {	639	if (chan && !(chan->flags & IEEE80211_CHAN_DISABLED)) {
640	if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&	640	if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
641	chan->flags & IEEE80211_CHAN_NO_IBSS)	641	chan->flags & IEEE80211_CHAN_NO_IBSS)
642	return ret;	642	return ret;
643	local->oper_channel = chan;	643	local->oper_channel = chan;
644	local->oper_sec_chan_offset = NL80211_SEC_CHAN_NO_HT;	644	local->oper_channel_type = NL80211_CHAN_NO_HT;
645		645
646	if (local->sw_scanning \|\| local->hw_scanning)	646	if (local->sw_scanning \|\| local->hw_scanning)
647	ret = 0;	647	ret = 0;
648	else	648	else
649	ret = ieee80211_hw_config(	649	ret = ieee80211_hw_config(
650	local, IEEE80211_CONF_CHANGE_CHANNEL);	650	local, IEEE80211_CONF_CHANGE_CHANNEL);
651	}	651	}
652		652
653	return ret;	653	return ret;
654	}	654	}
655		655
656	u64 ieee80211_mandatory_rates(struct ieee80211_local *local,	656	u64 ieee80211_mandatory_rates(struct ieee80211_local *local,
657	enum ieee80211_band band)	657	enum ieee80211_band band)
658	{	658	{
659	struct ieee80211_supported_band *sband;	659	struct ieee80211_supported_band *sband;
660	struct ieee80211_rate *bitrates;	660	struct ieee80211_rate *bitrates;
661	u64 mandatory_rates;	661	u64 mandatory_rates;
662	enum ieee80211_rate_flags mandatory_flag;	662	enum ieee80211_rate_flags mandatory_flag;
663	int i;	663	int i;
664		664
665	sband = local->hw.wiphy->bands[band];	665	sband = local->hw.wiphy->bands[band];
666	if (!sband) {	666	if (!sband) {
667	WARN_ON(1);	667	WARN_ON(1);
668	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];	668	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
669	}	669	}
670		670
671	if (band == IEEE80211_BAND_2GHZ)	671	if (band == IEEE80211_BAND_2GHZ)
672	mandatory_flag = IEEE80211_RATE_MANDATORY_B;	672	mandatory_flag = IEEE80211_RATE_MANDATORY_B;
673	else	673	else
674	mandatory_flag = IEEE80211_RATE_MANDATORY_A;	674	mandatory_flag = IEEE80211_RATE_MANDATORY_A;
675		675
676	bitrates = sband->bitrates;	676	bitrates = sband->bitrates;
677	mandatory_rates = 0;	677	mandatory_rates = 0;
678	for (i = 0; i < sband->n_bitrates; i++)	678	for (i = 0; i < sband->n_bitrates; i++)
679	if (bitrates[i].flags & mandatory_flag)	679	if (bitrates[i].flags & mandatory_flag)
680	mandatory_rates \|= BIT(i);	680	mandatory_rates \|= BIT(i);
681	return mandatory_rates;	681	return mandatory_rates;
682	}	682	}
683		683

net/wireless/nl80211.c

Diff comments View file @ 094d05d

 /*
  * This is the new netlink-based wireless configuration interface.
  *
  * Copyright 2006, 2007	Johannes Berg <johannes@sipsolutions.net>
  */
 #include <linux/if.h>
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/mutex.h>
 #include <linux/list.h>
 #include <linux/if_ether.h>
 #include <linux/ieee80211.h>
 #include <linux/nl80211.h>
 #include <linux/rtnetlink.h>
 #include <linux/netlink.h>
 #include <net/genetlink.h>
 #include <net/cfg80211.h>
 #include "core.h"
 #include "nl80211.h"
 #include "reg.h"
 /* the netlink family */
 static struct genl_family nl80211_fam = {
 	.id = GENL_ID_GENERATE,	/* don't bother with a hardcoded ID */
 	.name = "nl80211",	/* have users key off the name instead */
 	.hdrsize = 0,		/* no private header */
 	.version = 1,		/* no particular meaning now */
 	.maxattr = NL80211_ATTR_MAX,
 };
 /* internal helper: get drv and dev */
 static int get_drv_dev_by_info_ifindex(struct nlattr **attrs,
 				       struct cfg80211_registered_device **drv,
 				       struct net_device **dev)
 {
 	int ifindex;
 	if (!attrs[NL80211_ATTR_IFINDEX])
 		return -EINVAL;
 	ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
 	*dev = dev_get_by_index(&init_net, ifindex);
 	if (!*dev)
 		return -ENODEV;
 	*drv = cfg80211_get_dev_from_ifindex(ifindex);
 	if (IS_ERR(*drv)) {
 		dev_put(*dev);
 		return PTR_ERR(*drv);
 	}
 	return 0;
 }
 /* policy for the attributes */
 static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
 	[NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
 	[NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
 				      .len = BUS_ID_SIZE-1 },
 	[NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
 	[NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
-	[NL80211_ATTR_WIPHY_SEC_CHAN_OFFSET] = { .type = NLA_U32 },
+	[NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
 	[NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
 	[NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
 	[NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
 	[NL80211_ATTR_MAC] = { .type = NLA_BINARY, .len = ETH_ALEN },
 	[NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
 				    .len = WLAN_MAX_KEY_LEN },
 	[NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
 	[NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
 	[NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
 	[NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
 	[NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
 	[NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
 				       .len = IEEE80211_MAX_DATA_LEN },
 	[NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
 				       .len = IEEE80211_MAX_DATA_LEN },
 	[NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
 	[NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
 	[NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
 	[NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
 					       .len = NL80211_MAX_SUPP_RATES },
 	[NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
 	[NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
 	[NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
 	[NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
 				.len = IEEE80211_MAX_MESH_ID_LEN },
 	[NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
 	[NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
 	[NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
 	[NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
 	[NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
 	[NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
 	[NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
 					   .len = NL80211_MAX_SUPP_RATES },
 	[NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED },
 	[NL80211_ATTR_HT_CAPABILITY] = { .type = NLA_BINARY,
 					 .len = NL80211_HT_CAPABILITY_LEN },
 };
 /* message building helper */
 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
 				   int flags, u8 cmd)
 {
 	/* since there is no private header just add the generic one */
 	return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
 }
 /* netlink command implementations */
 static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
 			      struct cfg80211_registered_device *dev)
 {
 	void *hdr;
 	struct nlattr *nl_bands, *nl_band;
 	struct nlattr *nl_freqs, *nl_freq;
 	struct nlattr *nl_rates, *nl_rate;
 	struct nlattr *nl_modes;
 	enum ieee80211_band band;
 	struct ieee80211_channel *chan;
 	struct ieee80211_rate *rate;
 	int i;
 	u16 ifmodes = dev->wiphy.interface_modes;
 	hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
 	if (!hdr)
 		return -1;
 	NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->idx);
 	NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
 	nl_modes = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_IFTYPES);
 	if (!nl_modes)
 		goto nla_put_failure;
 	i = 0;
 	while (ifmodes) {
 		if (ifmodes & 1)
 			NLA_PUT_FLAG(msg, i);
 		ifmodes >>= 1;
 		i++;
 	}
 	nla_nest_end(msg, nl_modes);
 	nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
 	if (!nl_bands)
 		goto nla_put_failure;
 	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
 		if (!dev->wiphy.bands[band])
 			continue;
 		nl_band = nla_nest_start(msg, band);
 		if (!nl_band)
 			goto nla_put_failure;
 		/* add HT info */
 		if (dev->wiphy.bands[band]->ht_cap.ht_supported) {
 			NLA_PUT(msg, NL80211_BAND_ATTR_HT_MCS_SET,
 				sizeof(dev->wiphy.bands[band]->ht_cap.mcs),
 				&dev->wiphy.bands[band]->ht_cap.mcs);
 			NLA_PUT_U16(msg, NL80211_BAND_ATTR_HT_CAPA,
 				dev->wiphy.bands[band]->ht_cap.cap);
 			NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
 				dev->wiphy.bands[band]->ht_cap.ampdu_factor);
 			NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
 				dev->wiphy.bands[band]->ht_cap.ampdu_density);
 		}
 		/* add frequencies */
 		nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS);
 		if (!nl_freqs)
 			goto nla_put_failure;
 		for (i = 0; i < dev->wiphy.bands[band]->n_channels; i++) {
 			nl_freq = nla_nest_start(msg, i);
 			if (!nl_freq)
 				goto nla_put_failure;
 			chan = &dev->wiphy.bands[band]->channels[i];
 			NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_FREQ,
 				    chan->center_freq);
 			if (chan->flags & IEEE80211_CHAN_DISABLED)
 				NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_DISABLED);
 			if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
 				NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN);
 			if (chan->flags & IEEE80211_CHAN_NO_IBSS)
 				NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_NO_IBSS);
 			if (chan->flags & IEEE80211_CHAN_RADAR)
 				NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_RADAR);
 			NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
 				    DBM_TO_MBM(chan->max_power));
 			nla_nest_end(msg, nl_freq);
 		}
 		nla_nest_end(msg, nl_freqs);
 		/* add bitrates */
 		nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
 		if (!nl_rates)
 			goto nla_put_failure;
 		for (i = 0; i < dev->wiphy.bands[band]->n_bitrates; i++) {
 			nl_rate = nla_nest_start(msg, i);
 			if (!nl_rate)
 				goto nla_put_failure;
 			rate = &dev->wiphy.bands[band]->bitrates[i];
 			NLA_PUT_U32(msg, NL80211_BITRATE_ATTR_RATE,
 				    rate->bitrate);
 			if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
 				NLA_PUT_FLAG(msg,
 					NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE);
 			nla_nest_end(msg, nl_rate);
 		}
 		nla_nest_end(msg, nl_rates);
 		nla_nest_end(msg, nl_band);
 	}
 	nla_nest_end(msg, nl_bands);
 	return genlmsg_end(msg, hdr);
  nla_put_failure:
 	genlmsg_cancel(msg, hdr);
 	return -EMSGSIZE;
 }
 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
 {
 	int idx = 0;
 	int start = cb->args[0];
 	struct cfg80211_registered_device *dev;
 	mutex_lock(&cfg80211_drv_mutex);
 	list_for_each_entry(dev, &cfg80211_drv_list, list) {
 		if (++idx <= start)
 			continue;
 		if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
 				       cb->nlh->nlmsg_seq, NLM_F_MULTI,
 				       dev) < 0) {
 			idx--;
 			break;
 		}
 	}
 	mutex_unlock(&cfg80211_drv_mutex);
 	cb->args[0] = idx;
 	return skb->len;
 }
 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
 {
 	struct sk_buff *msg;
 	struct cfg80211_registered_device *dev;
 	dev = cfg80211_get_dev_from_info(info);
 	if (IS_ERR(dev))
 		return PTR_ERR(dev);
 	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 	if (!msg)
 		goto out_err;
 	if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0)
 		goto out_free;
 	cfg80211_put_dev(dev);
 	return genlmsg_unicast(msg, info->snd_pid);
  out_free:
 	nlmsg_free(msg);
  out_err:
 	cfg80211_put_dev(dev);
 	return -ENOBUFS;
 }
 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
 	[NL80211_TXQ_ATTR_QUEUE]		= { .type = NLA_U8 },
 	[NL80211_TXQ_ATTR_TXOP]			= { .type = NLA_U16 },
 	[NL80211_TXQ_ATTR_CWMIN]		= { .type = NLA_U16 },
 	[NL80211_TXQ_ATTR_CWMAX]		= { .type = NLA_U16 },
 	[NL80211_TXQ_ATTR_AIFS]			= { .type = NLA_U8 },
 };
 static int parse_txq_params(struct nlattr *tb[],
 			    struct ieee80211_txq_params *txq_params)
 {
 	if (!tb[NL80211_TXQ_ATTR_QUEUE] || !tb[NL80211_TXQ_ATTR_TXOP] ||
 	    !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
 	    !tb[NL80211_TXQ_ATTR_AIFS])
 		return -EINVAL;
 	txq_params->queue = nla_get_u8(tb[NL80211_TXQ_ATTR_QUEUE]);
 	txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
 	txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
 	txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
 	txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
 	return 0;
 }
 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *rdev;
 	int result = 0, rem_txq_params = 0;
 	struct nlattr *nl_txq_params;
 	rdev = cfg80211_get_dev_from_info(info);
 	if (IS_ERR(rdev))
 		return PTR_ERR(rdev);
 	if (info->attrs[NL80211_ATTR_WIPHY_NAME]) {
 		result = cfg80211_dev_rename(
 			rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
 		if (result)
 			goto bad_res;
 	}
 	if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
 		struct ieee80211_txq_params txq_params;
 		struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
 		if (!rdev->ops->set_txq_params) {
 			result = -EOPNOTSUPP;
 			goto bad_res;
 		}
 		nla_for_each_nested(nl_txq_params,
 				    info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
 				    rem_txq_params) {
 			nla_parse(tb, NL80211_TXQ_ATTR_MAX,
 				  nla_data(nl_txq_params),
 				  nla_len(nl_txq_params),
 				  txq_params_policy);
 			result = parse_txq_params(tb, &txq_params);
 			if (result)
 				goto bad_res;
 			result = rdev->ops->set_txq_params(&rdev->wiphy,
 							   &txq_params);
 			if (result)
 				goto bad_res;
 		}
 	}
 	if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
-		enum nl80211_sec_chan_offset sec_chan_offset =
+		enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
-			NL80211_SEC_CHAN_NO_HT;
 		struct ieee80211_channel *chan;
 		struct ieee80211_sta_ht_cap *ht_cap;
 		u32 freq, sec_freq;
 		if (!rdev->ops->set_channel) {
 			result = -EOPNOTSUPP;
 			goto bad_res;
 		}
 		result = -EINVAL;
-		if (info->attrs[NL80211_ATTR_WIPHY_SEC_CHAN_OFFSET]) {
+		if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
-			sec_chan_offset = nla_get_u32(info->attrs[
+			channel_type = nla_get_u32(info->attrs[
-					NL80211_ATTR_WIPHY_SEC_CHAN_OFFSET]);
+					   NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
-			if (sec_chan_offset != NL80211_SEC_CHAN_NO_HT &&
+			if (channel_type != NL80211_CHAN_NO_HT &&
-			    sec_chan_offset != NL80211_SEC_CHAN_DISABLED &&
+			    channel_type != NL80211_CHAN_HT20 &&
-			    sec_chan_offset != NL80211_SEC_CHAN_BELOW &&
+			    channel_type != NL80211_CHAN_HT40PLUS &&
-			    sec_chan_offset != NL80211_SEC_CHAN_ABOVE)
+			    channel_type != NL80211_CHAN_HT40MINUS)
 				goto bad_res;
 		}
 		freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
 		chan = ieee80211_get_channel(&rdev->wiphy, freq);
 		/* Primary channel not allowed */
 		if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
 			goto bad_res;
-		if (sec_chan_offset == NL80211_SEC_CHAN_BELOW)
+		if (channel_type == NL80211_CHAN_HT40MINUS)
 			sec_freq = freq - 20;
-		else if (sec_chan_offset == NL80211_SEC_CHAN_ABOVE)
+		else if (channel_type == NL80211_CHAN_HT40PLUS)
 			sec_freq = freq + 20;
 		else
 			sec_freq = 0;
 		ht_cap = &rdev->wiphy.bands[chan->band]->ht_cap;
 		/* no HT capabilities */
-		if (sec_chan_offset != NL80211_SEC_CHAN_NO_HT &&
+		if (channel_type != NL80211_CHAN_NO_HT &&
 		    !ht_cap->ht_supported)
 			goto bad_res;
 		if (sec_freq) {
 			struct ieee80211_channel *schan;
 			/* no 40 MHz capabilities */
 			if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
 			    (ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT))
 				goto bad_res;
 			schan = ieee80211_get_channel(&rdev->wiphy, sec_freq);
 			/* Secondary channel not allowed */
 			if (!schan || schan->flags & IEEE80211_CHAN_DISABLED)
 				goto bad_res;
 		}
 		result = rdev->ops->set_channel(&rdev->wiphy, chan,
-						sec_chan_offset);
+						channel_type);
 		if (result)
 			goto bad_res;
 	}
  bad_res:
 	cfg80211_put_dev(rdev);
 	return result;
 }
 static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
 			      struct net_device *dev)
 {
 	void *hdr;
 	hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
 	if (!hdr)
 		return -1;
 	NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 	NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name);
 	NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, dev->ieee80211_ptr->iftype);
 	return genlmsg_end(msg, hdr);
  nla_put_failure:
 	genlmsg_cancel(msg, hdr);
 	return -EMSGSIZE;
 }
 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
 {
 	int wp_idx = 0;
 	int if_idx = 0;
 	int wp_start = cb->args[0];
 	int if_start = cb->args[1];
 	struct cfg80211_registered_device *dev;
 	struct wireless_dev *wdev;
 	mutex_lock(&cfg80211_drv_mutex);
 	list_for_each_entry(dev, &cfg80211_drv_list, list) {
 		if (wp_idx < wp_start) {
 			wp_idx++;
 			continue;
 		}
 		if_idx = 0;
 		mutex_lock(&dev->devlist_mtx);
 		list_for_each_entry(wdev, &dev->netdev_list, list) {
 			if (if_idx < if_start) {
 				if_idx++;
 				continue;
 			}
 			if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
 					       cb->nlh->nlmsg_seq, NLM_F_MULTI,
 					       wdev->netdev) < 0) {
 				mutex_unlock(&dev->devlist_mtx);
 				goto out;
 			}
 			if_idx++;
 		}
 		mutex_unlock(&dev->devlist_mtx);
 		wp_idx++;
 	}
  out:
 	mutex_unlock(&cfg80211_drv_mutex);
 	cb->args[0] = wp_idx;
 	cb->args[1] = if_idx;
 	return skb->len;
 }
 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
 {
 	struct sk_buff *msg;
 	struct cfg80211_registered_device *dev;
 	struct net_device *netdev;
 	int err;
 	err = get_drv_dev_by_info_ifindex(info->attrs, &dev, &netdev);
 	if (err)
 		return err;
 	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 	if (!msg)
 		goto out_err;
 	if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0, netdev) < 0)
 		goto out_free;
 	dev_put(netdev);
 	cfg80211_put_dev(dev);
 	return genlmsg_unicast(msg, info->snd_pid);
  out_free:
 	nlmsg_free(msg);
  out_err:
 	dev_put(netdev);
 	cfg80211_put_dev(dev);
 	return -ENOBUFS;
 }
 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
 	[NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
 	[NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
 	[NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
 	[NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
 	[NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
 };
 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
 {
 	struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
 	int flag;
 	*mntrflags = 0;
 	if (!nla)
 		return -EINVAL;
 	if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
 			     nla, mntr_flags_policy))
 		return -EINVAL;
 	for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
 		if (flags[flag])
 			*mntrflags |= (1<<flag);
 	return 0;
 }
 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	struct vif_params params;
 	int err, ifindex;
 	enum nl80211_iftype type;
 	struct net_device *dev;
 	u32 _flags, *flags = NULL;
 	memset(&params, 0, sizeof(params));
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	ifindex = dev->ifindex;
 	type = dev->ieee80211_ptr->iftype;
 	dev_put(dev);
 	err = -EINVAL;
 	if (info->attrs[NL80211_ATTR_IFTYPE]) {
 		type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
 		if (type > NL80211_IFTYPE_MAX)
 			goto unlock;
 	}
 	if (!drv->ops->change_virtual_intf ||
 	    !(drv->wiphy.interface_modes & (1 << type))) {
 		err = -EOPNOTSUPP;
 		goto unlock;
 	}
 	if (info->attrs[NL80211_ATTR_MESH_ID]) {
 		if (type != NL80211_IFTYPE_MESH_POINT) {
 			err = -EINVAL;
 			goto unlock;
 		}
 		params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
 		params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
 	}
 	if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
 		if (type != NL80211_IFTYPE_MONITOR) {
 			err = -EINVAL;
 			goto unlock;
 		}
 		err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
 					  &_flags);
 		if (!err)
 			flags = &_flags;
 	}
 	rtnl_lock();
 	err = drv->ops->change_virtual_intf(&drv->wiphy, ifindex,
 					    type, flags, &params);
 	dev = __dev_get_by_index(&init_net, ifindex);
 	WARN_ON(!dev || (!err && dev->ieee80211_ptr->iftype != type));
 	rtnl_unlock();
  unlock:
 	cfg80211_put_dev(drv);
 	return err;
 }
 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	struct vif_params params;
 	int err;
 	enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
 	u32 flags;
 	memset(&params, 0, sizeof(params));
 	if (!info->attrs[NL80211_ATTR_IFNAME])
 		return -EINVAL;
 	if (info->attrs[NL80211_ATTR_IFTYPE]) {
 		type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
 		if (type > NL80211_IFTYPE_MAX)
 			return -EINVAL;
 	}
 	drv = cfg80211_get_dev_from_info(info);
 	if (IS_ERR(drv))
 		return PTR_ERR(drv);
 	if (!drv->ops->add_virtual_intf ||
 	    !(drv->wiphy.interface_modes & (1 << type))) {
 		err = -EOPNOTSUPP;
 		goto unlock;
 	}
 	if (type == NL80211_IFTYPE_MESH_POINT &&
 	    info->attrs[NL80211_ATTR_MESH_ID]) {
 		params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
 		params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
 	}
 	rtnl_lock();
 	err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
 				  info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
 				  &flags);
 	err = drv->ops->add_virtual_intf(&drv->wiphy,
 		nla_data(info->attrs[NL80211_ATTR_IFNAME]),
 		type, err ? NULL : &flags, &params);
 	rtnl_unlock();
  unlock:
 	cfg80211_put_dev(drv);
 	return err;
 }
 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int ifindex, err;
 	struct net_device *dev;
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	ifindex = dev->ifindex;
 	dev_put(dev);
 	if (!drv->ops->del_virtual_intf) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->del_virtual_intf(&drv->wiphy, ifindex);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	return err;
 }
 struct get_key_cookie {
 	struct sk_buff *msg;
 	int error;
 };
 static void get_key_callback(void *c, struct key_params *params)
 {
 	struct get_key_cookie *cookie = c;
 	if (params->key)
 		NLA_PUT(cookie->msg, NL80211_ATTR_KEY_DATA,
 			params->key_len, params->key);
 	if (params->seq)
 		NLA_PUT(cookie->msg, NL80211_ATTR_KEY_SEQ,
 			params->seq_len, params->seq);
 	if (params->cipher)
 		NLA_PUT_U32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
 			    params->cipher);
 	return;
  nla_put_failure:
 	cookie->error = 1;
 }
 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	u8 key_idx = 0;
 	u8 *mac_addr = NULL;
 	struct get_key_cookie cookie = {
 		.error = 0,
 	};
 	void *hdr;
 	struct sk_buff *msg;
 	if (info->attrs[NL80211_ATTR_KEY_IDX])
 		key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 	if (key_idx > 3)
 		return -EINVAL;
 	if (info->attrs[NL80211_ATTR_MAC])
 		mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->get_key) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 	if (!msg) {
 		err = -ENOMEM;
 		goto out;
 	}
 	hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
 			     NL80211_CMD_NEW_KEY);
 	if (IS_ERR(hdr)) {
 		err = PTR_ERR(hdr);
 		goto out;
 	}
 	cookie.msg = msg;
 	NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 	NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
 	if (mac_addr)
 		NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
 	rtnl_lock();
 	err = drv->ops->get_key(&drv->wiphy, dev, key_idx, mac_addr,
 				&cookie, get_key_callback);
 	rtnl_unlock();
 	if (err)
 		goto out;
 	if (cookie.error)
 		goto nla_put_failure;
 	genlmsg_end(msg, hdr);
 	err = genlmsg_unicast(msg, info->snd_pid);
 	goto out;
  nla_put_failure:
 	err = -ENOBUFS;
 	nlmsg_free(msg);
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	u8 key_idx;
 	if (!info->attrs[NL80211_ATTR_KEY_IDX])
 		return -EINVAL;
 	key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 	if (key_idx > 3)
 		return -EINVAL;
 	/* currently only support setting default key */
 	if (!info->attrs[NL80211_ATTR_KEY_DEFAULT])
 		return -EINVAL;
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->set_default_key) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->set_default_key(&drv->wiphy, dev, key_idx);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	struct key_params params;
 	u8 key_idx = 0;
 	u8 *mac_addr = NULL;
 	memset(&params, 0, sizeof(params));
 	if (!info->attrs[NL80211_ATTR_KEY_CIPHER])
 		return -EINVAL;
 	if (info->attrs[NL80211_ATTR_KEY_DATA]) {
 		params.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
 		params.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
 	}
 	if (info->attrs[NL80211_ATTR_KEY_IDX])
 		key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 	params.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
 	if (info->attrs[NL80211_ATTR_MAC])
 		mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	if (key_idx > 3)
 		return -EINVAL;
 	/*
 	 * Disallow pairwise keys with non-zero index unless it's WEP
 	 * (because current deployments use pairwise WEP keys with
 	 * non-zero indizes but 802.11i clearly specifies to use zero)
 	 */
 	if (mac_addr && key_idx &&
 	    params.cipher != WLAN_CIPHER_SUITE_WEP40 &&
 	    params.cipher != WLAN_CIPHER_SUITE_WEP104)
 		return -EINVAL;
 	/* TODO: add definitions for the lengths to linux/ieee80211.h */
 	switch (params.cipher) {
 	case WLAN_CIPHER_SUITE_WEP40:
 		if (params.key_len != 5)
 			return -EINVAL;
 		break;
 	case WLAN_CIPHER_SUITE_TKIP:
 		if (params.key_len != 32)
 			return -EINVAL;
 		break;
 	case WLAN_CIPHER_SUITE_CCMP:
 		if (params.key_len != 16)
 			return -EINVAL;
 		break;
 	case WLAN_CIPHER_SUITE_WEP104:
 		if (params.key_len != 13)
 			return -EINVAL;
 		break;
 	default:
 		return -EINVAL;
 	}
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->add_key) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->add_key(&drv->wiphy, dev, key_idx, mac_addr, &params);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	u8 key_idx = 0;
 	u8 *mac_addr = NULL;
 	if (info->attrs[NL80211_ATTR_KEY_IDX])
 		key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
 	if (key_idx > 3)
 		return -EINVAL;
 	if (info->attrs[NL80211_ATTR_MAC])
 		mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->del_key) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->del_key(&drv->wiphy, dev, key_idx, mac_addr);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info)
 {
         int (*call)(struct wiphy *wiphy, struct net_device *dev,
 		    struct beacon_parameters *info);
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	struct beacon_parameters params;
 	int haveinfo = 0;
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	switch (info->genlhdr->cmd) {
 	case NL80211_CMD_NEW_BEACON:
 		/* these are required for NEW_BEACON */
 		if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
 		    !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
 		    !info->attrs[NL80211_ATTR_BEACON_HEAD]) {
 			err = -EINVAL;
 			goto out;
 		}
 		call = drv->ops->add_beacon;
 		break;
 	case NL80211_CMD_SET_BEACON:
 		call = drv->ops->set_beacon;
 		break;
 	default:
 		WARN_ON(1);
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	if (!call) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	memset(&params, 0, sizeof(params));
 	if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
 		params.interval =
 		    nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
 		haveinfo = 1;
 	}
 	if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
 		params.dtim_period =
 		    nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
 		haveinfo = 1;
 	}
 	if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
 		params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
 		params.head_len =
 		    nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
 		haveinfo = 1;
 	}
 	if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
 		params.tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
 		params.tail_len =
 		    nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
 		haveinfo = 1;
 	}
 	if (!haveinfo) {
 		err = -EINVAL;
 		goto out;
 	}
 	rtnl_lock();
 	err = call(&drv->wiphy, dev, &params);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->del_beacon) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->del_beacon(&drv->wiphy, dev);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
 	[NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
 	[NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
 	[NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
 };
 static int parse_station_flags(struct nlattr *nla, u32 *staflags)
 {
 	struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
 	int flag;
 	*staflags = 0;
 	if (!nla)
 		return 0;
 	if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
 			     nla, sta_flags_policy))
 		return -EINVAL;
 	*staflags = STATION_FLAG_CHANGED;
 	for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++)
 		if (flags[flag])
 			*staflags |= (1<<flag);
 	return 0;
 }
 static u16 nl80211_calculate_bitrate(struct rate_info *rate)
 {
 	int modulation, streams, bitrate;
 	if (!(rate->flags & RATE_INFO_FLAGS_MCS))
 		return rate->legacy;
 	/* the formula below does only work for MCS values smaller than 32 */
 	if (rate->mcs >= 32)
 		return 0;
 	modulation = rate->mcs & 7;
 	streams = (rate->mcs >> 3) + 1;
 	bitrate = (rate->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH) ?
 			13500000 : 6500000;
 	if (modulation < 4)
 		bitrate *= (modulation + 1);
 	else if (modulation == 4)
 		bitrate *= (modulation + 2);
 	else
 		bitrate *= (modulation + 3);
 	bitrate *= streams;
 	if (rate->flags & RATE_INFO_FLAGS_SHORT_GI)
 		bitrate = (bitrate / 9) * 10;
 	/* do NOT round down here */
 	return (bitrate + 50000) / 100000;
 }
 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
 				int flags, struct net_device *dev,
 				u8 *mac_addr, struct station_info *sinfo)
 {
 	void *hdr;
 	struct nlattr *sinfoattr, *txrate;
 	u16 bitrate;
 	hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
 	if (!hdr)
 		return -1;
 	NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 	NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
 	sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
 	if (!sinfoattr)
 		goto nla_put_failure;
 	if (sinfo->filled & STATION_INFO_INACTIVE_TIME)
 		NLA_PUT_U32(msg, NL80211_STA_INFO_INACTIVE_TIME,
 			    sinfo->inactive_time);
 	if (sinfo->filled & STATION_INFO_RX_BYTES)
 		NLA_PUT_U32(msg, NL80211_STA_INFO_RX_BYTES,
 			    sinfo->rx_bytes);
 	if (sinfo->filled & STATION_INFO_TX_BYTES)
 		NLA_PUT_U32(msg, NL80211_STA_INFO_TX_BYTES,
 			    sinfo->tx_bytes);
 	if (sinfo->filled & STATION_INFO_LLID)
 		NLA_PUT_U16(msg, NL80211_STA_INFO_LLID,
 			    sinfo->llid);
 	if (sinfo->filled & STATION_INFO_PLID)
 		NLA_PUT_U16(msg, NL80211_STA_INFO_PLID,
 			    sinfo->plid);
 	if (sinfo->filled & STATION_INFO_PLINK_STATE)
 		NLA_PUT_U8(msg, NL80211_STA_INFO_PLINK_STATE,
 			    sinfo->plink_state);
 	if (sinfo->filled & STATION_INFO_SIGNAL)
 		NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL,
 			   sinfo->signal);
 	if (sinfo->filled & STATION_INFO_TX_BITRATE) {
 		txrate = nla_nest_start(msg, NL80211_STA_INFO_TX_BITRATE);
 		if (!txrate)
 			goto nla_put_failure;
 		/* nl80211_calculate_bitrate will return 0 for mcs >= 32 */
 		bitrate = nl80211_calculate_bitrate(&sinfo->txrate);
 		if (bitrate > 0)
 			NLA_PUT_U16(msg, NL80211_RATE_INFO_BITRATE, bitrate);
 		if (sinfo->txrate.flags & RATE_INFO_FLAGS_MCS)
 			NLA_PUT_U8(msg, NL80211_RATE_INFO_MCS,
 				    sinfo->txrate.mcs);
 		if (sinfo->txrate.flags & RATE_INFO_FLAGS_40_MHZ_WIDTH)
 			NLA_PUT_FLAG(msg, NL80211_RATE_INFO_40_MHZ_WIDTH);
 		if (sinfo->txrate.flags & RATE_INFO_FLAGS_SHORT_GI)
 			NLA_PUT_FLAG(msg, NL80211_RATE_INFO_SHORT_GI);
 		nla_nest_end(msg, txrate);
 	}
 	nla_nest_end(msg, sinfoattr);
 	return genlmsg_end(msg, hdr);
  nla_put_failure:
 	genlmsg_cancel(msg, hdr);
 	return -EMSGSIZE;
 }
 static int nl80211_dump_station(struct sk_buff *skb,
 				struct netlink_callback *cb)
 {
 	struct station_info sinfo;
 	struct cfg80211_registered_device *dev;
 	struct net_device *netdev;
 	u8 mac_addr[ETH_ALEN];
 	int ifidx = cb->args[0];
 	int sta_idx = cb->args[1];
 	int err;
 	if (!ifidx) {
 		err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
 				  nl80211_fam.attrbuf, nl80211_fam.maxattr,
 				  nl80211_policy);
 		if (err)
 			return err;
 		if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
 			return -EINVAL;
 		ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
 		if (!ifidx)
 			return -EINVAL;
 	}
 	netdev = dev_get_by_index(&init_net, ifidx);
 	if (!netdev)
 		return -ENODEV;
 	dev = cfg80211_get_dev_from_ifindex(ifidx);
 	if (IS_ERR(dev)) {
 		err = PTR_ERR(dev);
 		goto out_put_netdev;
 	}
 	if (!dev->ops->dump_station) {
 		err = -ENOSYS;
 		goto out_err;
 	}
 	rtnl_lock();
 	while (1) {
 		err = dev->ops->dump_station(&dev->wiphy, netdev, sta_idx,
 					     mac_addr, &sinfo);
 		if (err == -ENOENT)
 			break;
 		if (err)
 			goto out_err_rtnl;
 		if (nl80211_send_station(skb,
 				NETLINK_CB(cb->skb).pid,
 				cb->nlh->nlmsg_seq, NLM_F_MULTI,
 				netdev, mac_addr,
 				&sinfo) < 0)
 			goto out;
 		sta_idx++;
 	}
  out:
 	cb->args[1] = sta_idx;
 	err = skb->len;
  out_err_rtnl:
 	rtnl_unlock();
  out_err:
 	cfg80211_put_dev(dev);
  out_put_netdev:
 	dev_put(netdev);
 	return err;
 }
 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	struct station_info sinfo;
 	struct sk_buff *msg;
 	u8 *mac_addr = NULL;
 	memset(&sinfo, 0, sizeof(sinfo));
 	if (!info->attrs[NL80211_ATTR_MAC])
 		return -EINVAL;
 	mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->get_station) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->get_station(&drv->wiphy, dev, mac_addr, &sinfo);
 	rtnl_unlock();
 	if (err)
 		goto out;
 	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 	if (!msg)
 		goto out;
 	if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
 				 dev, mac_addr, &sinfo) < 0)
 		goto out_free;
 	err = genlmsg_unicast(msg, info->snd_pid);
 	goto out;
  out_free:
 	nlmsg_free(msg);
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 /*
  * Get vlan interface making sure it is on the right wiphy.
  */
 static int get_vlan(struct nlattr *vlanattr,
 		    struct cfg80211_registered_device *rdev,
 		    struct net_device **vlan)
 {
 	*vlan = NULL;
 	if (vlanattr) {
 		*vlan = dev_get_by_index(&init_net, nla_get_u32(vlanattr));
 		if (!*vlan)
 			return -ENODEV;
 		if (!(*vlan)->ieee80211_ptr)
 			return -EINVAL;
 		if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy)
 			return -EINVAL;
 	}
 	return 0;
 }
 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	struct station_parameters params;
 	u8 *mac_addr = NULL;
 	memset(&params, 0, sizeof(params));
 	params.listen_interval = -1;
 	if (info->attrs[NL80211_ATTR_STA_AID])
 		return -EINVAL;
 	if (!info->attrs[NL80211_ATTR_MAC])
 		return -EINVAL;
 	mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
 		params.supported_rates =
 			nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
 		params.supported_rates_len =
 			nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
 	}
 	if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
 		params.listen_interval =
 		    nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
 	if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
 		params.ht_capa =
 			nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
 	if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
 				&params.station_flags))
 		return -EINVAL;
 	if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
 		params.plink_action =
 		    nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
 	if (err)
 		goto out;
 	if (!drv->ops->change_station) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->change_station(&drv->wiphy, dev, mac_addr, &params);
 	rtnl_unlock();
  out:
 	if (params.vlan)
 		dev_put(params.vlan);
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	struct station_parameters params;
 	u8 *mac_addr = NULL;
 	memset(&params, 0, sizeof(params));
 	if (!info->attrs[NL80211_ATTR_MAC])
 		return -EINVAL;
 	if (!info->attrs[NL80211_ATTR_STA_AID])
 		return -EINVAL;
 	if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
 		return -EINVAL;
 	if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
 		return -EINVAL;
 	mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	params.supported_rates =
 		nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
 	params.supported_rates_len =
 		nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
 	params.listen_interval =
 		nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
 	params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
 	if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
 		params.ht_capa =
 			nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
 	if (parse_station_flags(info->attrs[NL80211_ATTR_STA_FLAGS],
 				&params.station_flags))
 		return -EINVAL;
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	err = get_vlan(info->attrs[NL80211_ATTR_STA_VLAN], drv, &params.vlan);
 	if (err)
 		goto out;
 	if (!drv->ops->add_station) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->add_station(&drv->wiphy, dev, mac_addr, &params);
 	rtnl_unlock();
  out:
 	if (params.vlan)
 		dev_put(params.vlan);
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	u8 *mac_addr = NULL;
 	if (info->attrs[NL80211_ATTR_MAC])
 		mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->del_station) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->del_station(&drv->wiphy, dev, mac_addr);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq,
 				int flags, struct net_device *dev,
 				u8 *dst, u8 *next_hop,
 				struct mpath_info *pinfo)
 {
 	void *hdr;
 	struct nlattr *pinfoattr;
 	hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
 	if (!hdr)
 		return -1;
 	NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 	NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, dst);
 	NLA_PUT(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop);
 	pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
 	if (!pinfoattr)
 		goto nla_put_failure;
 	if (pinfo->filled & MPATH_INFO_FRAME_QLEN)
 		NLA_PUT_U32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
 			    pinfo->frame_qlen);
 	if (pinfo->filled & MPATH_INFO_DSN)
 		NLA_PUT_U32(msg, NL80211_MPATH_INFO_DSN,
 			    pinfo->dsn);
 	if (pinfo->filled & MPATH_INFO_METRIC)
 		NLA_PUT_U32(msg, NL80211_MPATH_INFO_METRIC,
 			    pinfo->metric);
 	if (pinfo->filled & MPATH_INFO_EXPTIME)
 		NLA_PUT_U32(msg, NL80211_MPATH_INFO_EXPTIME,
 			    pinfo->exptime);
 	if (pinfo->filled & MPATH_INFO_FLAGS)
 		NLA_PUT_U8(msg, NL80211_MPATH_INFO_FLAGS,
 			    pinfo->flags);
 	if (pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT)
 		NLA_PUT_U32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
 			    pinfo->discovery_timeout);
 	if (pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES)
 		NLA_PUT_U8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
 			    pinfo->discovery_retries);
 	nla_nest_end(msg, pinfoattr);
 	return genlmsg_end(msg, hdr);
  nla_put_failure:
 	genlmsg_cancel(msg, hdr);
 	return -EMSGSIZE;
 }
 static int nl80211_dump_mpath(struct sk_buff *skb,
 			      struct netlink_callback *cb)
 {
 	struct mpath_info pinfo;
 	struct cfg80211_registered_device *dev;
 	struct net_device *netdev;
 	u8 dst[ETH_ALEN];
 	u8 next_hop[ETH_ALEN];
 	int ifidx = cb->args[0];
 	int path_idx = cb->args[1];
 	int err;
 	if (!ifidx) {
 		err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
 				  nl80211_fam.attrbuf, nl80211_fam.maxattr,
 				  nl80211_policy);
 		if (err)
 			return err;
 		if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
 			return -EINVAL;
 		ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
 		if (!ifidx)
 			return -EINVAL;
 	}
 	netdev = dev_get_by_index(&init_net, ifidx);
 	if (!netdev)
 		return -ENODEV;
 	dev = cfg80211_get_dev_from_ifindex(ifidx);
 	if (IS_ERR(dev)) {
 		err = PTR_ERR(dev);
 		goto out_put_netdev;
 	}
 	if (!dev->ops->dump_mpath) {
 		err = -ENOSYS;
 		goto out_err;
 	}
 	rtnl_lock();
 	while (1) {
 		err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx,
 					   dst, next_hop, &pinfo);
 		if (err == -ENOENT)
 			break;
 		if (err)
 			goto out_err_rtnl;
 		if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).pid,
 				       cb->nlh->nlmsg_seq, NLM_F_MULTI,
 				       netdev, dst, next_hop,
 				       &pinfo) < 0)
 			goto out;
 		path_idx++;
 	}
  out:
 	cb->args[1] = path_idx;
 	err = skb->len;
  out_err_rtnl:
 	rtnl_unlock();
  out_err:
 	cfg80211_put_dev(dev);
  out_put_netdev:
 	dev_put(netdev);
 	return err;
 }
 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	struct mpath_info pinfo;
 	struct sk_buff *msg;
 	u8 *dst = NULL;
 	u8 next_hop[ETH_ALEN];
 	memset(&pinfo, 0, sizeof(pinfo));
 	if (!info->attrs[NL80211_ATTR_MAC])
 		return -EINVAL;
 	dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->get_mpath) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->get_mpath(&drv->wiphy, dev, dst, next_hop, &pinfo);
 	rtnl_unlock();
 	if (err)
 		goto out;
 	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 	if (!msg)
 		goto out;
 	if (nl80211_send_mpath(msg, info->snd_pid, info->snd_seq, 0,
 				 dev, dst, next_hop, &pinfo) < 0)
 		goto out_free;
 	err = genlmsg_unicast(msg, info->snd_pid);
 	goto out;
  out_free:
 	nlmsg_free(msg);
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	u8 *dst = NULL;
 	u8 *next_hop = NULL;
 	if (!info->attrs[NL80211_ATTR_MAC])
 		return -EINVAL;
 	if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
 		return -EINVAL;
 	dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->change_mpath) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->change_mpath(&drv->wiphy, dev, dst, next_hop);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	u8 *dst = NULL;
 	u8 *next_hop = NULL;
 	if (!info->attrs[NL80211_ATTR_MAC])
 		return -EINVAL;
 	if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
 		return -EINVAL;
 	dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->add_mpath) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->add_mpath(&drv->wiphy, dev, dst, next_hop);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	u8 *dst = NULL;
 	if (info->attrs[NL80211_ATTR_MAC])
 		dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->del_mpath) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->del_mpath(&drv->wiphy, dev, dst);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	int err;
 	struct net_device *dev;
 	struct bss_parameters params;
 	memset(&params, 0, sizeof(params));
 	/* default to not changing parameters */
 	params.use_cts_prot = -1;
 	params.use_short_preamble = -1;
 	params.use_short_slot_time = -1;
 	if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
 		params.use_cts_prot =
 		    nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
 	if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
 		params.use_short_preamble =
 		    nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
 	if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
 		params.use_short_slot_time =
 		    nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
 	if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
 		params.basic_rates =
 			nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
 		params.basic_rates_len =
 			nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
 	}
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	if (!drv->ops->change_bss) {
 		err = -EOPNOTSUPP;
 		goto out;
 	}
 	rtnl_lock();
 	err = drv->ops->change_bss(&drv->wiphy, dev, &params);
 	rtnl_unlock();
  out:
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 static const struct nla_policy
 	reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
 	[NL80211_ATTR_REG_RULE_FLAGS]		= { .type = NLA_U32 },
 	[NL80211_ATTR_FREQ_RANGE_START]		= { .type = NLA_U32 },
 	[NL80211_ATTR_FREQ_RANGE_END]		= { .type = NLA_U32 },
 	[NL80211_ATTR_FREQ_RANGE_MAX_BW]	= { .type = NLA_U32 },
 	[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]	= { .type = NLA_U32 },
 	[NL80211_ATTR_POWER_RULE_MAX_EIRP]	= { .type = NLA_U32 },
 };
 static int parse_reg_rule(struct nlattr *tb[],
 	struct ieee80211_reg_rule *reg_rule)
 {
 	struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
 	struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
 	if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
 		return -EINVAL;
 	if (!tb[NL80211_ATTR_FREQ_RANGE_START])
 		return -EINVAL;
 	if (!tb[NL80211_ATTR_FREQ_RANGE_END])
 		return -EINVAL;
 	if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
 		return -EINVAL;
 	if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
 		return -EINVAL;
 	reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
 	freq_range->start_freq_khz =
 		nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
 	freq_range->end_freq_khz =
 		nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
 	freq_range->max_bandwidth_khz =
 		nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
 	power_rule->max_eirp =
 		nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
 	if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
 		power_rule->max_antenna_gain =
 			nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
 	return 0;
 }
 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
 {
 	int r;
 	char *data = NULL;
 	if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
 		return -EINVAL;
 	data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
 	/* We ignore world regdom requests with the old regdom setup */
 	if (is_world_regdom(data))
 		return -EINVAL;
 #endif
 	mutex_lock(&cfg80211_drv_mutex);
 	r = __regulatory_hint(NULL, REGDOM_SET_BY_USER, data, 0, ENVIRON_ANY);
 	mutex_unlock(&cfg80211_drv_mutex);
 	return r;
 }
 static int nl80211_get_mesh_params(struct sk_buff *skb,
 	struct genl_info *info)
 {
 	struct cfg80211_registered_device *drv;
 	struct mesh_config cur_params;
 	int err;
 	struct net_device *dev;
 	void *hdr;
 	struct nlattr *pinfoattr;
 	struct sk_buff *msg;
 	/* Look up our device */
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	/* Get the mesh params */
 	rtnl_lock();
 	err = drv->ops->get_mesh_params(&drv->wiphy, dev, &cur_params);
 	rtnl_unlock();
 	if (err)
 		goto out;
 	/* Draw up a netlink message to send back */
 	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 	if (!msg) {
 		err = -ENOBUFS;
 		goto out;
 	}
 	hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
 			     NL80211_CMD_GET_MESH_PARAMS);
 	if (!hdr)
 		goto nla_put_failure;
 	pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_PARAMS);
 	if (!pinfoattr)
 		goto nla_put_failure;
 	NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
 	NLA_PUT_U16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
 			cur_params.dot11MeshRetryTimeout);
 	NLA_PUT_U16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
 			cur_params.dot11MeshConfirmTimeout);
 	NLA_PUT_U16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
 			cur_params.dot11MeshHoldingTimeout);
 	NLA_PUT_U16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
 			cur_params.dot11MeshMaxPeerLinks);
 	NLA_PUT_U8(msg, NL80211_MESHCONF_MAX_RETRIES,
 			cur_params.dot11MeshMaxRetries);
 	NLA_PUT_U8(msg, NL80211_MESHCONF_TTL,
 			cur_params.dot11MeshTTL);
 	NLA_PUT_U8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
 			cur_params.auto_open_plinks);
 	NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
 			cur_params.dot11MeshHWMPmaxPREQretries);
 	NLA_PUT_U32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
 			cur_params.path_refresh_time);
 	NLA_PUT_U16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
 			cur_params.min_discovery_timeout);
 	NLA_PUT_U32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
 			cur_params.dot11MeshHWMPactivePathTimeout);
 	NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
 			cur_params.dot11MeshHWMPpreqMinInterval);
 	NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
 			cur_params.dot11MeshHWMPnetDiameterTraversalTime);
 	nla_nest_end(msg, pinfoattr);
 	genlmsg_end(msg, hdr);
 	err = genlmsg_unicast(msg, info->snd_pid);
 	goto out;
 nla_put_failure:
 	genlmsg_cancel(msg, hdr);
 	err = -EMSGSIZE;
 out:
 	/* Cleanup */
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 #define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
 do {\
 	if (table[attr_num]) {\
 		cfg.param = nla_fn(table[attr_num]); \
 		mask |= (1 << (attr_num - 1)); \
 	} \
 } while (0);\
 static struct nla_policy
 nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] __read_mostly = {
 	[NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
 	[NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
 	[NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
 	[NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
 	[NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
 	[NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
 	[NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
 	[NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
 	[NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
 	[NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
 	[NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
 	[NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
 	[NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
 };
 static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
 {
 	int err;
 	u32 mask;
 	struct cfg80211_registered_device *drv;
 	struct net_device *dev;
 	struct mesh_config cfg;
 	struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
 	struct nlattr *parent_attr;
 	parent_attr = info->attrs[NL80211_ATTR_MESH_PARAMS];
 	if (!parent_attr)
 		return -EINVAL;
 	if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
 			parent_attr, nl80211_meshconf_params_policy))
 		return -EINVAL;
 	err = get_drv_dev_by_info_ifindex(info->attrs, &drv, &dev);
 	if (err)
 		return err;
 	/* This makes sure that there aren't more than 32 mesh config
 	 * parameters (otherwise our bitfield scheme would not work.) */
 	BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
 	/* Fill in the params struct */
 	mask = 0;
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
 			mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
 			mask, NL80211_MESHCONF_CONFIRM_TIMEOUT, nla_get_u16);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout,
 			mask, NL80211_MESHCONF_HOLDING_TIMEOUT, nla_get_u16);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks,
 			mask, NL80211_MESHCONF_MAX_PEER_LINKS, nla_get_u16);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries,
 			mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
 			mask, NL80211_MESHCONF_TTL, nla_get_u8);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
 			mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
 			mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
 			nla_get_u8);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time,
 			mask, NL80211_MESHCONF_PATH_REFRESH_TIME, nla_get_u32);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout,
 			mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
 			nla_get_u16);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
 			mask, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
 			nla_get_u32);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
 			mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
 			nla_get_u16);
 	FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
 			dot11MeshHWMPnetDiameterTraversalTime,
 			mask, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
 			nla_get_u16);
 	/* Apply changes */
 	rtnl_lock();
 	err = drv->ops->set_mesh_params(&drv->wiphy, dev, &cfg, mask);
 	rtnl_unlock();
 	/* cleanup */
 	cfg80211_put_dev(drv);
 	dev_put(dev);
 	return err;
 }
 #undef FILL_IN_MESH_PARAM_IF_SET
 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
 {
 	struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
 	struct nlattr *nl_reg_rule;
 	char *alpha2 = NULL;
 	int rem_reg_rules = 0, r = 0;
 	u32 num_rules = 0, rule_idx = 0, size_of_regd;
 	struct ieee80211_regdomain *rd = NULL;
 	if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
 		return -EINVAL;
 	if (!info->attrs[NL80211_ATTR_REG_RULES])
 		return -EINVAL;
 	alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
 	nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
 			rem_reg_rules) {
 		num_rules++;
 		if (num_rules > NL80211_MAX_SUPP_REG_RULES)
 			goto bad_reg;
 	}
 	if (!reg_is_valid_request(alpha2))
 		return -EINVAL;
 	size_of_regd = sizeof(struct ieee80211_regdomain) +
 		(num_rules * sizeof(struct ieee80211_reg_rule));
 	rd = kzalloc(size_of_regd, GFP_KERNEL);
 	if (!rd)
 		return -ENOMEM;
 	rd->n_reg_rules = num_rules;
 	rd->alpha2[0] = alpha2[0];
 	rd->alpha2[1] = alpha2[1];
 	nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
 			rem_reg_rules) {
 		nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
 			nla_data(nl_reg_rule), nla_len(nl_reg_rule),
 			reg_rule_policy);
 		r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
 		if (r)
 			goto bad_reg;
 		rule_idx++;
 		if (rule_idx > NL80211_MAX_SUPP_REG_RULES)
 			goto bad_reg;
 	}
 	BUG_ON(rule_idx != num_rules);
 	mutex_lock(&cfg80211_drv_mutex);
 	r = set_regdom(rd);
 	mutex_unlock(&cfg80211_drv_mutex);
 	return r;
  bad_reg:
 	kfree(rd);
 	return -EINVAL;
 }
 static struct genl_ops nl80211_ops[] = {
 	{
 		.cmd = NL80211_CMD_GET_WIPHY,
 		.doit = nl80211_get_wiphy,
 		.dumpit = nl80211_dump_wiphy,
 		.policy = nl80211_policy,
 		/* can be retrieved by unprivileged users */
 	},
 	{
 		.cmd = NL80211_CMD_SET_WIPHY,
 		.doit = nl80211_set_wiphy,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_GET_INTERFACE,
 		.doit = nl80211_get_interface,
 		.dumpit = nl80211_dump_interface,
 		.policy = nl80211_policy,
 		/* can be retrieved by unprivileged users */
 	},
 	{
 		.cmd = NL80211_CMD_SET_INTERFACE,
 		.doit = nl80211_set_interface,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_NEW_INTERFACE,
 		.doit = nl80211_new_interface,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_DEL_INTERFACE,
 		.doit = nl80211_del_interface,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_GET_KEY,
 		.doit = nl80211_get_key,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_SET_KEY,
 		.doit = nl80211_set_key,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_NEW_KEY,
 		.doit = nl80211_new_key,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_DEL_KEY,
 		.doit = nl80211_del_key,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_SET_BEACON,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 		.doit = nl80211_addset_beacon,
 	},
 	{
 		.cmd = NL80211_CMD_NEW_BEACON,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 		.doit = nl80211_addset_beacon,
 	},
 	{
 		.cmd = NL80211_CMD_DEL_BEACON,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 		.doit = nl80211_del_beacon,
 	},
 	{
 		.cmd = NL80211_CMD_GET_STATION,
 		.doit = nl80211_get_station,
 		.dumpit = nl80211_dump_station,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_SET_STATION,
 		.doit = nl80211_set_station,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_NEW_STATION,
 		.doit = nl80211_new_station,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_DEL_STATION,
 		.doit = nl80211_del_station,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_GET_MPATH,
 		.doit = nl80211_get_mpath,
 		.dumpit = nl80211_dump_mpath,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_SET_MPATH,
 		.doit = nl80211_set_mpath,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_NEW_MPATH,
 		.doit = nl80211_new_mpath,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_DEL_MPATH,
 		.doit = nl80211_del_mpath,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_SET_BSS,
 		.doit = nl80211_set_bss,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_SET_REG,
 		.doit = nl80211_set_reg,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_REQ_SET_REG,
 		.doit = nl80211_req_set_reg,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 	{
 		.cmd = NL80211_CMD_GET_MESH_PARAMS,
 		.doit = nl80211_get_mesh_params,
 		.policy = nl80211_policy,
 		/* can be retrieved by unprivileged users */
 	},
 	{
 		.cmd = NL80211_CMD_SET_MESH_PARAMS,
 		.doit = nl80211_set_mesh_params,
 		.policy = nl80211_policy,
 		.flags = GENL_ADMIN_PERM,
 	},
 };
 /* multicast groups */
 static struct genl_multicast_group nl80211_config_mcgrp = {
 	.name = "config",
 };
 /* notification functions */
 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
 {
 	struct sk_buff *msg;
 	msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 	if (!msg)
 		return;
 	if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
 		nlmsg_free(msg);
 		return;
 	}
 	genlmsg_multicast(msg, 0, nl80211_config_mcgrp.id, GFP_KERNEL);
 }
 /* initialisation/exit functions */
 int nl80211_init(void)
 {
 	int err, i;
 	err = genl_register_family(&nl80211_fam);
 	if (err)
 		return err;
 	for (i = 0; i < ARRAY_SIZE(nl80211_ops); i++) {
 		err = genl_register_ops(&nl80211_fam, &nl80211_ops[i]);
 		if (err)
 			goto err_out;
 	}
 	err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
 	if (err)
 		goto err_out;
 	return 0;
  err_out:
 	genl_unregister_family(&nl80211_fam);
 	return err;
 }
 void nl80211_exit(void)
 {
 	genl_unregister_family(&nl80211_fam);
 }