/*
 * Copyright (c) 2010 Broadcom Corporation
 *
 * 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.
 */

#ifndef _wlc_h_
#define _wlc_h_

#include <wlc_types.h>

#include <wl_dbg.h>
#include <wlioctl.h>
#include <wlc_event.h>
#include <wlc_phy_hal.h>
#include <wlc_channel.h>
#ifdef WLC_SPLIT
#include <bcm_rpc.h>
#endif

#include <wlc_bsscfg.h>

#include <wlc_scb.h>

#define MA_WINDOW_SZ		8	/* moving average window size */
#define	WL_HWRXOFF		38	/* chip rx buffer offset */
#define	INVCHANNEL		255	/* invalid channel */
#define	MAXCOREREV		28	/* max # supported core revisions (0 .. MAXCOREREV - 1) */
#define WLC_MAXMODULES		22	/* max #  wlc_module_register() calls */

/* network protection config */
#define	WLC_PROT_G_SPEC		1	/* SPEC g protection */
#define	WLC_PROT_G_OVR		2	/* SPEC g prot override */
#define	WLC_PROT_G_USER		3	/* gmode specified by user */
#define	WLC_PROT_OVERLAP	4	/* overlap */
#define	WLC_PROT_N_USER		10	/* nmode specified by user */
#define	WLC_PROT_N_CFG		11	/* n protection */
#define	WLC_PROT_N_CFG_OVR	12	/* n protection override */
#define	WLC_PROT_N_NONGF	13	/* non-GF protection */
#define	WLC_PROT_N_NONGF_OVR	14	/* non-GF protection override */
#define	WLC_PROT_N_PAM_OVR	15	/* n preamble override */
#define	WLC_PROT_N_OBSS		16	/* non-HT OBSS present */

#define WLC_BITSCNT(x)	bcm_bitcount((uint8 *)&(x), sizeof(uint8))

/* Maximum wait time for a MAC suspend */
#define	WLC_MAX_MAC_SUSPEND	83000	/* uS: 83mS is max packet time (64KB ampdu @ 6Mbps) */

/* Probe Response timeout - responses for probe requests older that this are tossed, zero to disable
 */
#define WLC_PRB_RESP_TIMEOUT	0	/* Disable probe response timeout */

/* transmit buffer max headroom for protocol headers */
#define TXOFF (D11_TXH_LEN + D11_PHY_HDR_LEN)

/* For managing scan result lists */
typedef struct wlc_bss_list {
	uint count;
	bool beacon;		/* set for beacon, cleared for probe response */
	wlc_bss_info_t *ptrs[MAXBSS];
} wlc_bss_list_t;

#define	SW_TIMER_MAC_STAT_UPD		30	/* periodic MAC stats update */

/* Double check that unsupported cores are not enabled */
#if CONF_MSK(D11CONF, 0x4f) || CONF_GE(D11CONF, MAXCOREREV)
#error "Configuration for D11CONF includes unsupported versions."
#endif				/* Bad versions */

#define	VALID_COREREV(corerev)	CONF_HAS(D11CONF, corerev)

/* values for shortslot_override */
#define WLC_SHORTSLOT_AUTO	-1	/* Driver will manage Shortslot setting */
#define WLC_SHORTSLOT_OFF	0	/* Turn off short slot */
#define WLC_SHORTSLOT_ON	1	/* Turn on short slot */

/* value for short/long and mixmode/greenfield preamble */

#define WLC_LONG_PREAMBLE	(0)
#define WLC_SHORT_PREAMBLE	(1 << 0)
#define WLC_GF_PREAMBLE		(1 << 1)
#define WLC_MM_PREAMBLE		(1 << 2)
#define WLC_IS_MIMO_PREAMBLE(_pre) (((_pre) == WLC_GF_PREAMBLE) || ((_pre) == WLC_MM_PREAMBLE))

/* values for barker_preamble */
#define WLC_BARKER_SHORT_ALLOWED	0	/* Short pre-amble allowed */

/* A fifo is full. Clear precedences related to that FIFO */
#define WLC_TX_FIFO_CLEAR(wlc, fifo) ((wlc)->tx_prec_map &= ~(wlc)->fifo2prec_map[fifo])

/* Fifo is NOT full. Enable precedences for that FIFO */
#define WLC_TX_FIFO_ENAB(wlc, fifo)  ((wlc)->tx_prec_map |= (wlc)->fifo2prec_map[fifo])

/* TxFrameID */
/* seq and frag bits: SEQNUM_SHIFT, FRAGNUM_MASK (802.11.h) */
/* rate epoch bits: TXFID_RATE_SHIFT, TXFID_RATE_MASK ((wlc_rate.c) */
#define TXFID_QUEUE_MASK	0x0007	/* Bits 0-2 */
#define TXFID_SEQ_MASK		0x7FE0	/* Bits 5-15 */
#define TXFID_SEQ_SHIFT		5	/* Number of bit shifts */
#define	TXFID_RATE_PROBE_MASK	0x8000	/* Bit 15 for rate probe */
#define TXFID_RATE_MASK		0x0018	/* Mask for bits 3 and 4 */
#define TXFID_RATE_SHIFT	3	/* Shift 3 bits for rate mask */

/* promote boardrev */
#define BOARDREV_PROMOTABLE	0xFF	/* from */
#define BOARDREV_PROMOTED	1	/* to */

/* if wpa is in use then portopen is true when the group key is plumbed otherwise it is always true
 */
#define WLC_PORTOPEN(cfg) \
	(((cfg)->WPA_auth != WPA_AUTH_DISABLED && WSEC_ENABLED((cfg)->wsec)) ? \
	(cfg)->wsec_portopen : TRUE)

#define PS_ALLOWED(wlc)	wlc_ps_allowed(wlc)
#define STAY_AWAKE(wlc) wlc_stay_awake(wlc)

#define DATA_BLOCK_TX_SUPR	(1 << 4)

/* 802.1D Priority to TX FIFO number for wme */
extern const uint8 prio2fifo[];

/* Ucode MCTL_WAKE override bits */
#define WLC_WAKE_OVERRIDE_CLKCTL	0x01
#define WLC_WAKE_OVERRIDE_PHYREG	0x02
#define WLC_WAKE_OVERRIDE_MACSUSPEND	0x04
#define WLC_WAKE_OVERRIDE_TXFIFO	0x08
#define WLC_WAKE_OVERRIDE_FORCEFAST	0x10

/* stuff pulled in from wlc.c */

/* Interrupt bit error summary.  Don't include I_RU: we refill DMA at other
 * times; and if we run out, constant I_RU interrupts may cause lockup.  We
 * will still get error counts from rx0ovfl.
 */
#define	I_ERRORS	(I_PC | I_PD | I_DE | I_RO | I_XU)
/* default software intmasks */
#define	DEF_RXINTMASK	(I_RI)	/* enable rx int on rxfifo only */
#define	DEF_MACINTMASK	(MI_TXSTOP | MI_TBTT | MI_ATIMWINEND | MI_PMQ | \
			 MI_PHYTXERR | MI_DMAINT | MI_TFS | MI_BG_NOISE | \
			 MI_CCA | MI_TO | MI_GP0 | MI_RFDISABLE | MI_PWRUP)

#define	RETRY_SHORT_DEF			7	/* Default Short retry Limit */
#define	RETRY_SHORT_MAX			255	/* Maximum Short retry Limit */
#define	RETRY_LONG_DEF			4	/* Default Long retry count */
#define	RETRY_SHORT_FB			3	/* Short retry count for fallback rate */
#define	RETRY_LONG_FB			2	/* Long retry count for fallback rate */

#define	MAXTXPKTS		6	/* max # pkts pending */

/* frameburst */
#define	MAXTXFRAMEBURST		8	/* vanilla xpress mode: max frames/burst */
#define	MAXFRAMEBURST_TXOP	10000	/* Frameburst TXOP in usec */

/* Per-AC retry limit register definitions; uses bcmdefs.h bitfield macros */
#define EDCF_SHORT_S            0
#define EDCF_SFB_S              4
#define EDCF_LONG_S             8
#define EDCF_LFB_S              12
#define EDCF_SHORT_M            BITFIELD_MASK(4)
#define EDCF_SFB_M              BITFIELD_MASK(4)
#define EDCF_LONG_M             BITFIELD_MASK(4)
#define EDCF_LFB_M              BITFIELD_MASK(4)

#define WLC_WME_RETRY_SHORT_GET(wlc, ac)    GFIELD(wlc->wme_retries[ac], EDCF_SHORT)
#define WLC_WME_RETRY_SFB_GET(wlc, ac)      GFIELD(wlc->wme_retries[ac], EDCF_SFB)
#define WLC_WME_RETRY_LONG_GET(wlc, ac)     GFIELD(wlc->wme_retries[ac], EDCF_LONG)
#define WLC_WME_RETRY_LFB_GET(wlc, ac)      GFIELD(wlc->wme_retries[ac], EDCF_LFB)

#define WLC_WME_RETRY_SHORT_SET(wlc, ac, val) \
	wlc->wme_retries[ac] = SFIELD(wlc->wme_retries[ac], EDCF_SHORT, val)
#define WLC_WME_RETRY_SFB_SET(wlc, ac, val) \
	wlc->wme_retries[ac] = SFIELD(wlc->wme_retries[ac], EDCF_SFB, val)
#define WLC_WME_RETRY_LONG_SET(wlc, ac, val) \
	wlc->wme_retries[ac] = SFIELD(wlc->wme_retries[ac], EDCF_LONG, val)
#define WLC_WME_RETRY_LFB_SET(wlc, ac, val) \
	wlc->wme_retries[ac] = SFIELD(wlc->wme_retries[ac], EDCF_LFB, val)

/* PLL requests */
#define WLC_PLLREQ_SHARED	0x1	/* pll is shared on old chips */
#define WLC_PLLREQ_RADIO_MON	0x2	/* hold pll for radio monitor register checking */
#define WLC_PLLREQ_FLIP		0x4	/* hold/release pll for some short operation */

/* Do we support this rate? */
#define VALID_RATE_DBG(wlc, rspec) wlc_valid_rate(wlc, rspec, WLC_BAND_AUTO, TRUE)

/*
 * Macros to check if AP or STA is active.
 * AP Active means more than just configured: driver and BSS are "up";
 * that is, we are beaconing/responding as an AP (aps_associated).
 * STA Active similarly means the driver is up and a configured STA BSS
 * is up: either associated (stas_associated) or trying.
 *
 * Macro definitions vary as per AP/STA ifdefs, allowing references to
 * ifdef'd structure fields and constant values (0) for optimization.
 * Make sure to enclose blocks of code such that any routines they
 * reference can also be unused and optimized out by the linker.
 */
/* NOTE: References structure fields defined in wlc.h */
#define AP_ACTIVE(wlc)	(0)

/*
 * Detect Card removed.
 * Even checking an sbconfig register read will not false trigger when the core is in reset.
 * it breaks CF address mechanism. Accessing gphy phyversion will cause SB error if aphy
 * is in reset on 4306B0-DB. Need a simple accessible reg with fixed 0/1 pattern
 * (some platforms return all 0).
 * If clocks are present, call the sb routine which will figure out if the device is removed.
 */
#ifdef WLC_HIGH_ONLY
#define DEVICEREMOVED(wlc)	(!wlc->device_present)
#else
#define DEVICEREMOVED(wlc)      \
	((wlc->hw->clk) ?   \
	((R_REG(wlc->hw->osh, &wlc->hw->regs->maccontrol) & \
	(MCTL_PSM_JMP_0 | MCTL_IHR_EN)) != MCTL_IHR_EN) : \
	(si_deviceremoved(wlc->hw->sih)))
#endif				/* WLC_HIGH_ONLY */

#define WLCWLUNIT(wlc)		((wlc)->pub->unit)

typedef struct wlc_protection {
	bool _g;		/* use g spec protection, driver internal */
	int8 g_override;	/* override for use of g spec protection */
	uint8 gmode_user;	/* user config gmode, operating band->gmode is different */
	int8 overlap;		/* Overlap BSS/IBSS protection for both 11g and 11n */
	int8 nmode_user;	/* user config nmode, operating pub->nmode is different */
	int8 n_cfg;		/* use OFDM protection on MIMO frames */
	int8 n_cfg_override;	/* override for use of N protection */
	bool nongf;		/* non-GF present protection */
	int8 nongf_override;	/* override for use of GF protection */
	int8 n_pam_override;	/* override for preamble: MM or GF */
	bool n_obss;		/* indicated OBSS Non-HT STA present */

	uint longpre_detect_timeout;	/* #sec until long preamble bcns gone */
	uint barker_detect_timeout;	/* #sec until bcns signaling Barker long preamble */
	/* only is gone */
	uint ofdm_ibss_timeout;	/* #sec until ofdm IBSS beacons gone */
	uint ofdm_ovlp_timeout;	/* #sec until ofdm overlapping BSS bcns gone */
	uint nonerp_ibss_timeout;	/* #sec until nonerp IBSS beacons gone */
	uint nonerp_ovlp_timeout;	/* #sec until nonerp overlapping BSS bcns gone */
	uint g_ibss_timeout;	/* #sec until bcns signaling Use_Protection gone */
	uint n_ibss_timeout;	/* #sec until bcns signaling Use_OFDM_Protection gone */
	uint ht20in40_ovlp_timeout;	/* #sec until 20MHz overlapping OPMODE gone */
	uint ht20in40_ibss_timeout;	/* #sec until 20MHz-only HT station bcns gone */
	uint non_gf_ibss_timeout;	/* #sec until non-GF bcns gone */
} wlc_protection_t;

/* anything affects the single/dual streams/antenna operation */
typedef struct wlc_stf {
	uint8 hw_txchain;	/* HW txchain bitmap cfg */
	uint8 txchain;		/* txchain bitmap being used */
	uint8 txstreams;	/* number of txchains being used */

	uint8 hw_rxchain;	/* HW rxchain bitmap cfg */
	uint8 rxchain;		/* rxchain bitmap being used */
	uint8 rxstreams;	/* number of rxchains being used */

	uint8 ant_rx_ovr;	/* rx antenna override */
	int8 txant;		/* userTx antenna setting */
	uint16 phytxant;	/* phyTx antenna setting in txheader */

	uint8 ss_opmode;	/* singlestream Operational mode, 0:siso; 1:cdd */
	bool ss_algosel_auto;	/* if TRUE, use wlc->stf->ss_algo_channel; */
	/* else use wlc->band->stf->ss_mode_band; */
	uint16 ss_algo_channel;	/* ss based on per-channel algo: 0: SISO, 1: CDD 2: STBC */
	uint8 no_cddstbc;	/* stf override, 1: no CDD (or STBC) allowed */

	uint8 rxchain_restore_delay;	/* delay time to restore default rxchain */

	int8 ldpc;		/* AUTO/ON/OFF ldpc cap supported */
	uint8 txcore[MAX_STREAMS_SUPPORTED + 1];	/* bitmap of selected core for each Nsts */
	int8 spatial_policy;
} wlc_stf_t;

#define WLC_STF_SS_STBC_TX(wlc, scb) \
	(((wlc)->stf->txstreams > 1) && (((wlc)->band->band_stf_stbc_tx == ON) || \
	 (SCB_STBC_CAP((scb)) &&					\
	  (wlc)->band->band_stf_stbc_tx == AUTO &&			\
	  isset(&((wlc)->stf->ss_algo_channel), PHY_TXC1_MODE_STBC))))

#define WLC_STBC_CAP_PHY(wlc) (WLCISNPHY(wlc->band) && NREV_GE(wlc->band->phyrev, 3))

#define WLC_SGI_CAP_PHY(wlc) ((WLCISNPHY(wlc->band) && NREV_GE(wlc->band->phyrev, 3)) || \
	WLCISLCNPHY(wlc->band))

#define WLC_CHAN_PHYTYPE(x)     (((x) & RXS_CHAN_PHYTYPE_MASK) >> RXS_CHAN_PHYTYPE_SHIFT)
#define WLC_CHAN_CHANNEL(x)     (((x) & RXS_CHAN_ID_MASK) >> RXS_CHAN_ID_SHIFT)
#define WLC_RX_CHANNEL(rxh)	(WLC_CHAN_CHANNEL((rxh)->RxChan))

/* wlc_bss_info flag bit values */
#define WLC_BSS_HT		0x0020	/* BSS is HT (MIMO) capable */

/* Flags used in wlc_txq_info.stopped */
#define TXQ_STOP_FOR_PRIOFC_MASK	0x000000FF	/* per prio flow control bits */
#define TXQ_STOP_FOR_PKT_DRAIN		0x00000100	/* stop txq enqueue for packet drain */
#define TXQ_STOP_FOR_AMPDU_FLOW_CNTRL	0x00000200	/* stop txq enqueue for ampdu flow control */

#define WLC_HT_WEP_RESTRICT	0x01	/* restrict HT with WEP */
#define WLC_HT_TKIP_RESTRICT	0x02	/* restrict HT with TKIP */

/*
 * core state (mac)
 */
typedef struct wlccore {
#ifdef WLC_LOW
	uint coreidx;		/* # sb enumerated core */

	/* fifo */
	uint *txavail[NFIFO];	/* # tx descriptors available */
	int16 txpktpend[NFIFO];	/* tx admission control */
#endif				/* WLC_LOW */

	macstat_t *macstat_snapshot;	/* mac hw prev read values */
} wlccore_t;

/*
 * band state (phy+ana+radio)
 */
typedef struct wlcband {
	int bandtype;		/* WLC_BAND_2G, WLC_BAND_5G */
	uint bandunit;		/* bandstate[] index */

	uint16 phytype;		/* phytype */
	uint16 phyrev;
	uint16 radioid;
	uint16 radiorev;
	wlc_phy_t *pi;		/* pointer to phy specific information */
	bool abgphy_encore;

	uint8 gmode;		/* currently active gmode (see wlioctl.h) */

	struct scb *hwrs_scb;	/* permanent scb for hw rateset */

	wlc_rateset_t defrateset;	/* band-specific copy of default_bss.rateset */

	ratespec_t rspec_override;	/* 802.11 rate override */
	ratespec_t mrspec_override;	/* multicast rate override */
	uint8 band_stf_ss_mode;	/* Configured STF type, 0:siso; 1:cdd */
	int8 band_stf_stbc_tx;	/* STBC TX 0:off; 1:force on; -1:auto */
	wlc_rateset_t hw_rateset;	/* rates supported by chip (phy-specific) */
	uint8 basic_rate[WLC_MAXRATE + 1];	/* basic rates indexed by rate */
	bool mimo_cap_40;	/* 40 MHz cap enabled on this band */
	int8 antgain;		/* antenna gain from srom */

	uint16 CWmin;		/* The minimum size of contention window, in unit of aSlotTime */
	uint16 CWmax;		/* The maximum size of contention window, in unit of aSlotTime */
	uint16 bcntsfoff;	/* beacon tsf offset */
} wlcband_t;

/* generic function callback takes just one arg */
typedef void (*cb_fn_t) (void *);

/* tx completion callback takes 3 args */
typedef void (*pkcb_fn_t) (wlc_info_t * wlc, uint txstatus, void *arg);

typedef struct pkt_cb {
	pkcb_fn_t fn;		/* function to call when tx frame completes */
	void *arg;		/* void arg for fn */
	uint8 nextidx;		/* index of next call back if threading */
	bool entered;		/* recursion check */
} pkt_cb_t;

	/* module control blocks */
typedef struct modulecb {
	char name[32];		/* module name : NULL indicates empty array member */
	const bcm_iovar_t *iovars;	/* iovar table */
	void *hdl;		/* handle passed when handler 'doiovar' is called */
	watchdog_fn_t watchdog_fn;	/* watchdog handler */
	iovar_fn_t iovar_fn;	/* iovar handler */
	down_fn_t down_fn;	/* down handler. Note: the int returned
				 * by the down function is a count of the
				 * number of timers that could not be
				 * freed.
				 */
} modulecb_t;

	/* dump control blocks */
typedef struct dumpcb_s {
	const char *name;	/* dump name */
	dump_fn_t dump_fn;	/* 'wl dump' handler */
	void *dump_fn_arg;
	struct dumpcb_s *next;
} dumpcb_t;

/* virtual interface */
struct wlc_if {
	wlc_if_t *next;
	uint8 type;		/* WLC_IFTYPE_BSS or WLC_IFTYPE_WDS */
	uint8 index;		/* assigned in wl_add_if(), index of the wlif if any,
				 * not necessarily corresponding to bsscfg._idx or
				 * AID2PVBMAP(scb).
				 */
	uint8 flags;		/* flags for the interface */
	wl_if_t *wlif;		/* pointer to wlif */
	struct wlc_txq_info *qi;	/* pointer to associated tx queue */
	union {
		struct scb *scb;	/* pointer to scb if WLC_IFTYPE_WDS */
		struct wlc_bsscfg *bsscfg;	/* pointer to bsscfg if WLC_IFTYPE_BSS */
	} u;
};

/* flags for the interface */
#define WLC_IF_LINKED		0x02	/* this interface is linked to a wl_if */

#ifdef WLC_LOW
typedef struct wlc_hwband {
	int bandtype;		/* WLC_BAND_2G, WLC_BAND_5G */
	uint bandunit;		/* bandstate[] index */
	uint16 mhfs[MHFMAX];	/* MHF array shadow */
	uint8 bandhw_stf_ss_mode;	/* HW configured STF type, 0:siso; 1:cdd */
	uint16 CWmin;
	uint16 CWmax;
	uint32 core_flags;

	uint16 phytype;		/* phytype */
	uint16 phyrev;
	uint16 radioid;
	uint16 radiorev;
	wlc_phy_t *pi;		/* pointer to phy specific information */
	bool abgphy_encore;
} wlc_hwband_t;
#endif				/* WLC_LOW */

struct wlc_hw_info {
#ifdef WLC_SPLIT
	rpc_info_t *rpc;	/* Handle to RPC module */
#endif
	osl_t *osh;		/* pointer to os handle */
	bool _piomode;		/* true if pio mode */
	wlc_info_t *wlc;

	/* fifo */
	hnddma_t *di[NFIFO];	/* hnddma handles, per fifo */

#ifdef WLC_LOW
	uint unit;		/* device instance number */

	/* version info */
	uint16 vendorid;	/* PCI vendor id */
	uint16 deviceid;	/* PCI device id */
	uint corerev;		/* core revision */
	uint8 sromrev;		/* version # of the srom */
	uint16 boardrev;	/* version # of particular board */
	uint32 boardflags;	/* Board specific flags from srom */
	uint32 boardflags2;	/* More board flags if sromrev >= 4 */
	uint32 machwcap;	/* MAC capabilities (corerev >= 13) */
	uint32 machwcap_backup;	/* backup of machwcap (corerev >= 13) */
	uint16 ucode_dbgsel;	/* dbgsel for ucode debug(config gpio) */

	si_t *sih;		/* SB handle (cookie for siutils calls) */
	char *vars;		/* "environment" name=value */
	uint vars_size;		/* size of vars, free vars on detach */
	d11regs_t *regs;	/* pointer to device registers */
	void *physhim;		/* phy shim layer handler */
	void *phy_sh;		/* pointer to shared phy state */
	wlc_hwband_t *band;	/* pointer to active per-band state */
	wlc_hwband_t *bandstate[MAXBANDS];	/* per-band state (one per phy/radio) */
	uint16 bmac_phytxant;	/* cache of high phytxant state */
	bool shortslot;		/* currently using 11g ShortSlot timing */
	uint16 SRL;		/* 802.11 dot11ShortRetryLimit */
	uint16 LRL;		/* 802.11 dot11LongRetryLimit */
	uint16 SFBL;		/* Short Frame Rate Fallback Limit */
	uint16 LFBL;		/* Long Frame Rate Fallback Limit */

	bool up;		/* d11 hardware up and running */
	uint now;		/* # elapsed seconds */
	uint _nbands;		/* # bands supported */
	chanspec_t chanspec;	/* bmac chanspec shadow */

	uint *txavail[NFIFO];	/* # tx descriptors available */
	uint16 *xmtfifo_sz;	/* fifo size in 256B for each xmt fifo */

	mbool pllreq;		/* pll requests to keep PLL on */

	uint8 suspended_fifos;	/* Which TX fifo to remain awake for */
	uint32 maccontrol;	/* Cached value of maccontrol */
	uint mac_suspend_depth;	/* current depth of mac_suspend levels */
	uint32 wake_override;	/* Various conditions to force MAC to WAKE mode */
	uint32 mute_override;	/* Prevent ucode from sending beacons */
	struct ether_addr etheraddr;	/* currently configured ethernet address */
	uint32 led_gpio_mask;	/* LED GPIO Mask */
	bool noreset;		/* true= do not reset hw, used by WLC_OUT */
	bool forcefastclk;	/* true if the h/w is forcing the use of fast clk */
	bool clk;		/* core is out of reset and has clock */
	bool sbclk;		/* sb has clock */
	bmac_pmq_t *bmac_pmq;	/*  bmac PM states derived from ucode PMQ */
	bool phyclk;		/* phy is out of reset and has clock */
	bool dma_lpbk;		/* core is in DMA loopback */

#ifdef BCMSDIO
	void *sdh;
#endif
	bool ucode_loaded;	/* TRUE after ucode downloaded */

#ifdef WLC_LOW_ONLY
	struct wl_timer *wdtimer;	/* timer for watchdog routine */
	struct ether_addr orig_etheraddr;	/* original hw ethernet address */
	uint16 rpc_dngl_agg;	/* rpc agg control for dongle */
	uint32 mem_required_def;	/* memory required to replenish RX DMA ring */
	uint32 mem_required_lower;	/* memory required with lower RX bound */
	uint32 mem_required_least;	/* minimum memory requirement to handle RX */

#endif				/* WLC_LOW_ONLY */

	uint8 hw_stf_ss_opmode;	/* STF single stream operation mode */
	uint8 antsel_type;	/* Type of boardlevel mimo antenna switch-logic
				 * 0 = N/A, 1 = 2x4 board, 2 = 2x3 CB2 board
				 */
	uint32 antsel_avail;	/* put antsel_info_t here if more info is needed */
#endif				/* WLC_LOW */
};

/* TX Queue information
 *
 * Each flow of traffic out of the device has a TX Queue with independent
 * flow control. Several interfaces may be associated with a single TX Queue
 * if they belong to the same flow of traffic from the device. For multi-channel
 * operation there are independent TX Queues for each channel.
 */
typedef struct wlc_txq_info {
	struct wlc_txq_info *next;
	struct pktq q;
	uint stopped;		/* tx flow control bits */
} wlc_txq_info_t;

/*
 * Principal common (os-independent) software data structure.
 */
struct wlc_info {
	wlc_pub_t *pub;		/* pointer to wlc public state */
	osl_t *osh;		/* pointer to os handle */
	struct wl_info *wl;	/* pointer to os-specific private state */
	d11regs_t *regs;	/* pointer to device registers */

	wlc_hw_info_t *hw;	/* HW related state used primarily by BMAC */
#ifdef WLC_SPLIT
	rpc_info_t *rpc;	/* Handle to RPC module */
#endif

	/* clock */
	int clkreq_override;	/* setting for clkreq for PCIE : Auto, 0, 1 */
	uint16 fastpwrup_dly;	/* time in us needed to bring up d11 fast clock */

	/* interrupt */
	uint32 macintstatus;	/* bit channel between isr and dpc */
	uint32 macintmask;	/* sw runtime master macintmask value */
	uint32 defmacintmask;	/* default "on" macintmask value */

	/* up and down */
	bool device_present;	/* (removable) device is present */

	bool clk;		/* core is out of reset and has clock */

	/* multiband */
	wlccore_t *core;	/* pointer to active io core */
	wlcband_t *band;	/* pointer to active per-band state */
	wlccore_t *corestate;	/* per-core state (one per hw core) */
	wlcband_t *bandstate[MAXBANDS];	/* per-band state (one per phy/radio) */

	bool war16165;		/* PCI slow clock 16165 war flag */

	bool tx_suspended;	/* data fifos need to remain suspended */

	uint txpend16165war;

	/* packet queue */
	uint qvalid;		/* DirFrmQValid and BcMcFrmQValid */

	/* Regulatory power limits */
	int8 txpwr_local_max;	/* regulatory local txpwr max */
	uint8 txpwr_local_constraint;	/* local power contraint in dB */

#ifdef WLC_HIGH_ONLY
	rpctx_info_t *rpctx;	/* RPC TX module */
	bool reset_bmac_pending;	/* bmac reset is in progressing */
	uint32 rpc_agg;		/* host agg: bit 16-31, bmac agg: bit 0-15 */
	uint32 rpc_msglevel;	/* host rpc: bit 16-31, bmac rpc: bit 0-15 */
#endif

	ampdu_info_t *ampdu;	/* ampdu module handler */
	antsel_info_t *asi;	/* antsel module handler */
	wlc_cm_info_t *cmi;	/* channel manager module handler */

	void *btparam;		/* bus type specific cookie */

	uint vars_size;		/* size of vars, free vars on detach */

	uint16 vendorid;	/* PCI vendor id */
	uint16 deviceid;	/* PCI device id */
	uint ucode_rev;		/* microcode revision */

	uint32 machwcap;	/* MAC capabilities, BMAC shadow */

	struct ether_addr perm_etheraddr;	/* original sprom local ethernet address */

	bool bandlocked;	/* disable auto multi-band switching */
	bool bandinit_pending;	/* track band init in auto band */

	bool radio_monitor;	/* radio timer is running */
	bool down_override;	/* true=down */
	bool going_down;	/* down path intermediate variable */

	bool mpc;		/* enable minimum power consumption */
	uint8 mpc_dlycnt;	/* # of watchdog cnt before turn disable radio */
	uint8 mpc_offcnt;	/* # of watchdog cnt that radio is disabled */
	uint8 mpc_delay_off;	/* delay radio disable by # of watchdog cnt */
	uint8 prev_non_delay_mpc;	/* prev state wlc_is_non_delay_mpc */

	/* timer */
	struct wl_timer *wdtimer;	/* timer for watchdog routine */
	uint fast_timer;	/* Periodic timeout for 'fast' timer */
	uint slow_timer;	/* Periodic timeout for 'slow' timer */
	uint glacial_timer;	/* Periodic timeout for 'glacial' timer */
	uint phycal_mlo;	/* last time measurelow calibration was done */
	uint phycal_txpower;	/* last time txpower calibration was done */

	struct wl_timer *radio_timer;	/* timer for hw radio button monitor routine */
	struct wl_timer *pspoll_timer;	/* periodic pspoll timer */

	/* promiscuous */
	bool monitor;		/* monitor (MPDU sniffing) mode */
	bool bcnmisc_ibss;	/* bcns promisc mode override for IBSS */
	bool bcnmisc_scan;	/* bcns promisc mode override for scan */
	bool bcnmisc_monitor;	/* bcns promisc mode override for monitor */

	uint8 bcn_wait_prd;	/* max waiting period (for beacon) in 1024TU */

	/* driver feature */
	bool _rifs;		/* enable per-packet rifs */
	int32 rifs_advert;	/* RIFS mode advertisement */
	int8 sgi_tx;		/* sgi tx */
	bool wet;		/* true if wireless ethernet bridging mode */

	/* AP-STA synchronization, power save */
	bool check_for_unaligned_tbtt;	/* check unaligned tbtt flag */
	bool PM_override;	/* no power-save flag, override PM(user input) */
	bool PMenabled;		/* current power-management state (CAM or PS) */
	bool PMpending;		/* waiting for tx status with PM indicated set */
	bool PMblocked;		/* block any PSPolling in PS mode, used to buffer
				 * AP traffic, also used to indicate in progress
				 * of scan, rm, etc. off home channel activity.
				 */
	bool PSpoll;		/* whether there is an outstanding PS-Poll frame */
	uint8 PM;		/* power-management mode (CAM, PS or FASTPS) */
	bool PMawakebcn;	/* bcn recvd during current waking state */

	bool WME_PM_blocked;	/* Can STA go to PM when in WME Auto mode */
	bool wake;		/* host-specified PS-mode sleep state */
	uint8 pspoll_prd;	/* pspoll interval in milliseconds */
	uint8 bcn_li_bcn;	/* beacon listen interval in # beacons */
	uint8 bcn_li_dtim;	/* beacon listen interval in # dtims */

	bool WDarmed;		/* watchdog timer is armed */
	uint32 WDlast;		/* last time wlc_watchdog() was called */

	/* WME */
	ac_bitmap_t wme_dp;	/* Discard (oldest first) policy per AC */
	bool wme_apsd;		/* enable Advanced Power Save Delivery */
	ac_bitmap_t wme_admctl;	/* bit i set if AC i under admission control */
	uint16 edcf_txop[AC_COUNT];	/* current txop for each ac */
	wme_param_ie_t wme_param_ie;	/* WME parameter info element, which on STA
					 * contains parameters in use locally, and on
					 * AP contains parameters advertised to STA
					 * in beacons and assoc responses.
					 */
	bool wme_prec_queuing;	/* enable/disable non-wme STA prec queuing */
	uint16 wme_retries[AC_COUNT];	/* per-AC retry limits */

	int vlan_mode;		/* OK to use 802.1Q Tags (ON, OFF, AUTO) */
	uint16 tx_prec_map;	/* Precedence map based on HW FIFO space */
	uint16 fifo2prec_map[NFIFO];	/* pointer to fifo2_prec map based on WME */

	/* BSS Configurations */
	wlc_bsscfg_t *bsscfg[WLC_MAXBSSCFG];	/* set of BSS configurations, idx 0 is default and
						 * always valid
						 */
	wlc_bsscfg_t *cfg;	/* the primary bsscfg (can be AP or STA) */
	uint8 stas_associated;	/* count of ASSOCIATED STA bsscfgs */
	uint8 aps_associated;	/* count of UP AP bsscfgs */
	uint8 block_datafifo;	/* prohibit posting frames to data fifos */
	bool bcmcfifo_drain;	/* TX_BCMC_FIFO is set to drain */

	/* tx queue */
	wlc_txq_info_t *tx_queues;	/* common TX Queue list */

	/* event */
	wlc_eventq_t *eventq;	/* event queue for deferred processing */

	/* security */
	wsec_key_t *wsec_keys[WSEC_MAX_KEYS];	/* dynamic key storage */
	wsec_key_t *wsec_def_keys[WLC_DEFAULT_KEYS];	/* default key storage */
	bool wsec_swkeys;	/* indicates that all keys should be
				 * treated as sw keys (used for debugging)
				 */
	modulecb_t *modulecb;
	dumpcb_t *dumpcb_head;

	uint8 mimoft;		/* SIGN or 11N */
	uint8 mimo_band_bwcap;	/* bw cap per band type */
	int8 txburst_limit_override;	/* tx burst limit override */
	uint16 txburst_limit;	/* tx burst limit value */
	int8 cck_40txbw;	/* 11N, cck tx b/w override when in 40MHZ mode */
	int8 ofdm_40txbw;	/* 11N, ofdm tx b/w override when in 40MHZ mode */
	int8 mimo_40txbw;	/* 11N, mimo tx b/w override when in 40MHZ mode */
	ht_cap_ie_t ht_cap;	/* HT CAP IE being advertised by this node */
	ht_add_ie_t ht_add;	/* HT ADD IE being used by this node */

	uint seckeys;		/* 54 key table shm address */
	uint tkmickeys;		/* 12 TKIP MIC key table shm address */

	wlc_bss_info_t *default_bss;	/* configured BSS parameters */

	uint16 AID;		/* association ID */
	uint16 counter;		/* per-sdu monotonically increasing counter */
	uint16 mc_fid_counter;	/* BC/MC FIFO frame ID counter */

	bool ibss_allowed;	/* FALSE, all IBSS will be ignored during a scan
				 * and the driver will not allow the creation of
				 * an IBSS network
				 */
	bool ibss_coalesce_allowed;

	char country_default[WLC_CNTRY_BUF_SZ];	/* saved country for leaving 802.11d
						 * auto-country mode
						 */
	char autocountry_default[WLC_CNTRY_BUF_SZ];	/* initial country for 802.11d
							 * auto-country mode
							 */
#ifdef BCMDBG
	bcm_tlv_t *country_ie_override;	/* debug override of announced Country IE */
#endif

	uint16 prb_resp_timeout;	/* do not send prb resp if request older than this,
					 * 0 = disable
					 */

	wlc_rateset_t sup_rates_override;	/* use only these rates in 11g supported rates if
						 * specifed
						 */

	chanspec_t home_chanspec;	/* shared home chanspec */

	/* PHY parameters */
	chanspec_t chanspec;	/* target operational channel */
	uint16 usr_fragthresh;	/* user configured fragmentation threshold */
	uint16 fragthresh[NFIFO];	/* per-fifo fragmentation thresholds */
	uint16 RTSThresh;	/* 802.11 dot11RTSThreshold */
	uint16 SRL;		/* 802.11 dot11ShortRetryLimit */
	uint16 LRL;		/* 802.11 dot11LongRetryLimit */
	uint16 SFBL;		/* Short Frame Rate Fallback Limit */
	uint16 LFBL;		/* Long Frame Rate Fallback Limit */

	/* network config */
	bool shortpreamble;	/* currently operating with CCK ShortPreambles */
	bool shortslot;		/* currently using 11g ShortSlot timing */
	int8 barker_preamble;	/* current Barker Preamble Mode */
	int8 shortslot_override;	/* 11g ShortSlot override */
	bool include_legacy_erp;	/* include Legacy ERP info elt ID 47 as well as g ID 42 */
	bool barker_overlap_control;	/* TRUE: be aware of overlapping BSSs for barker */
	bool ignore_bcns;	/* override: ignore non shortslot bcns in a 11g network */
	bool legacy_probe;	/* restricts probe requests to CCK rates */

	wlc_protection_t *protection;
	int8 PLCPHdr_override;	/* 802.11b Preamble Type override */

	wlc_stf_t *stf;

	pkt_cb_t *pkt_callback;	/* tx completion callback handlers */

	uint32 txretried;	/* tx retried number in one msdu */

	ratespec_t bcn_rspec;	/* save bcn ratespec purpose */

	bool apsd_sta_usp;	/* Unscheduled Service Period in progress on STA */
	struct wl_timer *apsd_trigger_timer;	/* timer for wme apsd trigger frames */
	uint32 apsd_trigger_timeout;	/* timeout value for apsd_trigger_timer (in ms)
					 * 0 == disable
					 */
	ac_bitmap_t apsd_trigger_ac;	/* Permissible Acess Category in which APSD Null
					 * Trigger frames can be send
					 */
	wlc_ap_info_t *ap;

	uint8 htphy_membership;	/* HT PHY membership */

	bool _regulatory_domain;	/* 802.11d enabled? */

	uint8 mimops_PM;

	uint8 txpwr_percent;	/* power output percentage */

	uint8 ht_wsec_restriction;	/* the restriction of HT with TKIP or WEP */

	uint tempsense_lasttime;

	uint16 tx_duty_cycle_ofdm;	/* maximum allowed duty cycle for OFDM */
	uint16 tx_duty_cycle_cck;	/* maximum allowed duty cycle for CCK */

	uint16 next_bsscfg_ID;

	wlc_if_t *wlcif_list;	/* linked list of wlc_if structs */
	wlc_txq_info_t *active_queue;	/* txq for the currently active transmit context */
	uint32 mpc_dur;		/* total time (ms) in mpc mode except for the
				 * portion since radio is turned off last time
				 */
	uint32 mpc_laston_ts;	/* timestamp (ms) when radio is turned off last
				 * time
				 */
	bool pr80838_war;
	uint hwrxoff;
};

/* antsel module specific state */
struct antsel_info {
	wlc_info_t *wlc;	/* pointer to main wlc structure */
	wlc_pub_t *pub;		/* pointer to public fn */
	uint8 antsel_type;	/* Type of boardlevel mimo antenna switch-logic
				 * 0 = N/A, 1 = 2x4 board, 2 = 2x3 CB2 board
				 */
	uint8 antsel_antswitch;	/* board level antenna switch type */
	bool antsel_avail;	/* Ant selection availability (SROM based) */
	wlc_antselcfg_t antcfg_11n;	/* antenna configuration */
	wlc_antselcfg_t antcfg_cur;	/* current antenna config (auto) */
};

#define	CHANNEL_BANDUNIT(wlc, ch) (((ch) <= CH_MAX_2G_CHANNEL) ? BAND_2G_INDEX : BAND_5G_INDEX)
#define	OTHERBANDUNIT(wlc)	((uint)((wlc)->band->bandunit? BAND_2G_INDEX : BAND_5G_INDEX))

#define IS_MBAND_UNLOCKED(wlc) \
	((NBANDS(wlc) > 1) && !(wlc)->bandlocked)

#ifdef WLC_LOW
#define WLC_BAND_PI_RADIO_CHANSPEC wlc_phy_chanspec_get(wlc->band->pi)
#else
#define WLC_BAND_PI_RADIO_CHANSPEC (wlc->chanspec)
#endif

/* sum the individual fifo tx pending packet counts */
#if defined(WLC_HIGH_ONLY)
#define TXPKTPENDTOT(wlc)		(wlc_rpctx_txpktpend((wlc)->rpctx, 0, TRUE))
#define TXPKTPENDGET(wlc, fifo)		(wlc_rpctx_txpktpend((wlc)->rpctx, (fifo), FALSE))
#define TXPKTPENDINC(wlc, fifo, val)	(wlc_rpctx_txpktpendinc((wlc)->rpctx, (fifo), (val)))
#define TXPKTPENDDEC(wlc, fifo, val)	(wlc_rpctx_txpktpenddec((wlc)->rpctx, (fifo), (val)))
#define TXPKTPENDCLR(wlc, fifo)		(wlc_rpctx_txpktpendclr((wlc)->rpctx, (fifo)))
#define TXAVAIL(wlc, fifo)		(wlc_rpctx_txavail((wlc)->rpctx, (fifo)))
#define GETNEXTTXP(wlc, _queue)		(wlc_rpctx_getnexttxp((wlc)->rpctx, (_queue)))

#else
#define	TXPKTPENDTOT(wlc) ((wlc)->core->txpktpend[0] + (wlc)->core->txpktpend[1] + \
	(wlc)->core->txpktpend[2] + (wlc)->core->txpktpend[3])
#define TXPKTPENDGET(wlc, fifo)		((wlc)->core->txpktpend[(fifo)])
#define TXPKTPENDINC(wlc, fifo, val)	((wlc)->core->txpktpend[(fifo)] += (val))
#define TXPKTPENDDEC(wlc, fifo, val)	((wlc)->core->txpktpend[(fifo)] -= (val))
#define TXPKTPENDCLR(wlc, fifo)		((wlc)->core->txpktpend[(fifo)] = 0)
#define TXAVAIL(wlc, fifo)		(*(wlc)->core->txavail[(fifo)])
#define GETNEXTTXP(wlc, _queue)								\
		dma_getnexttxp((wlc)->hw->di[(_queue)], HNDDMA_RANGE_TRANSMITTED)
#endif				/* WLC_HIGH_ONLY */

#define WLC_IS_MATCH_SSID(wlc, ssid1, ssid2, len1, len2) \
	((len1 == len2) && !bcmp(ssid1, ssid2, len1))

/* API shared by both WLC_HIGH and WLC_LOW driver */
extern void wlc_high_dpc(wlc_info_t * wlc, uint32 macintstatus);
extern void wlc_fatal_error(wlc_info_t * wlc);
extern void wlc_bmac_rpc_watchdog(wlc_info_t * wlc);
extern void wlc_recv(wlc_info_t * wlc, void *p);
extern bool wlc_dotxstatus(wlc_info_t * wlc, tx_status_t * txs, uint32 frm_tx2);
extern void wlc_txfifo(wlc_info_t * wlc, uint fifo, void *p, bool commit,
		       int8 txpktpend);
extern void wlc_txfifo_complete(wlc_info_t * wlc, uint fifo, int8 txpktpend);
extern void wlc_info_init(wlc_info_t * wlc, int unit);
extern void wlc_print_txstatus(tx_status_t * txs);
extern int wlc_xmtfifo_sz_get(wlc_info_t * wlc, uint fifo, uint * blocks);
extern void wlc_write_template_ram(wlc_info_t * wlc, int offset, int len,
				   void *buf);
extern void wlc_write_hw_bcntemplates(wlc_info_t * wlc, void *bcn, int len,
				      bool both);
#if defined(BCMDBG)
extern void wlc_get_rcmta(wlc_info_t * wlc, int idx, struct ether_addr *addr);
#endif
extern void wlc_set_rcmta(wlc_info_t * wlc, int idx,
			  const struct ether_addr *addr);
extern void wlc_set_addrmatch(wlc_info_t * wlc, int match_reg_offset,
			      const struct ether_addr *addr);
extern void wlc_read_tsf(wlc_info_t * wlc, uint32 * tsf_l_ptr,
			 uint32 * tsf_h_ptr);
extern void wlc_set_cwmin(wlc_info_t * wlc, uint16 newmin);
extern void wlc_set_cwmax(wlc_info_t * wlc, uint16 newmax);
extern void wlc_fifoerrors(wlc_info_t * wlc);
extern void wlc_pllreq(wlc_info_t * wlc, bool set, mbool req_bit);
extern void wlc_reset_bmac_done(wlc_info_t * wlc);
extern void wlc_protection_upd(wlc_info_t * wlc, uint idx, int val);
extern void wlc_hwtimer_gptimer_set(wlc_info_t * wlc, uint us);
extern void wlc_hwtimer_gptimer_abort(wlc_info_t * wlc);
extern void wlc_pktengtx(wlc_info_t * wlc, wl_pkteng_t * pkteng, uint8 rate,
			 struct ether_addr *sa, uint32 wait_delay);

#if defined(BCMDBG)
extern void wlc_print_rxh(d11rxhdr_t * rxh);
extern void wlc_print_hdrs(wlc_info_t * wlc, const char *prefix, uint8 * frame,
			   d11txh_t * txh, d11rxhdr_t * rxh, uint len);
extern void wlc_print_txdesc(d11txh_t * txh);
#endif
#if defined(BCMDBG)
extern void wlc_print_dot11_mac_hdr(uint8 * buf, int len);
#endif

#ifdef WLC_LOW
extern void wlc_setxband(wlc_hw_info_t * wlc_hw, uint bandunit);
extern void wlc_coredisable(wlc_hw_info_t * wlc_hw);
#endif

extern bool wlc_valid_rate(wlc_info_t * wlc, ratespec_t rate, int band,
			   bool verbose);
extern void wlc_ap_upd(wlc_info_t * wlc);

/* helper functions */
extern void wlc_shm_ssid_upd(wlc_info_t * wlc, wlc_bsscfg_t * cfg);
extern int wlc_set_gmode(wlc_info_t * wlc, uint8 gmode, bool config);

extern void wlc_mac_bcn_promisc_change(wlc_info_t * wlc, bool promisc);
extern void wlc_mac_bcn_promisc(wlc_info_t * wlc);
extern void wlc_mac_promisc(wlc_info_t * wlc);
extern void wlc_txflowcontrol(wlc_info_t * wlc, wlc_txq_info_t * qi, bool on,
			      int prio);
extern void wlc_txflowcontrol_override(wlc_info_t * wlc, wlc_txq_info_t * qi,
				       bool on, uint override);
extern bool wlc_txflowcontrol_prio_isset(wlc_info_t * wlc, wlc_txq_info_t * qi,
					 int prio);
extern void wlc_send_q(wlc_info_t * wlc, wlc_txq_info_t * qi);
extern int wlc_prep_pdu(wlc_info_t * wlc, void *pdu, uint * fifo);

extern uint16 wlc_calc_lsig_len(wlc_info_t * wlc, ratespec_t ratespec,
				uint mac_len);
extern ratespec_t wlc_rspec_to_rts_rspec(wlc_info_t * wlc, ratespec_t rspec,
					 bool use_rspec, uint16 mimo_ctlchbw);
extern uint16 wlc_compute_rtscts_dur(wlc_info_t * wlc, bool cts_only,
				     ratespec_t rts_rate, ratespec_t frame_rate,
				     uint8 rts_preamble_type,
				     uint8 frame_preamble_type, uint frame_len,
				     bool ba);

extern void wlc_tbtt(wlc_info_t * wlc, d11regs_t * regs);

#if defined(BCMDBG)
extern void wlc_dump_ie(wlc_info_t * wlc, bcm_tlv_t * ie, struct bcmstrbuf *b);
#endif

extern bool wlc_ps_check(wlc_info_t * wlc);
extern void wlc_reprate_init(wlc_info_t * wlc);
extern void wlc_bsscfg_reprate_init(wlc_bsscfg_t * bsscfg);
extern void wlc_uint64_sub(uint32 * a_high, uint32 * a_low, uint32 b_high,
			   uint32 b_low);
extern uint32 wlc_calc_tbtt_offset(uint32 bi, uint32 tsf_h, uint32 tsf_l);

/* Shared memory access */
extern void wlc_write_shm(wlc_info_t * wlc, uint offset, uint16 v);
extern uint16 wlc_read_shm(wlc_info_t * wlc, uint offset);
extern void wlc_set_shm(wlc_info_t * wlc, uint offset, uint16 v, int len);
extern void wlc_copyto_shm(wlc_info_t * wlc, uint offset, const void *buf,
			   int len);
extern void wlc_copyfrom_shm(wlc_info_t * wlc, uint offset, void *buf, int len);

extern void wlc_update_beacon(wlc_info_t * wlc);
extern void wlc_bss_update_beacon(wlc_info_t * wlc, struct wlc_bsscfg *bsscfg);

extern void wlc_update_probe_resp(wlc_info_t * wlc, bool suspend);
extern void wlc_bss_update_probe_resp(wlc_info_t * wlc, wlc_bsscfg_t * cfg,
				      bool suspend);

extern bool wlc_ismpc(wlc_info_t * wlc);
extern bool wlc_is_non_delay_mpc(wlc_info_t * wlc);
extern void wlc_radio_mpc_upd(wlc_info_t * wlc);
extern bool wlc_prec_enq(wlc_info_t * wlc, struct pktq *q, void *pkt, int prec);
extern bool wlc_prec_enq_head(wlc_info_t * wlc, struct pktq *q, void *pkt,
			      int prec, bool head);
extern uint16 wlc_phytxctl1_calc(wlc_info_t * wlc, ratespec_t rspec);
extern void wlc_compute_plcp(wlc_info_t * wlc, ratespec_t rate, uint length,
			     uint8 * plcp);
extern uint wlc_calc_frame_time(wlc_info_t * wlc, ratespec_t ratespec,
				uint8 preamble_type, uint mac_len);

extern void wlc_set_chanspec(wlc_info_t * wlc, chanspec_t chanspec);

extern bool wlc_timers_init(wlc_info_t * wlc, int unit);

extern const bcm_iovar_t wlc_iovars[];

extern int wlc_doiovar(void *hdl, const bcm_iovar_t * vi, uint32 actionid,
		       const char *name, void *params, uint p_len, void *arg,
		       int len, int val_size, wlc_if_t * wlcif);

#if defined(BCMDBG)
extern void wlc_print_ies(wlc_info_t * wlc, uint8 * ies, uint ies_len);
#endif

extern int wlc_set_nmode(wlc_info_t * wlc, int32 nmode);
extern void wlc_ht_mimops_cap_update(wlc_info_t * wlc, uint8 mimops_mode);
extern void wlc_mimops_action_ht_send(wlc_info_t * wlc, wlc_bsscfg_t * bsscfg,
				      uint8 mimops_mode);

extern void wlc_switch_shortslot(wlc_info_t * wlc, bool shortslot);
extern void wlc_set_bssid(wlc_bsscfg_t * cfg);
extern void wlc_edcf_setparams(wlc_bsscfg_t * cfg, bool suspend);
extern void wlc_wme_setparams(wlc_info_t * wlc, u16 aci, void *arg,
			      bool suspend);

extern void wlc_set_ratetable(wlc_info_t * wlc);
extern int wlc_set_mac(wlc_bsscfg_t * cfg);
extern void wlc_beacon_phytxctl_txant_upd(wlc_info_t * wlc,
					  ratespec_t bcn_rate);
extern void wlc_mod_prb_rsp_rate_table(wlc_info_t * wlc, uint frame_len);
extern ratespec_t wlc_lowest_basic_rspec(wlc_info_t * wlc, wlc_rateset_t * rs);
extern uint16 wlc_compute_bcntsfoff(wlc_info_t * wlc, ratespec_t rspec,
				    bool short_preamble, bool phydelay);
extern void wlc_radio_disable(wlc_info_t * wlc);
extern void wlc_bcn_li_upd(wlc_info_t * wlc);

extern int wlc_get_revision_info(wlc_info_t * wlc, void *buf, uint len);
extern void wlc_out(wlc_info_t * wlc);
extern void wlc_set_home_chanspec(wlc_info_t * wlc, chanspec_t chanspec);
extern void wlc_watchdog_upd(wlc_info_t * wlc, bool tbtt);
extern bool wlc_ps_allowed(wlc_info_t * wlc);
extern bool wlc_stay_awake(wlc_info_t * wlc);
extern void wlc_wme_initparams_sta(wlc_info_t * wlc, wme_param_ie_t * pe);

extern void wlc_bss_list_free(wlc_info_t * wlc, wlc_bss_list_t * bss_list);
#endif				/* _wlc_h_ */