/*- * 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 1666 2006-07-04 10:22:11Z kelmo $ */#ifndef _NET80211_IEEE80211_LINUX_H_#define _NET80211_IEEE80211_LINUX_H_#ifdef CONFIG_NET_WIRELESS#include <linux/wireless.h>#endif/* * 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/* __skb_append got a third parameter in 2.6.14 */#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14)#define __skb_append(a,b,c)	__skb_append(a,b)#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)/* * Transmitted frames have the following information * held in the sk_buff control buffer.  This is used to * communicate various inter-procedural state that needs * to be associated with the frame for the duration of * it's existence. * * NB: sizeof(cb) == 48 and the vlan code grabs the first *     8 bytes so we reserve/avoid it. */struct ieee80211_cb {	u_int8_t vlan[8];			/* reserve for vlan tag info */	struct ieee80211_node *ni;	u_int32_t flags;#define	M_LINK0		0x01			/* frame needs WEP encryption */#define	M_FF		0x02			/* fast frame */#define	M_PWR_SAV	0x04			/* bypass power save handling */#define M_UAPSD		0x08			/* frame flagged for u-apsd handling */#define M_RAW           0x10	struct sk_buff *next;			/* fast frame sk_buf chain */