include/kernel/net80211/ieee80211_linux.h - kernel/skids - Git at Google

 /*-
  * Copyright (c) 2003-2005 Sam Leffler, Errno Consulting
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $Id: ieee80211_linux.h 2696 2007-08-30 01:59:13Z kelmo $
  */
 #ifndef _NET80211_IEEE80211_LINUX_H_
 #define _NET80211_IEEE80211_LINUX_H_

 #include <linux/version.h>
 #include <linux/wireless.h>
 #include <linux/fs.h>
 #include "compat.h"

 /*
  * Compatibility definition of statistics flags
  * (bitmask in (struct iw_quality *)->updated)
  */
 #ifndef IW_QUAL_QUAL_UPDATED
 #define IW_QUAL_QUAL_UPDATED	0x01	/* Value was updated since last read */
 #define IW_QUAL_LEVEL_UPDATED	0x02
 #define IW_QUAL_NOISE_UPDATED	0x04
 #define IW_QUAL_QUAL_INVALID	0x10	/* Driver doesn't provide value */
 #define IW_QUAL_LEVEL_INVALID	0x20
 #define IW_QUAL_NOISE_INVALID	0x40
 #endif /* IW_QUAL_QUAL_UPDATED */

 #ifndef IW_QUAL_ALL_UPDATED
 #define IW_QUAL_ALL_UPDATED \
 	(IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_UPDATED)
 #endif
 #ifndef IW_QUAL_ALL_INVALID
 #define IW_QUAL_ALL_INVALID \
 	(IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID | IW_QUAL_NOISE_INVALID)
 #endif

 void set_quality(struct iw_quality *iq, u_int rssi, int noise);

 /*
  * Task deferral
  *
  * Deduce if tasklets are available.  If not then
  * fall back to using the immediate work queue.
  */
 #include <linux/interrupt.h>
 #ifdef DECLARE_TASKLET			/* native tasklets */
 #define IEEE80211_TQ_STRUCT tasklet_struct
 #define IEEE80211_INIT_TQUEUE(a,b,c)	tasklet_init((a),(b),(unsigned long)(c))
 #define IEEE80211_SCHEDULE_TQUEUE(a)	tasklet_schedule((a))
 #define IEEE80211_CANCEL_TQUEUE(a)	if (!in_interrupt()) tasklet_kill((a))
 typedef unsigned long IEEE80211_TQUEUE_ARG;
 #define mark_bh(a) do {} while (0)
 #else					/* immediate work queue */
 #define IEEE80211_TQ_STRUCT tq_struct
 #define IEEE80211_INIT_TQUEUE(a,b,c)		INIT_TQUEUE(a,b,c)
 #define IEEE80211_SCHEDULE_TQUEUE(a) do { \
 	int __macro_needmark;		\
 	__macro_needmark |= queue_task((a), &tq_immediate);	\
 	if (__macro_needmark)		\
 		mark_bh(IMMEDIATE_BH);	\
 } while(0)
 typedef void *IEEE80211_TQUEUE_ARG;
 #define	tasklet_disable(t)	do { (void) t; local_bh_disable(); } while (0)
 #define	tasklet_enable(t)	do { (void) t; local_bh_enable(); } while (0)
 /* XXX: not supporting cancel in old kernels! */
 #define IEEE80211_CANCEL_TQUEUE(a)	((a),0)
 #endif /* !DECLARE_TASKLET */

 #define	IEEE80211_RESCHEDULE	schedule

 /*
  * Beacon handler locking definitions.
  * Beacon locking
  * UAPSD locking
  */
 typedef spinlock_t ieee80211com_lock_t;
 #define	IEEE80211_LOCK_INIT(_ic, _name)				\
 	spin_lock_init(&(_ic)->ic_comlock)
 #define	IEEE80211_LOCK_DESTROY(_ic)
 #define	IEEE80211_LOCK_IRQ(_ic) do {				\
 	unsigned long __ilockflags;				\
 	spin_lock_irqsave(&(_ic)->ic_comlock, __ilockflags);
 #define	IEEE80211_UNLOCK_IRQ(_ic)					\
 	spin_unlock_irqrestore(&(_ic)->ic_comlock, __ilockflags);	\
 } while (0)
 #define	IEEE80211_UNLOCK_IRQ_EARLY(_ic)					\
 	spin_unlock_irqrestore(&(_ic)->ic_comlock, __ilockflags);
 #define IEEE80211_LOCK_BH(_ic)	spin_lock_bh(&(_ic)->ic_comlock)
 #define IEEE80211_UNLOCK_BH(_ic) spin_unlock_bh(&(_ic)->ic_comlock)
 #define IEEE80211_LOCK(_ic)	spin_lock(&(_ic)->ic_comlock)
 #define IEEE80211_UNLOCK(_ic)	spin_unlock(&(_ic)->ic_comlock)

 /* NB: beware, spin_is_locked() is unusable for !SMP */
 #if defined(CONFIG_SMP)
 #define	IEEE80211_LOCK_ASSERT(_ic) \
 	KASSERT(spin_is_locked(&(_ic)->ic_comlock),("ieee80211com not locked!"))
 #else
 #define	IEEE80211_LOCK_ASSERT(_ic)
 #endif

 #define IEEE80211_VAPS_LOCK_INIT(_ic, _name)		\
 	spin_lock_init(&(_ic)->ic_vapslock)
 #define IEEE80211_VAPS_LOCK_DESTROY(_ic)
 #define IEEE80211_VAPS_LOCK(_ic)	spin_lock(&(_ic)->ic_vapslock);
 #define IEEE80211_VAPS_UNLOCK(_ic)	spin_unlock(&(_ic)->ic_vapslock);
 #define IEEE80211_VAPS_LOCK_BH(_ic)	spin_lock_bh(&(_ic)->ic_vapslock);
 #define IEEE80211_VAPS_UNLOCK_BH(_ic)	spin_unlock_bh(&(_ic)->ic_vapslock);
 #define IEEE80211_VAPS_LOCK_IRQ(_ic)	do {	\
 	int _vaps_lockflags;			\
 	spin_lock_irqsave(&(_ic)->ic_vapslock, _vaps_lockflags);
 #define IEEE80211_VAPS_UNLOCK_IRQ(_ic)	\
 	spin_unlock_irqrestore(&(_ic)->ic_vapslock, _vaps_lockflags); \
 } while (0)
 #define IEEE80211_VAPS_UNLOCK_IRQ_EARLY(_ic)	spin_unlock_irqrestore(&(_ic)->ic_vapslock, _vaps_lockflags)


 /* NB: beware, spin_is_locked() is unusable for !SMP */
 #if defined(CONFIG_SMP)
 #define IEEE80211_VAPS_LOCK_ASSERT(_ic) \
 	KASSERT(spin_is_locked(&(_ic)->ic_vapslock),("ieee80211com_vaps not locked!"))
 #else
 #define IEEE80211_VAPS_LOCK_ASSERT(_ic)
 #endif


 /*
  * Node locking definitions.
  */
 typedef spinlock_t ieee80211_node_lock_t;
 #define	IEEE80211_NODE_LOCK_INIT(_nt, _name)	spin_lock_init(&(_nt)->nt_nodelock)
 #define	IEEE80211_NODE_LOCK_DESTROY(_nt)
 #define	IEEE80211_NODE_LOCK(_nt)	spin_lock(&(_nt)->nt_nodelock)
 #define	IEEE80211_NODE_UNLOCK(_nt)	spin_unlock(&(_nt)->nt_nodelock)
 #define	IEEE80211_NODE_LOCK_BH(_nt)	spin_lock_bh(&(_nt)->nt_nodelock)
 #define	IEEE80211_NODE_UNLOCK_BH(_nt)	spin_unlock_bh(&(_nt)->nt_nodelock)
 #define	IEEE80211_NODE_LOCK_IRQ(_nt)	do {	\
 	unsigned long __node_lockflags;		\
 	spin_lock_irqsave(&(_nt)->nt_nodelock, __node_lockflags);
 #define	IEEE80211_NODE_UNLOCK_IRQ(_nt)		\
 	spin_unlock_irqrestore(&(_nt)->nt_nodelock, __node_lockflags); \
 } while(0)
 #define	IEEE80211_NODE_UNLOCK_IRQ_EARLY(_nt)		\
 	spin_unlock_irqrestore(&(_nt)->nt_nodelock, __node_lockflags);

 /* NB: beware, *_is_locked() are bogusly defined for UP+!PREEMPT */
 #if (defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)) && defined(spinlock_is_locked)
 #define	IEEE80211_NODE_LOCK_ASSERT(_nt) \
 	KASSERT(spinlock_is_locked(&(_nt)->nt_nodelock), \
 		("802.11 node table not locked!"))
 #else
 #define	IEEE80211_NODE_LOCK_ASSERT(_nt)
 #endif

 /*
  * Node table scangen locking definitions.
  */
 typedef spinlock_t ieee80211_scan_lock_t;
 #define	IEEE80211_SCAN_LOCK_INIT(_nt, _name) spin_lock_init(&(_nt)->nt_scanlock)
 #define	IEEE80211_SCAN_LOCK_DESTROY(_nt)
 #define	IEEE80211_SCAN_LOCK_BH(_nt)	spin_lock_bh(&(_nt)->nt_scanlock)
 #define	IEEE80211_SCAN_UNLOCK_BH(_nt)	spin_unlock_bh(&(_nt)->nt_scanlock)
 #define	IEEE80211_SCAN_LOCK_IRQ(_nt)	do {	\
 	unsigned long __scan_lockflags;		\
 	spin_lock_irqsave(&(_nt)->nt_scanlock, __scan_lockflags);
 #define	IEEE80211_SCAN_UNLOCK_IRQ(_nt)		\
 	spin_unlock_irqrestore(&(_nt)->nt_scanlock, __scan_lockflags); \
 } while (0)
 #define	IEEE80211_SCAN_UNLOCK_IRQ_EARLY(_nt)		\
 	spin_unlock_irqrestore(&(_nt)->nt_scanlock, __scan_lockflags);

 /* NB: beware, spin_is_locked() is unusable for !SMP */
 #if defined(CONFIG_SMP)
 #define	IEEE80211_SCAN_LOCK_ASSERT(_nt) \
 	KASSERT(spin_is_locked(&(_nt)->nt_scanlock), ("scangen not locked!"))
 #else
 #define	IEEE80211_SCAN_LOCK_ASSERT(_nt)
 #endif

 /*
  * 802.1x MAC ACL database locking definitions.
  */
 typedef spinlock_t acl_lock_t;
 #define	ACL_LOCK_INIT(_as, _name)	spin_lock_init(&(_as)->as_lock)
 #define	ACL_LOCK_DESTROY(_as)
 #define	ACL_LOCK(_as)			spin_lock(&(_as)->as_lock)
 #define	ACL_UNLOCK(_as)			spin_unlock(&(_as)->as_lock)
 #define	ACL_LOCK_BH(_as)		spin_lock_bh(&(_as)->as_lock)
 #define	ACL_UNLOCK_BH(_as)		spin_unlock_bh(&(_as)->as_lock)

 /* NB: beware, spin_is_locked() is unusable for !SMP */
 #if defined(CONFIG_SMP)
 #define	ACL_LOCK_ASSERT(_as) \
 	KASSERT(spin_is_locked(&(_as)->as_lock), ("ACL not locked!"))
 #else
 #define	ACL_LOCK_ASSERT(_as)
 #endif

 /*
  * Per-node power-save queue definitions.  Beware of control
  * flow with IEEE80211_NODE_SAVEQ_LOCK/IEEE80211_NODE_SAVEQ_UNLOCK.
  */
 #define	IEEE80211_NODE_SAVEQ_INIT(_ni, _name) do {		\
 	skb_queue_head_init(&(_ni)->ni_savedq);			\
 } while (0)
 #define	IEEE80211_NODE_SAVEQ_DESTROY(_ni)
 #define	IEEE80211_NODE_SAVEQ_QLEN(_ni)	skb_queue_len(&(_ni)->ni_savedq)
 #define	IEEE80211_NODE_SAVEQ_LOCK(_ni)				\
 	spin_lock(&(_ni)->ni_savedq.lock)
 #define	IEEE80211_NODE_SAVEQ_UNLOCK(_ni)			\
 	spin_unlock(&(_ni)->ni_savedq.lock)
 #define	IEEE80211_NODE_SAVEQ_LOCK_IRQ(_ni) do {			\
 	unsigned long __sqlockflags;				\
 	spin_lock_irqsave(&(_ni)->ni_savedq.lock, __sqlockflags);
 #define	IEEE80211_NODE_SAVEQ_UNLOCK_IRQ(_ni)			\
 	spin_unlock_irqrestore(&(_ni)->ni_savedq.lock, __sqlockflags);\
 } while (0)

 /* caller MUST lock IEEE80211_NODE_SAVEQ */
 #define	IEEE80211_NODE_SAVEQ_DEQUEUE(_ni, _skb, _qlen) do {	\
 	_skb = __skb_dequeue(&(_ni)->ni_savedq);		\
 	(_qlen) = skb_queue_len(&(_ni)->ni_savedq);		\
 } while (0)
 #define	_IEEE80211_NODE_SAVEQ_ENQUEUE(_ni, _skb, _qlen, _age) do {\
 	struct sk_buff *tail = skb_peek_tail(&(_ni)->ni_savedq);\
 	if (tail != NULL) {					\
 		_age -= M_AGE_GET(tail);			\
 		__skb_append(tail, _skb, &(_ni)->ni_savedq);	\
 	} else {						\
 		__skb_queue_head(&(_ni)->ni_savedq, _skb);	\
 	}							\
 	M_AGE_SET(_skb, _age);					\
 	(_qlen) = skb_queue_len(&(_ni)->ni_savedq);		\
 } while (0)

 struct ieee80211com;
 struct ieee80211vap;

 int ieee80211_load_module(const char *);

 /*
  * Node reference counting definitions.
  *
  * ieee80211_node_initref	initialize the reference count to 1
  * ieee80211_node_incref	add a reference
  * ieee80211_node_dectestref	remove a reference and return 1 if this
  *				is the last reference, otherwise 0
  * ieee80211_node_refcnt	reference count for printing (only)
  */
 #define ieee80211_node_initref(_ni)	atomic_set(&(_ni)->ni_refcnt, 1)
 #define ieee80211_node_incref(_ni)	atomic_inc(&(_ni)->ni_refcnt)
 #define ieee80211_node_decref(_ni)	atomic_dec(&(_ni)->ni_refcnt)
 #define	ieee80211_node_dectestref(_ni)	atomic_dec_and_test(&(_ni)->ni_refcnt)
 #define	ieee80211_node_refcnt(_ni)	(_ni)->ni_refcnt.counter

 #define	le16toh(_x)	le16_to_cpu(_x)
 #define	htole16(_x)	cpu_to_le16(_x)
 #define	le32toh(_x)	le32_to_cpu(_x)
 #define	htole32(_x)	cpu_to_le32(_x)
 #define	be16toh(_x)	be16_to_cpu(_x)
 #define	htobe16(_x)	cpu_to_be16(_x)
 #define	be32toh(_x)	be32_to_cpu(_x)
 #define	htobe32(_x)	cpu_to_be32(_x)

 /*
  * Linux has no equivalents to malloc types so null these out.
  */
 #define	MALLOC_DEFINE(type, shortdesc, longdesc)
 #define	MALLOC_DECLARE(type)

 /*
  * flags to malloc.
  */
 #define	M_NOWAIT	0x0001		/* do not block */
 #define	M_WAITOK	0x0002		/* ok to block */
 #define	M_ZERO		0x0100		/* bzero the allocation */

 /* Debug memory alloc/free. Keeps a running total of allocated/freed
  * dynamic memory on the WLAN driver.
  */
 #define WLAN_MALLOC_FREE_TOT_DEBUG

 #ifdef WLAN_MALLOC_FREE_TOT_DEBUG
 /* Total number of bytes allocated using the MALLOC macro */
 extern int g_wlan_tot_alloc;
 extern int g_wlan_tot_alloc_cnt;
 /* Total number of bytes freed using the FREE macro */
 extern int g_wlan_tot_free;
 extern int g_wlan_tot_free_cnt;
 /* g_wlan_tot_alloc - g_wlan_tot_free - convenience value */
 extern int g_wlan_balance;
 #endif

 static __inline void
 ieee80211_safe_wait_ms(uint32_t wait_ms, int is_proc)
 {
 #define	IEEE80211_SAFE_WAIT_MS_MAX	1000
 	unsigned long start_time = jiffies;
 	uint32_t ret = 0;

 	KASSERT(wait_ms <= IEEE80211_SAFE_WAIT_MS_MAX,
 		("%s: safe wait limit exceeded\n", __func__));

 	while (!ret) {
 		if (is_proc) {
 			msleep(wait_ms);
 			ret = 1;
 		} else {
 			ret = time_after(jiffies,
 				start_time + msecs_to_jiffies(wait_ms));
 		}
 	}
 }

 /* WLAN driver malloc - chain into kmalloc while supporting extra
  * features such as zeroing the memory.
  */
 static __inline void *
 ieee80211_malloc(size_t size, int flags)
 {
 #ifndef WLAN_MALLOC_FREE_TOT_DEBUG
 	void *p = kmalloc(size, flags & M_NOWAIT ? GFP_ATOMIC : GFP_KERNEL);
 	if (p && (flags & M_ZERO))
 		memset(p, 0, size);
 	return p;
 #else
 	/* Debug version of the MALLOC - add in extra fields for accounting */
 	/* The memory looks like: | Size | Magic | Block ..... |
 	 * Where magic is 0xDEADBEEF and is used to ensure we're only
 	 * doing accounting/pointer juggling on blocks allocated using
 	 * this MALLOC
 	 */
 	void *p = kmalloc(size + (2 * sizeof(int)), flags & M_NOWAIT ? GFP_ATOMIC : GFP_KERNEL);
 	if (p)
 	{
 		int *p_size = (int *)p;
 		if (flags & M_ZERO)
 		{
 			memset(p, 0, size + (2 * sizeof(int)));
 		}
 		/* First extra word is the length of the allocation */
 		*p_size = size;
 		p_size++;
 		/* Magic value for making free work properly */
 		*p_size = 0xDEADBEEF;
 		p_size++;
 		p = p_size;
 		/* Accounting */
 		g_wlan_tot_alloc += size;
 		g_wlan_tot_alloc_cnt++;
 		/* This is NOT thread safe */
 		g_wlan_balance += size;
 	}
 	return p;
 #endif
 }

 #ifdef WLAN_MALLOC_FREE_TOT_DEBUG
 static __inline void
 ieee80211_free(void *addr)
 {
 	int *p_size = (int *)(addr);
 	p_size--;
 	/* Only do pointer juggling for blocks allocated using MALLOC */
 	if (*p_size == 0xDEADBEEF)
 	{
 		p_size--;
 		g_wlan_tot_free += *p_size;
 		g_wlan_tot_free_cnt++;
 		/* This is NOT thread safe */
 		g_wlan_balance -= *p_size;
 	}
 	else
 	{
 		/* Invalid - block not allocated using 'MALLOC' passed in */
 		p_size++;
 	}
 	//printk("Free %p\n", p_size);
 	kfree((void *)p_size);
 }
 #endif

 #define	MALLOC(_ptr, cast, _size, _type, _flags) \
 	((_ptr) = (cast)ieee80211_malloc(_size, _flags))
 #ifdef WLAN_MALLOC_FREE_TOT_DEBUG
 # define	FREE(addr, type)	ieee80211_free((addr))
 #else
 # define	FREE(addr, type)	kfree((addr))
 #endif

 /*
  * This unlikely to be popular but it dramatically reduces diffs.
  */
 #define printf(...) printk(__VA_ARGS__)
 struct ieee80211com;
 extern void if_printf(struct net_device *, const char *, ...);
 extern const char *ether_sprintf(const u_int8_t *);

 /*
  * Queue write-arounds and support routines.
  */
 struct sk_buff *ieee80211_getdataframe(struct ieee80211vap *vap, uint8_t **frm, uint8_t qos,
 					uint32_t payload_len);
 struct sk_buff *ieee80211_getmgtframe(uint8_t **frm, uint32_t payload_len);
 #define	IF_ENQUEUE(_q,_skb)	skb_queue_tail(_q,_skb)
 #define	IF_DEQUEUE(_q,_skb)	(_skb = skb_dequeue(_q))
 #define	_IF_QLEN(_q)		skb_queue_len(_q)
 #define	IF_DRAIN(_q)		skb_queue_drain(_q)
 void skb_queue_drain(struct sk_buff_head *q);

 #ifndef __MOD_INC_USE_COUNT
 #define	_MOD_INC_USE(_m, _err)						\
 	if (!try_module_get(_m)) {					\
 		printk(KERN_WARNING "%s: try_module_get failed\n",	\
 			__func__); \
 		_err;							\
 	}
 #define	_MOD_DEC_USE(_m)		module_put(_m)
 #else
 #define	_MOD_INC_USE(_m, _err)	MOD_INC_USE_COUNT
 #define	_MOD_DEC_USE(_m)	MOD_DEC_USE_COUNT
 #endif

 #include <linux/delay.h>
 #include <linux/jiffies.h>

 #ifndef CLONE_KERNEL
 /*
  * List of flags we want to share for kernel threads,
  * if only because they are not used by them anyway.
  */
 #define CLONE_KERNEL	(CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
 #endif

 #include <linux/mm.h>
 #ifndef offset_in_page
 #define	offset_in_page(p) ((unsigned long) (p) & ~PAGE_MASK)
 #endif

 #ifndef module_put_and_exit
 #define module_put_and_exit(code) do {	\
 	_MOD_DEC_USE(THIS_MODULE);	\
 	do_exit(code);			\
 } while (0)
 #endif

 /*
  * Linux uses __BIG_ENDIAN and __LITTLE_ENDIAN while BSD uses _foo
  * and an explicit _BYTE_ORDER.  Sorry, BSD got there first--define
  * things in the BSD way...
  */
 #undef _LITTLE_ENDIAN
 #define	_LITTLE_ENDIAN	1234	/* LSB first: i386, vax */
 #undef _BIG_ENDIAN
 #define	_BIG_ENDIAN	4321	/* MSB first: 68000, ibm, net */
 #include <asm/byteorder.h>
 #if defined(__LITTLE_ENDIAN)
 #define	_BYTE_ORDER	_LITTLE_ENDIAN
 #elif defined(__BIG_ENDIAN)
 #define	_BYTE_ORDER	_BIG_ENDIAN
 #else
 #error "Please fix asm/byteorder.h"
 #endif


 /*
  * Deal with the sysctl handler api changing.
  */
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)
 #define	IEEE80211_SYSCTL_DECL(f, ctl, write, filp, buffer, lenp, ppos) \
 	f(ctl_table *ctl, int write, \
 	  void __user *buffer, size_t *lenp, loff_t *ppos)
 #define	IEEE80211_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer, lenp, ppos) \
 	proc_dointvec(ctl, write, buffer, lenp, ppos)
 #define BIN_ATTR_ACCESS_DECL(f, filp, kobj, bin_attr, buf, offset, size) \
 	ssize_t f(struct file *filp, struct kobject * kobj, struct bin_attribute * bin_attr, char * buf, loff_t offset, size_t size)
 #else
 #define	IEEE80211_SYSCTL_DECL(f, ctl, write, filp, buffer, lenp, ppos) \
 	f(ctl_table *ctl, int write, struct file *filp, \
 	  void __user *buffer, size_t *lenp, loff_t *ppos)
 #define	IEEE80211_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer, lenp, ppos) \
 	proc_dointvec(ctl, write, filp, buffer, lenp, ppos)
 #define BIN_ATTR_ACCESS_DECL(f, filp, kobj, bin_attr, buf, offset, size) \
 	ssize_t f(struct kobject * kobj, struct bin_attribute * bin_attr, char * buf, loff_t offset, size_t size)
 #endif

 void ieee80211_sysctl_vattach(struct ieee80211vap *);
 void ieee80211_sysctl_vdetach(struct ieee80211vap *);
 int ieee80211_proc_vcreate(struct ieee80211vap *, struct file_operations *,
 	       char *);
 void ieee80211_proc_cleanup(struct ieee80211vap *);

 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
 #define IEEE80211_VLAN_TAG_USED 1

 #ifndef VLAN_GROUP_ARRAY_PART_LEN
 #define vlan_group_set_device(group, vid, dev) do { \
 	group->vlan_devices[vid] = dev; \
 } while (0);
 #endif

 #else
 #define IEEE80211_VLAN_TAG_USED 0
 #endif
 void ieee80211_vlan_vattach(struct ieee80211vap *);
 void ieee80211_vlan_vdetach(struct ieee80211vap *);

 void ieee80211_ioctl_vattach(struct ieee80211vap *);
 void ieee80211_ioctl_vdetach(struct ieee80211vap *);
 void sample_rel_client_data(struct ieee80211vap *vap);
 struct ifreq;
 int ieee80211_ioctl_create_vap(struct ieee80211com *, struct ifreq *,
 	struct net_device *);
 int ieee80211_create_vap(struct ieee80211com *, char *, struct net_device *,
 	int, int);

 /* For explicitly logging messages */
 void ieee80211_dot11_msg_send(struct ieee80211vap *vap,
 		const char *mac_bssid,
 		const char *message,
 		const char *message_code,
 		int message_reason,
 		const char *message_description,
 		const char *auth,
 		const char *crypto);

 extern char *d11_m[];
 extern char *d11_c[];
 extern char *d11_r[];

 #endif /* _NET80211_IEEE80211_LINUX_H_ */
	/*-
	* Copyright (c) 2003-2005 Sam Leffler, Errno Consulting
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 3. The name of the author may not be used to endorse or promote products
	* derived from this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*
	* $Id: ieee80211_linux.h 2696 2007-08-30 01:59:13Z kelmo $
	*/
	#ifndef _NET80211_IEEE80211_LINUX_H_
	#define _NET80211_IEEE80211_LINUX_H_

	#include <linux/version.h>
	#include <linux/wireless.h>
	#include <linux/fs.h>
	#include "compat.h"

	/*
	* Compatibility definition of statistics flags
	* (bitmask in (struct iw_quality *)->updated)
	*/
	#ifndef IW_QUAL_QUAL_UPDATED
	#define IW_QUAL_QUAL_UPDATED 0x01 /* Value was updated since last read */
	#define IW_QUAL_LEVEL_UPDATED 0x02
	#define IW_QUAL_NOISE_UPDATED 0x04
	#define IW_QUAL_QUAL_INVALID 0x10 /* Driver doesn't provide value */
	#define IW_QUAL_LEVEL_INVALID 0x20
	#define IW_QUAL_NOISE_INVALID 0x40
	#endif /* IW_QUAL_QUAL_UPDATED */

	#ifndef IW_QUAL_ALL_UPDATED
	#define IW_QUAL_ALL_UPDATED \
	(IW_QUAL_QUAL_UPDATED \| IW_QUAL_LEVEL_UPDATED \| IW_QUAL_NOISE_UPDATED)
	#endif
	#ifndef IW_QUAL_ALL_INVALID
	#define IW_QUAL_ALL_INVALID \
	(IW_QUAL_QUAL_INVALID \| IW_QUAL_LEVEL_INVALID \| IW_QUAL_NOISE_INVALID)
	#endif

	void set_quality(struct iw_quality *iq, u_int rssi, int noise);

	/*
	* Task deferral
	*
	* Deduce if tasklets are available. If not then
	* fall back to using the immediate work queue.
	*/
	#include <linux/interrupt.h>
	#ifdef DECLARE_TASKLET /* native tasklets */
	#define IEEE80211_TQ_STRUCT tasklet_struct
	#define IEEE80211_INIT_TQUEUE(a,b,c) tasklet_init((a),(b),(unsigned long)(c))
	#define IEEE80211_SCHEDULE_TQUEUE(a) tasklet_schedule((a))
	#define IEEE80211_CANCEL_TQUEUE(a) if (!in_interrupt()) tasklet_kill((a))
	typedef unsigned long IEEE80211_TQUEUE_ARG;
	#define mark_bh(a) do {} while (0)
	#else /* immediate work queue */
	#define IEEE80211_TQ_STRUCT tq_struct
	#define IEEE80211_INIT_TQUEUE(a,b,c) INIT_TQUEUE(a,b,c)
	#define IEEE80211_SCHEDULE_TQUEUE(a) do { \
	int __macro_needmark; \
	__macro_needmark \|= queue_task((a), &tq_immediate); \
	if (__macro_needmark) \
	mark_bh(IMMEDIATE_BH); \
	} while(0)
	typedef void *IEEE80211_TQUEUE_ARG;
	#define tasklet_disable(t) do { (void) t; local_bh_disable(); } while (0)
	#define tasklet_enable(t) do { (void) t; local_bh_enable(); } while (0)
	/* XXX: not supporting cancel in old kernels! */
	#define IEEE80211_CANCEL_TQUEUE(a) ((a),0)
	#endif /* !DECLARE_TASKLET */

	#define IEEE80211_RESCHEDULE schedule

	/*
	* Beacon handler locking definitions.
	* Beacon locking
	* UAPSD locking
	*/
	typedef spinlock_t ieee80211com_lock_t;
	#define IEEE80211_LOCK_INIT(_ic, _name) \
	spin_lock_init(&(_ic)->ic_comlock)
	#define IEEE80211_LOCK_DESTROY(_ic)
	#define IEEE80211_LOCK_IRQ(_ic) do { \
	unsigned long __ilockflags; \
	spin_lock_irqsave(&(_ic)->ic_comlock, __ilockflags);
	#define IEEE80211_UNLOCK_IRQ(_ic) \
	spin_unlock_irqrestore(&(_ic)->ic_comlock, __ilockflags); \
	} while (0)
	#define IEEE80211_UNLOCK_IRQ_EARLY(_ic) \
	spin_unlock_irqrestore(&(_ic)->ic_comlock, __ilockflags);
	#define IEEE80211_LOCK_BH(_ic) spin_lock_bh(&(_ic)->ic_comlock)
	#define IEEE80211_UNLOCK_BH(_ic) spin_unlock_bh(&(_ic)->ic_comlock)
	#define IEEE80211_LOCK(_ic) spin_lock(&(_ic)->ic_comlock)
	#define IEEE80211_UNLOCK(_ic) spin_unlock(&(_ic)->ic_comlock)

	/* NB: beware, spin_is_locked() is unusable for !SMP */
	#if defined(CONFIG_SMP)
	#define IEEE80211_LOCK_ASSERT(_ic) \
	KASSERT(spin_is_locked(&(_ic)->ic_comlock),("ieee80211com not locked!"))
	#else
	#define IEEE80211_LOCK_ASSERT(_ic)
	#endif

	#define IEEE80211_VAPS_LOCK_INIT(_ic, _name) \
	spin_lock_init(&(_ic)->ic_vapslock)
	#define IEEE80211_VAPS_LOCK_DESTROY(_ic)
	#define IEEE80211_VAPS_LOCK(_ic) spin_lock(&(_ic)->ic_vapslock);
	#define IEEE80211_VAPS_UNLOCK(_ic) spin_unlock(&(_ic)->ic_vapslock);
	#define IEEE80211_VAPS_LOCK_BH(_ic) spin_lock_bh(&(_ic)->ic_vapslock);
	#define IEEE80211_VAPS_UNLOCK_BH(_ic) spin_unlock_bh(&(_ic)->ic_vapslock);
	#define IEEE80211_VAPS_LOCK_IRQ(_ic) do { \
	int _vaps_lockflags; \
	spin_lock_irqsave(&(_ic)->ic_vapslock, _vaps_lockflags);
	#define IEEE80211_VAPS_UNLOCK_IRQ(_ic) \
	spin_unlock_irqrestore(&(_ic)->ic_vapslock, _vaps_lockflags); \
	} while (0)
	#define IEEE80211_VAPS_UNLOCK_IRQ_EARLY(_ic) spin_unlock_irqrestore(&(_ic)->ic_vapslock, _vaps_lockflags)


	/* NB: beware, spin_is_locked() is unusable for !SMP */
	#if defined(CONFIG_SMP)
	#define IEEE80211_VAPS_LOCK_ASSERT(_ic) \
	KASSERT(spin_is_locked(&(_ic)->ic_vapslock),("ieee80211com_vaps not locked!"))
	#else
	#define IEEE80211_VAPS_LOCK_ASSERT(_ic)
	#endif


	/*
	* Node locking definitions.
	*/
	typedef spinlock_t ieee80211_node_lock_t;
	#define IEEE80211_NODE_LOCK_INIT(_nt, _name) spin_lock_init(&(_nt)->nt_nodelock)
	#define IEEE80211_NODE_LOCK_DESTROY(_nt)
	#define IEEE80211_NODE_LOCK(_nt) spin_lock(&(_nt)->nt_nodelock)
	#define IEEE80211_NODE_UNLOCK(_nt) spin_unlock(&(_nt)->nt_nodelock)
	#define IEEE80211_NODE_LOCK_BH(_nt) spin_lock_bh(&(_nt)->nt_nodelock)
	#define IEEE80211_NODE_UNLOCK_BH(_nt) spin_unlock_bh(&(_nt)->nt_nodelock)
	#define IEEE80211_NODE_LOCK_IRQ(_nt) do { \
	unsigned long __node_lockflags; \
	spin_lock_irqsave(&(_nt)->nt_nodelock, __node_lockflags);
	#define IEEE80211_NODE_UNLOCK_IRQ(_nt) \
	spin_unlock_irqrestore(&(_nt)->nt_nodelock, __node_lockflags); \
	} while(0)
	#define IEEE80211_NODE_UNLOCK_IRQ_EARLY(_nt) \
	spin_unlock_irqrestore(&(_nt)->nt_nodelock, __node_lockflags);

	/* NB: beware, _is_locked() are bogusly defined for UP+!PREEMPT /
	#if (defined(CONFIG_SMP) \|\| defined(CONFIG_PREEMPT)) && defined(spinlock_is_locked)
	#define IEEE80211_NODE_LOCK_ASSERT(_nt) \
	KASSERT(spinlock_is_locked(&(_nt)->nt_nodelock), \
	("802.11 node table not locked!"))
	#else
	#define IEEE80211_NODE_LOCK_ASSERT(_nt)
	#endif

	/*
	* Node table scangen locking definitions.
	*/
	typedef spinlock_t ieee80211_scan_lock_t;
	#define IEEE80211_SCAN_LOCK_INIT(_nt, _name) spin_lock_init(&(_nt)->nt_scanlock)
	#define IEEE80211_SCAN_LOCK_DESTROY(_nt)
	#define IEEE80211_SCAN_LOCK_BH(_nt) spin_lock_bh(&(_nt)->nt_scanlock)
	#define IEEE80211_SCAN_UNLOCK_BH(_nt) spin_unlock_bh(&(_nt)->nt_scanlock)
	#define IEEE80211_SCAN_LOCK_IRQ(_nt) do { \
	unsigned long __scan_lockflags; \
	spin_lock_irqsave(&(_nt)->nt_scanlock, __scan_lockflags);
	#define IEEE80211_SCAN_UNLOCK_IRQ(_nt) \
	spin_unlock_irqrestore(&(_nt)->nt_scanlock, __scan_lockflags); \
	} while (0)
	#define IEEE80211_SCAN_UNLOCK_IRQ_EARLY(_nt) \
	spin_unlock_irqrestore(&(_nt)->nt_scanlock, __scan_lockflags);

	/* NB: beware, spin_is_locked() is unusable for !SMP */
	#if defined(CONFIG_SMP)
	#define IEEE80211_SCAN_LOCK_ASSERT(_nt) \
	KASSERT(spin_is_locked(&(_nt)->nt_scanlock), ("scangen not locked!"))
	#else
	#define IEEE80211_SCAN_LOCK_ASSERT(_nt)
	#endif

	/*
	* 802.1x MAC ACL database locking definitions.
	*/
	typedef spinlock_t acl_lock_t;
	#define ACL_LOCK_INIT(_as, _name) spin_lock_init(&(_as)->as_lock)
	#define ACL_LOCK_DESTROY(_as)
	#define ACL_LOCK(_as) spin_lock(&(_as)->as_lock)
	#define ACL_UNLOCK(_as) spin_unlock(&(_as)->as_lock)
	#define ACL_LOCK_BH(_as) spin_lock_bh(&(_as)->as_lock)
	#define ACL_UNLOCK_BH(_as) spin_unlock_bh(&(_as)->as_lock)

	/* NB: beware, spin_is_locked() is unusable for !SMP */
	#if defined(CONFIG_SMP)
	#define ACL_LOCK_ASSERT(_as) \
	KASSERT(spin_is_locked(&(_as)->as_lock), ("ACL not locked!"))
	#else
	#define ACL_LOCK_ASSERT(_as)
	#endif

	/*
	* Per-node power-save queue definitions. Beware of control
	* flow with IEEE80211_NODE_SAVEQ_LOCK/IEEE80211_NODE_SAVEQ_UNLOCK.
	*/
	#define IEEE80211_NODE_SAVEQ_INIT(_ni, _name) do { \
	skb_queue_head_init(&(_ni)->ni_savedq); \
	} while (0)
	#define IEEE80211_NODE_SAVEQ_DESTROY(_ni)
	#define IEEE80211_NODE_SAVEQ_QLEN(_ni) skb_queue_len(&(_ni)->ni_savedq)
	#define IEEE80211_NODE_SAVEQ_LOCK(_ni) \
	spin_lock(&(_ni)->ni_savedq.lock)
	#define IEEE80211_NODE_SAVEQ_UNLOCK(_ni) \
	spin_unlock(&(_ni)->ni_savedq.lock)
	#define IEEE80211_NODE_SAVEQ_LOCK_IRQ(_ni) do { \
	unsigned long __sqlockflags; \
	spin_lock_irqsave(&(_ni)->ni_savedq.lock, __sqlockflags);
	#define IEEE80211_NODE_SAVEQ_UNLOCK_IRQ(_ni) \
	spin_unlock_irqrestore(&(_ni)->ni_savedq.lock, __sqlockflags);\
	} while (0)

	/* caller MUST lock IEEE80211_NODE_SAVEQ */
	#define IEEE80211_NODE_SAVEQ_DEQUEUE(_ni, _skb, _qlen) do { \
	_skb = __skb_dequeue(&(_ni)->ni_savedq); \
	(_qlen) = skb_queue_len(&(_ni)->ni_savedq); \
	} while (0)
	#define _IEEE80211_NODE_SAVEQ_ENQUEUE(_ni, _skb, _qlen, _age) do {\
	struct sk_buff *tail = skb_peek_tail(&(_ni)->ni_savedq);\
	if (tail != NULL) { \
	_age -= M_AGE_GET(tail); \
	__skb_append(tail, _skb, &(_ni)->ni_savedq); \
	} else { \
	__skb_queue_head(&(_ni)->ni_savedq, _skb); \
	} \
	M_AGE_SET(_skb, _age); \
	(_qlen) = skb_queue_len(&(_ni)->ni_savedq); \
	} while (0)

	struct ieee80211com;
	struct ieee80211vap;

	int ieee80211_load_module(const char *);

	/*
	* Node reference counting definitions.
	*
	* ieee80211_node_initref initialize the reference count to 1
	* ieee80211_node_incref add a reference
	* ieee80211_node_dectestref remove a reference and return 1 if this
	* is the last reference, otherwise 0
	* ieee80211_node_refcnt reference count for printing (only)
	*/
	#define ieee80211_node_initref(_ni) atomic_set(&(_ni)->ni_refcnt, 1)
	#define ieee80211_node_incref(_ni) atomic_inc(&(_ni)->ni_refcnt)
	#define ieee80211_node_decref(_ni) atomic_dec(&(_ni)->ni_refcnt)
	#define ieee80211_node_dectestref(_ni) atomic_dec_and_test(&(_ni)->ni_refcnt)
	#define ieee80211_node_refcnt(_ni) (_ni)->ni_refcnt.counter

	#define le16toh(_x) le16_to_cpu(_x)
	#define htole16(_x) cpu_to_le16(_x)
	#define le32toh(_x) le32_to_cpu(_x)
	#define htole32(_x) cpu_to_le32(_x)
	#define be16toh(_x) be16_to_cpu(_x)
	#define htobe16(_x) cpu_to_be16(_x)
	#define be32toh(_x) be32_to_cpu(_x)
	#define htobe32(_x) cpu_to_be32(_x)

	/*
	* Linux has no equivalents to malloc types so null these out.
	*/
	#define MALLOC_DEFINE(type, shortdesc, longdesc)
	#define MALLOC_DECLARE(type)

	/*
	* flags to malloc.
	*/
	#define M_NOWAIT 0x0001 /* do not block */
	#define M_WAITOK 0x0002 /* ok to block */
	#define M_ZERO 0x0100 /* bzero the allocation */

	/* Debug memory alloc/free. Keeps a running total of allocated/freed
	* dynamic memory on the WLAN driver.
	*/
	#define WLAN_MALLOC_FREE_TOT_DEBUG

	#ifdef WLAN_MALLOC_FREE_TOT_DEBUG
	/* Total number of bytes allocated using the MALLOC macro */
	extern int g_wlan_tot_alloc;
	extern int g_wlan_tot_alloc_cnt;
	/* Total number of bytes freed using the FREE macro */
	extern int g_wlan_tot_free;
	extern int g_wlan_tot_free_cnt;
	/* g_wlan_tot_alloc - g_wlan_tot_free - convenience value */
	extern int g_wlan_balance;
	#endif

	static __inline void
	ieee80211_safe_wait_ms(uint32_t wait_ms, int is_proc)
	{
	#define IEEE80211_SAFE_WAIT_MS_MAX 1000
	unsigned long start_time = jiffies;
	uint32_t ret = 0;

	KASSERT(wait_ms <= IEEE80211_SAFE_WAIT_MS_MAX,
	("%s: safe wait limit exceeded\n", __func__));

	while (!ret) {
	if (is_proc) {
	msleep(wait_ms);
	ret = 1;
	} else {
	ret = time_after(jiffies,
	start_time + msecs_to_jiffies(wait_ms));
	}
	}
	}

	/* WLAN driver malloc - chain into kmalloc while supporting extra
	* features such as zeroing the memory.
	*/
	static __inline void *
	ieee80211_malloc(size_t size, int flags)
	{
	#ifndef WLAN_MALLOC_FREE_TOT_DEBUG
	void *p = kmalloc(size, flags & M_NOWAIT ? GFP_ATOMIC : GFP_KERNEL);
	if (p && (flags & M_ZERO))
	memset(p, 0, size);
	return p;
	#else
	/* Debug version of the MALLOC - add in extra fields for accounting */
	/* The memory looks like: \| Size \| Magic \| Block ..... \|
	* Where magic is 0xDEADBEEF and is used to ensure we're only
	* doing accounting/pointer juggling on blocks allocated using
	* this MALLOC
	*/
	void p = kmalloc(size + (2 sizeof(int)), flags & M_NOWAIT ? GFP_ATOMIC : GFP_KERNEL);
	if (p)
	{
	int p_size = (int )p;
	if (flags & M_ZERO)
	{
	memset(p, 0, size + (2 * sizeof(int)));
	}
	/* First extra word is the length of the allocation */
	*p_size = size;
	p_size++;
	/* Magic value for making free work properly */
	*p_size = 0xDEADBEEF;
	p_size++;
	p = p_size;
	/* Accounting */
	g_wlan_tot_alloc += size;
	g_wlan_tot_alloc_cnt++;
	/* This is NOT thread safe */
	g_wlan_balance += size;
	}
	return p;
	#endif
	}

	#ifdef WLAN_MALLOC_FREE_TOT_DEBUG
	static __inline void
	ieee80211_free(void *addr)
	{
	int p_size = (int )(addr);
	p_size--;
	/* Only do pointer juggling for blocks allocated using MALLOC */
	if (*p_size == 0xDEADBEEF)
	{
	p_size--;
	g_wlan_tot_free += *p_size;
	g_wlan_tot_free_cnt++;
	/* This is NOT thread safe */
	g_wlan_balance -= *p_size;
	}
	else
	{
	/* Invalid - block not allocated using 'MALLOC' passed in */
	p_size++;
	}
	//printk("Free %p\n", p_size);
	kfree((void *)p_size);
	}
	#endif

	#define MALLOC(_ptr, cast, _size, _type, _flags) \
	((_ptr) = (cast)ieee80211_malloc(_size, _flags))
	#ifdef WLAN_MALLOC_FREE_TOT_DEBUG
	# define FREE(addr, type) ieee80211_free((addr))
	#else
	# define FREE(addr, type) kfree((addr))
	#endif

	/*
	* This unlikely to be popular but it dramatically reduces diffs.
	*/
	#define printf(...) printk(__VA_ARGS__)
	struct ieee80211com;
	extern void if_printf(struct net_device , const char , ...);
	extern const char ether_sprintf(const u_int8_t );

	/*
	* Queue write-arounds and support routines.
	*/
	struct sk_buff ieee80211_getdataframe(struct ieee80211vap vap, uint8_t **frm, uint8_t qos,
	uint32_t payload_len);
	struct sk_buff ieee80211_getmgtframe(uint8_t *frm, uint32_t payload_len);
	#define IF_ENQUEUE(_q,_skb) skb_queue_tail(_q,_skb)
	#define IF_DEQUEUE(_q,_skb) (_skb = skb_dequeue(_q))
	#define _IF_QLEN(_q) skb_queue_len(_q)
	#define IF_DRAIN(_q) skb_queue_drain(_q)
	void skb_queue_drain(struct sk_buff_head *q);

	#ifndef __MOD_INC_USE_COUNT
	#define _MOD_INC_USE(_m, _err) \
	if (!try_module_get(_m)) { \
	printk(KERN_WARNING "%s: try_module_get failed\n", \
	__func__); \
	_err; \
	}
	#define _MOD_DEC_USE(_m) module_put(_m)
	#else
	#define _MOD_INC_USE(_m, _err) MOD_INC_USE_COUNT
	#define _MOD_DEC_USE(_m) MOD_DEC_USE_COUNT
	#endif

	#include <linux/delay.h>
	#include <linux/jiffies.h>

	#ifndef CLONE_KERNEL
	/*
	* List of flags we want to share for kernel threads,
	* if only because they are not used by them anyway.
	*/
	#define CLONE_KERNEL (CLONE_FS \| CLONE_FILES \| CLONE_SIGHAND)
	#endif

	#include <linux/mm.h>
	#ifndef offset_in_page
	#define offset_in_page(p) ((unsigned long) (p) & ~PAGE_MASK)
	#endif

	#ifndef module_put_and_exit
	#define module_put_and_exit(code) do { \
	_MOD_DEC_USE(THIS_MODULE); \
	do_exit(code); \
	} while (0)
	#endif

	/*
	* Linux uses __BIG_ENDIAN and __LITTLE_ENDIAN while BSD uses _foo
	* and an explicit _BYTE_ORDER. Sorry, BSD got there first--define
	* things in the BSD way...
	*/
	#undef _LITTLE_ENDIAN
	#define _LITTLE_ENDIAN 1234 /* LSB first: i386, vax */
	#undef _BIG_ENDIAN
	#define _BIG_ENDIAN 4321 /* MSB first: 68000, ibm, net */
	#include <asm/byteorder.h>
	#if defined(__LITTLE_ENDIAN)
	#define _BYTE_ORDER _LITTLE_ENDIAN
	#elif defined(__BIG_ENDIAN)
	#define _BYTE_ORDER _BIG_ENDIAN
	#else
	#error "Please fix asm/byteorder.h"
	#endif


	/*
	* Deal with the sysctl handler api changing.
	*/
	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)
	#define IEEE80211_SYSCTL_DECL(f, ctl, write, filp, buffer, lenp, ppos) \
	f(ctl_table *ctl, int write, \
	void __user buffer, size_t lenp, loff_t *ppos)
	#define IEEE80211_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer, lenp, ppos) \
	proc_dointvec(ctl, write, buffer, lenp, ppos)
	#define BIN_ATTR_ACCESS_DECL(f, filp, kobj, bin_attr, buf, offset, size) \
	ssize_t f(struct file filp, struct kobject kobj, struct bin_attribute * bin_attr, char * buf, loff_t offset, size_t size)
	#else
	#define IEEE80211_SYSCTL_DECL(f, ctl, write, filp, buffer, lenp, ppos) \
	f(ctl_table ctl, int write, struct file filp, \
	void __user buffer, size_t lenp, loff_t *ppos)
	#define IEEE80211_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer, lenp, ppos) \
	proc_dointvec(ctl, write, filp, buffer, lenp, ppos)
	#define BIN_ATTR_ACCESS_DECL(f, filp, kobj, bin_attr, buf, offset, size) \
	ssize_t f(struct kobject * kobj, struct bin_attribute * bin_attr, char * buf, loff_t offset, size_t size)
	#endif

	void ieee80211_sysctl_vattach(struct ieee80211vap *);
	void ieee80211_sysctl_vdetach(struct ieee80211vap *);
	int ieee80211_proc_vcreate(struct ieee80211vap , struct file_operations ,
	char *);
	void ieee80211_proc_cleanup(struct ieee80211vap *);

	#if defined(CONFIG_VLAN_8021Q) \|\| defined(CONFIG_VLAN_8021Q_MODULE)
	#define IEEE80211_VLAN_TAG_USED 1

	#ifndef VLAN_GROUP_ARRAY_PART_LEN
	#define vlan_group_set_device(group, vid, dev) do { \
	group->vlan_devices[vid] = dev; \
	} while (0);
	#endif

	#else
	#define IEEE80211_VLAN_TAG_USED 0
	#endif
	void ieee80211_vlan_vattach(struct ieee80211vap *);
	void ieee80211_vlan_vdetach(struct ieee80211vap *);

	void ieee80211_ioctl_vattach(struct ieee80211vap *);
	void ieee80211_ioctl_vdetach(struct ieee80211vap *);
	void sample_rel_client_data(struct ieee80211vap *vap);
	struct ifreq;
	int ieee80211_ioctl_create_vap(struct ieee80211com , struct ifreq ,
	struct net_device *);
	int ieee80211_create_vap(struct ieee80211com , char , struct net_device *,
	int, int);

	/* For explicitly logging messages */
	void ieee80211_dot11_msg_send(struct ieee80211vap *vap,
	const char *mac_bssid,
	const char *message,
	const char *message_code,
	int message_reason,
	const char *message_description,
	const char *auth,
	const char *crypto);

	extern char *d11_m[];
	extern char *d11_c[];
	extern char *d11_r[];

	#endif /* _NET80211_IEEE80211_LINUX_H_ */