89a4592afe02ff30f79080820a49222e2dbadfe1
[debian/madwifi.git] / net80211 / ieee80211_linux.h
1 /*-
2  * Copyright (c) 2003-2005 Sam Leffler, Errno Consulting
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. The name of the author may not be used to endorse or promote products
14  *    derived from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  *
27  * $Id: ieee80211_linux.h 4139 2011-05-03 22:07:34Z proski $
28  */
29 #ifndef _NET80211_IEEE80211_LINUX_H_
30 #define _NET80211_IEEE80211_LINUX_H_
31
32 #include <linux/wireless.h>
33 #include <linux/fs.h>
34
35 /*
36  * Compatibility definition of statistics flags
37  * (bitmask in (struct iw_quality *)->updated)
38  */
39 #ifndef IW_QUAL_QUAL_UPDATED
40 #define IW_QUAL_QUAL_UPDATED    0x01    /* Value was updated since last read */
41 #define IW_QUAL_LEVEL_UPDATED   0x02
42 #define IW_QUAL_NOISE_UPDATED   0x04
43 #define IW_QUAL_QUAL_INVALID    0x10    /* Driver doesn't provide value */
44 #define IW_QUAL_LEVEL_INVALID   0x20
45 #define IW_QUAL_NOISE_INVALID   0x40
46 #endif /* IW_QUAL_QUAL_UPDATED */
47
48 #ifndef IW_QUAL_ALL_UPDATED
49 #define IW_QUAL_ALL_UPDATED \
50         (IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_UPDATED)
51 #endif
52 #ifndef IW_QUAL_ALL_INVALID
53 #define IW_QUAL_ALL_INVALID \
54         (IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID | IW_QUAL_NOISE_INVALID)
55 #endif
56
57 /*
58  * The RSSI values reported in the TX/RX descriptors in the driver are the SNR 
59  * expressed in dBm. Thus 'rssi' is signal level above the noise floor in dBm.
60  *
61  * Noise is measured in dBm and is negative unless there is an unimaginable 
62  * level of RF noise. 
63  *
64  * The signal level is noise + rssi.
65  *
66  * Note that the iw_quality values are 1 byte, and can be signed, unsigned or 
67  * negative depending on context.
68  *
69  */
70 static __inline void
71 set_quality(struct iw_quality *iq, u_int rssi, int noise)
72 {
73         iq->qual = rssi;
74         iq->noise = noise; 
75         iq->level = ((((int)rssi + noise) <= 0) ? ((int)rssi + noise) : 0);
76         iq->updated = IW_QUAL_ALL_UPDATED;
77 #if WIRELESS_EXT >= 19
78         iq->updated |= IW_QUAL_DBM;
79 #endif
80 }
81
82 /*
83  * Task deferral
84  *
85  * Deduce if tasklets are available.  If not then
86  * fall back to using the immediate work queue.
87  */
88 #include <linux/interrupt.h>
89 #ifdef DECLARE_TASKLET                  /* native tasklets */
90 #define IEEE80211_TQ_STRUCT tasklet_struct
91 #define IEEE80211_INIT_TQUEUE(a,b,c)    tasklet_init((a),(b),(unsigned long)(c))
92 #define IEEE80211_SCHEDULE_TQUEUE(a)    tasklet_schedule((a))
93 #define IEEE80211_CANCEL_TQUEUE(a)      if (!in_interrupt()) tasklet_kill((a))
94 typedef unsigned long IEEE80211_TQUEUE_ARG;
95 #define mark_bh(a) do {} while (0)
96 #else                                   /* immediate work queue */
97 #define IEEE80211_TQ_STRUCT tq_struct
98 #define IEEE80211_INIT_TQUEUE(a,b,c)            INIT_TQUEUE(a,b,c)
99 #define IEEE80211_SCHEDULE_TQUEUE(a) do { \
100         int __macro_needmark;           \
101         __macro_needmark |= queue_task((a), &tq_immediate);     \
102         if (__macro_needmark)           \
103                 mark_bh(IMMEDIATE_BH);  \
104 } while(0)
105 typedef void *IEEE80211_TQUEUE_ARG;
106 #define tasklet_disable(t)      do { (void) t; local_bh_disable(); } while (0)
107 #define tasklet_enable(t)       do { (void) t; local_bh_enable(); } while (0)
108 /* XXX: not supporting cancel in old kernels! */
109 #define IEEE80211_CANCEL_TQUEUE(a)      ((a),0)
110 #endif /* !DECLARE_TASKLET */
111
112 #define IEEE80211_RESCHEDULE    schedule
113
114 /*
115  * Beacon handler locking definitions.
116  * Beacon locking 
117  * UAPSD locking 
118  */
119 typedef spinlock_t ieee80211com_lock_t;
120 #define IEEE80211_LOCK_INIT(_ic, _name)                         \
121         spin_lock_init(&(_ic)->ic_comlock)
122 #define IEEE80211_LOCK_DESTROY(_ic)
123 #define IEEE80211_LOCK_IRQ(_ic) do {                            \
124         unsigned long __ilockflags;                             \
125         spin_lock_irqsave(&(_ic)->ic_comlock, __ilockflags);
126 #define IEEE80211_UNLOCK_IRQ(_ic)                                       \
127         spin_unlock_irqrestore(&(_ic)->ic_comlock, __ilockflags);       \
128 } while (0)
129 #define IEEE80211_UNLOCK_IRQ_EARLY(_ic)                                 \
130         spin_unlock_irqrestore(&(_ic)->ic_comlock, __ilockflags);
131 #define IEEE80211_LOCK_BH(_ic)  spin_lock_bh(&(_ic)->ic_comlock)
132 #define IEEE80211_UNLOCK_BH(_ic) spin_unlock_bh(&(_ic)->ic_comlock)
133 #define IEEE80211_LOCK(_ic)     spin_lock(&(_ic)->ic_comlock)
134 #define IEEE80211_UNLOCK(_ic)   spin_unlock(&(_ic)->ic_comlock)
135
136 /* NB: beware, spin_is_locked() is unusable for !SMP */
137 #if defined(CONFIG_SMP)
138 #define IEEE80211_LOCK_ASSERT(_ic) \
139         KASSERT(spin_is_locked(&(_ic)->ic_comlock),("ieee80211com not locked!"))
140 #else
141 #define IEEE80211_LOCK_ASSERT(_ic)
142 #endif
143
144 #define IEEE80211_VAPS_LOCK_INIT(_ic, _name)            \
145         spin_lock_init(&(_ic)->ic_vapslock)
146 #define IEEE80211_VAPS_LOCK_DESTROY(_ic)
147 #define IEEE80211_VAPS_LOCK(_ic)        spin_lock(&(_ic)->ic_vapslock);
148 #define IEEE80211_VAPS_UNLOCK(_ic)      spin_unlock(&(_ic)->ic_vapslock);
149 #define IEEE80211_VAPS_LOCK_BH(_ic)     spin_lock_bh(&(_ic)->ic_vapslock);
150 #define IEEE80211_VAPS_UNLOCK_BH(_ic)   spin_unlock_bh(&(_ic)->ic_vapslock);
151 #define IEEE80211_VAPS_LOCK_IRQ(_ic)    do {    \
152         int _vaps_lockflags;                    \
153         spin_lock_irqsave(&(_ic)->ic_vapslock, _vaps_lockflags);
154 #define IEEE80211_VAPS_UNLOCK_IRQ(_ic)  \
155         spin_unlock_irqrestore(&(_ic)->ic_vapslock, _vaps_lockflags); \
156 } while (0)
157 #define IEEE80211_VAPS_UNLOCK_IRQ_EARLY(_ic)    spin_unlock_irqrestore(&(_ic)->ic_vapslock, _vaps_lockflags)
158
159
160 /* NB: beware, spin_is_locked() is unusable for !SMP */
161 #if defined(CONFIG_SMP)
162 #define IEEE80211_VAPS_LOCK_ASSERT(_ic) \
163         KASSERT(spin_is_locked(&(_ic)->ic_vapslock),("ieee80211com_vaps not locked!"))
164 #else
165 #define IEEE80211_VAPS_LOCK_ASSERT(_ic)
166 #endif
167
168
169 /*
170  * Node locking definitions.
171  */
172 typedef spinlock_t ieee80211_node_lock_t;
173 #define IEEE80211_NODE_LOCK_INIT(_nt, _name)    spin_lock_init(&(_nt)->nt_nodelock)
174 #define IEEE80211_NODE_LOCK_DESTROY(_nt)
175 #define IEEE80211_NODE_LOCK(_nt)        spin_lock(&(_nt)->nt_nodelock)
176 #define IEEE80211_NODE_UNLOCK(_nt)      spin_unlock(&(_nt)->nt_nodelock)
177 #define IEEE80211_NODE_LOCK_BH(_nt)     spin_lock_bh(&(_nt)->nt_nodelock)
178 #define IEEE80211_NODE_UNLOCK_BH(_nt)   spin_unlock_bh(&(_nt)->nt_nodelock)
179 #define IEEE80211_NODE_LOCK_IRQ(_nt)    do {    \
180         unsigned long __node_lockflags;         \
181         spin_lock_irqsave(&(_nt)->nt_nodelock, __node_lockflags);
182 #define IEEE80211_NODE_UNLOCK_IRQ(_nt)          \
183         spin_unlock_irqrestore(&(_nt)->nt_nodelock, __node_lockflags); \
184 } while(0)
185 #define IEEE80211_NODE_UNLOCK_IRQ_EARLY(_nt)            \
186         spin_unlock_irqrestore(&(_nt)->nt_nodelock, __node_lockflags);
187
188 /* NB: beware, *_is_locked() are bogusly defined for UP+!PREEMPT */
189 #if (defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)) && defined(spinlock_is_locked)
190 #define IEEE80211_NODE_LOCK_ASSERT(_nt) \
191         KASSERT(spinlock_is_locked(&(_nt)->nt_nodelock), \
192                 ("802.11 node table not locked!"))
193 #else
194 #define IEEE80211_NODE_LOCK_ASSERT(_nt)
195 #endif
196
197 /*
198  * Node table scangen locking definitions.
199  */
200 typedef spinlock_t ieee80211_scan_lock_t;
201 #define IEEE80211_SCAN_LOCK_INIT(_nt, _name) spin_lock_init(&(_nt)->nt_scanlock)
202 #define IEEE80211_SCAN_LOCK_DESTROY(_nt)
203 #define IEEE80211_SCAN_LOCK_BH(_nt)     spin_lock_bh(&(_nt)->nt_scanlock)
204 #define IEEE80211_SCAN_UNLOCK_BH(_nt)   spin_unlock_bh(&(_nt)->nt_scanlock)
205 #define IEEE80211_SCAN_LOCK_IRQ(_nt)    do {    \
206         unsigned long __scan_lockflags;         \
207         spin_lock_irqsave(&(_nt)->nt_scanlock, __scan_lockflags);
208 #define IEEE80211_SCAN_UNLOCK_IRQ(_nt)          \
209         spin_unlock_irqrestore(&(_nt)->nt_scanlock, __scan_lockflags); \
210 } while (0)
211 #define IEEE80211_SCAN_UNLOCK_IRQ_EARLY(_nt)            \
212         spin_unlock_irqrestore(&(_nt)->nt_scanlock, __scan_lockflags);
213
214 /* NB: beware, spin_is_locked() is unusable for !SMP */
215 #if defined(CONFIG_SMP)
216 #define IEEE80211_SCAN_LOCK_ASSERT(_nt) \
217         KASSERT(spin_is_locked(&(_nt)->nt_scanlock), ("scangen not locked!"))
218 #else
219 #define IEEE80211_SCAN_LOCK_ASSERT(_nt)
220 #endif
221
222 /*
223  * 802.1x MAC ACL database locking definitions.
224  */
225 typedef spinlock_t acl_lock_t;
226 #define ACL_LOCK_INIT(_as, _name)       spin_lock_init(&(_as)->as_lock)
227 #define ACL_LOCK_DESTROY(_as)
228 #define ACL_LOCK(_as)                   spin_lock(&(_as)->as_lock)
229 #define ACL_UNLOCK(_as)                 spin_unlock(&(_as)->as_lock)
230 #define ACL_LOCK_BH(_as)                spin_lock_bh(&(_as)->as_lock)
231 #define ACL_UNLOCK_BH(_as)              spin_unlock_bh(&(_as)->as_lock)
232
233 /* NB: beware, spin_is_locked() is unusable for !SMP */
234 #if defined(CONFIG_SMP)
235 #define ACL_LOCK_ASSERT(_as) \
236         KASSERT(spin_is_locked(&(_as)->as_lock), ("ACL not locked!"))
237 #else
238 #define ACL_LOCK_ASSERT(_as)
239 #endif
240
241 /*
242  * Per-node power-save queue definitions.  Beware of control
243  * flow with IEEE80211_NODE_SAVEQ_LOCK/IEEE80211_NODE_SAVEQ_UNLOCK.
244  */
245 #define IEEE80211_NODE_SAVEQ_INIT(_ni, _name) do {              \
246         skb_queue_head_init(&(_ni)->ni_savedq);                 \
247 } while (0)
248 #define IEEE80211_NODE_SAVEQ_DESTROY(_ni)
249 #define IEEE80211_NODE_SAVEQ_QLEN(_ni)  skb_queue_len(&(_ni)->ni_savedq)
250 #define IEEE80211_NODE_SAVEQ_LOCK(_ni)                          \
251         spin_lock(&(_ni)->ni_savedq.lock)
252 #define IEEE80211_NODE_SAVEQ_UNLOCK(_ni)                        \
253         spin_unlock(&(_ni)->ni_savedq.lock)
254 #define IEEE80211_NODE_SAVEQ_LOCK_IRQ(_ni) do {                 \
255         unsigned long __sqlockflags;                            \
256         spin_lock_irqsave(&(_ni)->ni_savedq.lock, __sqlockflags);
257 #define IEEE80211_NODE_SAVEQ_UNLOCK_IRQ(_ni)                    \
258         spin_unlock_irqrestore(&(_ni)->ni_savedq.lock, __sqlockflags);\
259 } while (0)
260
261 /* caller MUST lock IEEE80211_NODE_SAVEQ */
262 #define IEEE80211_NODE_SAVEQ_DEQUEUE(_ni, _skb) ({              \
263         _skb = __skb_dequeue(&(_ni)->ni_savedq);                \
264         skb_queue_len(&(_ni)->ni_savedq);                       \
265 })
266 #define _IEEE80211_NODE_SAVEQ_ENQUEUE(_ni, _skb, _qlen, _age) do {      \
267         struct sk_buff *tail = skb_peek_tail(&(_ni)->ni_savedq);        \
268         if (tail != NULL) {                                             \
269                 _age -= M_AGE_GET(tail);                                \
270                 __skb_queue_after(&(_ni)->ni_savedq, tail, _skb);       \
271         } else {                                                        \
272                 __skb_queue_head(&(_ni)->ni_savedq, _skb);              \
273         }                                                               \
274         M_AGE_SET(_skb, _age);                                          \
275         (_qlen) = skb_queue_len(&(_ni)->ni_savedq);                     \
276 } while (0)
277
278 /*
279  * Transmitted frames have the following information
280  * held in the sk_buff control buffer.  This is used to
281  * communicate various inter-procedural state that needs
282  * to be associated with the frame for the duration of
283  * it's existence.
284  *
285  * NB: sizeof(cb) == 48 and the vlan code grabs the first
286  *     8 bytes so we reserve/avoid it.
287  */
288 struct ieee80211_cb {
289         u_int8_t vlan[8];                       /* reserve for vlan tag info */
290         struct ieee80211_node *ni;
291         u_int32_t flags;
292 #define M_LINK0         0x01                    /* frame needs WEP encryption */
293 #define M_FF            0x02                    /* fast frame */
294 #define M_PWR_SAV       0x04                    /* bypass power save handling */
295 #define M_UAPSD         0x08                    /* frame flagged for u-apsd handling */
296 #define M_RAW           0x10
297         struct sk_buff *next;                   /* fast frame sk_buf chain */
298 };
299
300
301 #define M_FLAG_SET(_skb, _flag) \
302         (((struct ieee80211_cb *)(_skb)->cb)->flags |= (_flag))
303 #define M_FLAG_CLR(_skb, _flag) \
304         (((struct ieee80211_cb *)(_skb)->cb)->flags &= ~(_flag))
305 #define M_FLAG_GET(_skb, _flag) \
306         (((struct ieee80211_cb *)(_skb)->cb)->flags & (_flag))
307 #define M_FLAG_KEEP_ONLY(_skb, _flag) \
308         (((struct ieee80211_cb *)(_skb)->cb)->flags &= (_flag))
309
310 #define M_PWR_SAV_SET(skb) M_FLAG_SET((skb), M_PWR_SAV)
311 #define M_PWR_SAV_CLR(skb) M_FLAG_CLR((skb), M_PWR_SAV)
312 #define M_PWR_SAV_GET(skb) M_FLAG_GET((skb), M_PWR_SAV)
313
314 /*
315  * Skbufs on the power save queue are tagged with an age and
316  * timed out.  We reuse the hardware checksum field in the
317  * mbuf packet header to store this data.
318  * XXX use private cb area
319  */
320 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
321 #define skb_age csum_offset
322 #else
323 #define skb_age csum
324 #endif
325
326 #define M_AGE_SET(skb,v)        (skb->skb_age = v)
327 #define M_AGE_GET(skb)          (skb->skb_age)
328 #define M_AGE_SUB(skb,adj)      (skb->skb_age -= adj)
329
330 struct ieee80211com;
331 struct ieee80211vap;
332
333 int ieee80211_load_module(const char *);
334
335 /*
336  * Node reference counting definitions.
337  *
338  * ieee80211_node_initref       initialize the reference count to 1
339  * ieee80211_node_incref        add a reference
340  * ieee80211_node_decref        remove a reference
341  * ieee80211_node_dectestref    remove a reference and return 1 if this
342  *                              is the last reference, otherwise 0
343  * ieee80211_node_refcnt        reference count for printing (only)
344  */
345 #define ieee80211_node_initref(_ni)     atomic_set(&(_ni)->ni_refcnt, 1)
346 #define ieee80211_node_incref(_ni)      atomic_inc(&(_ni)->ni_refcnt)
347 #define ieee80211_node_decref(_ni)      atomic_dec(&(_ni)->ni_refcnt)
348 #define ieee80211_node_dectestref(_ni)  atomic_dec_and_test(&(_ni)->ni_refcnt)
349 #define ieee80211_node_refcnt(_ni)      (_ni)->ni_refcnt.counter
350
351 #define le16toh(_x)     le16_to_cpu(_x)
352 #define htole16(_x)     cpu_to_le16(_x)
353 #define le32toh(_x)     le32_to_cpu(_x)
354 #define htole32(_x)     cpu_to_le32(_x)
355 #define be32toh(_x)     be32_to_cpu(_x)
356 #define htobe32(_x)     cpu_to_be32(_x)
357
358 /*
359  * Linux has no equivalents to malloc types so null these out.
360  */
361 #define MALLOC_DEFINE(type, shortdesc, longdesc)
362 #define MALLOC_DECLARE(type)
363
364 /*
365  * flags to malloc.
366  */
367 #define M_NOWAIT        0x0001          /* do not block */
368 #define M_WAITOK        0x0002          /* ok to block */
369 #define M_ZERO          0x0100          /* bzero the allocation */
370
371 static __inline void *
372 ieee80211_malloc(size_t size, int flags)
373 {
374         void *p = kmalloc(size, flags & M_NOWAIT ? GFP_ATOMIC : GFP_KERNEL);
375         if (p && (flags & M_ZERO))
376                 memset(p, 0, size);
377         return p;
378 }
379 #define MALLOC(_ptr, cast, _size, _type, _flags) \
380         ((_ptr) = (cast)ieee80211_malloc(_size, _flags))
381 #define FREE(addr, type)        kfree((addr))
382
383 /*
384  * This unlikely to be popular but it dramatically reduces diffs.
385  */
386 #define printf(...) printk(__VA_ARGS__)
387 struct ieee80211com;
388 extern void if_printf(struct net_device *, const char *, ...);
389 extern const char *ether_sprintf(const u_int8_t *);
390
391 /*
392  * Queue write-arounds and support routines.
393  */
394 extern  struct sk_buff *ieee80211_getmgtframe(u_int8_t **frm, u_int pktlen);
395 #define IF_ENQUEUE(_q,_skb)     skb_queue_tail(_q,_skb)
396 #define IF_DEQUEUE(_q,_skb)     (_skb = skb_dequeue(_q))
397 #define _IF_QLEN(_q)            skb_queue_len(_q)
398 #define IF_DRAIN(_q)            skb_queue_drain(_q)
399 extern  void skb_queue_drain(struct sk_buff_head *q);
400
401 #ifndef __MOD_INC_USE_COUNT
402 #define _MOD_INC_USE(_m, _err)                                          \
403         if (!try_module_get(_m)) {                                      \
404                 printk(KERN_WARNING "%s: try_module_get failed\n",      \
405                         __func__); \
406                 _err;                                                   \
407         }
408 #define _MOD_DEC_USE(_m)                module_put(_m)
409 #else
410 #define _MOD_INC_USE(_m, _err)  MOD_INC_USE_COUNT
411 #define _MOD_DEC_USE(_m)        MOD_DEC_USE_COUNT
412 #endif
413
414 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
415 static __inline u_int64_t
416 get_jiffies_64(void)
417 {
418         return (u_int64_t) jiffies;             /* XXX not right */
419 }
420 #endif
421
422 /* msecs_to_jiffies appeared in 2.6.7 and 2.4.29 */
423 #include <linux/delay.h>
424 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) && \
425       LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7)) || \
426      LINUX_VERSION_CODE < KERNEL_VERSION(2,4,29)
427
428 /* The following definitions and inline functions are
429  * copied from the kernel src, include/linux/jiffies.h */
430
431 #ifndef MSEC_PER_SEC
432 #define MSEC_PER_SEC (1000L)
433 #endif
434
435 #ifndef MAX_JIFFY_OFFSET
436 #define MAX_JIFFY_OFFSET ((~0UL >> 1)-1)
437 #endif
438
439 static __inline unsigned int jiffies_to_msecs(const unsigned long j)
440 {
441 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
442         return (MSEC_PER_SEC / HZ) * j;
443 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
444         return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
445 #else
446         return (j * MSEC_PER_SEC) / HZ;
447 #endif
448 }
449
450 static __inline unsigned long msecs_to_jiffies(const unsigned int m)
451 {
452         if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
453                 return MAX_JIFFY_OFFSET;
454 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
455         return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
456 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
457         return m * (HZ / MSEC_PER_SEC);
458 #else
459         return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;
460 #endif
461 }
462
463 #endif
464
465 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,7)
466 #include <linux/jiffies.h>
467 #endif
468
469 #ifndef CLONE_KERNEL
470 /*
471  * List of flags we want to share for kernel threads,
472  * if only because they are not used by them anyway.
473  */
474 #define CLONE_KERNEL    (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
475 #endif
476
477 #include <linux/mm.h>
478 #ifndef offset_in_page
479 #define offset_in_page(p) ((unsigned long) (p) & ~PAGE_MASK)
480 #endif
481
482 #ifndef module_put_and_exit
483 #define module_put_and_exit(code) do {  \
484         _MOD_DEC_USE(THIS_MODULE);      \
485         do_exit(code);                  \
486 } while (0)
487 #endif
488
489 /*
490  * Linux uses __BIG_ENDIAN and __LITTLE_ENDIAN while BSD uses _foo
491  * and an explicit _BYTE_ORDER.  Sorry, BSD got there first--define
492  * things in the BSD way...
493  */
494 #undef _LITTLE_ENDIAN
495 #define _LITTLE_ENDIAN  1234    /* LSB first: i386, vax */
496 #undef _BIG_ENDIAN
497 #define _BIG_ENDIAN     4321    /* MSB first: 68000, ibm, net */
498 #include <asm/byteorder.h>
499 #if defined(__LITTLE_ENDIAN)
500 #define _BYTE_ORDER     _LITTLE_ENDIAN
501 #elif defined(__BIG_ENDIAN)
502 #define _BYTE_ORDER     _BIG_ENDIAN
503 #else
504 #error "Please fix asm/byteorder.h"
505 #endif
506
507
508 /*
509  * Deal with the sysctl handler api changing.
510  */
511 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8)
512 #define IEEE80211_SYSCTL_DECL(f, ctl, write, filp, buffer, lenp, ppos) \
513         f(ctl_table *ctl, int write, struct file *filp, \
514           void __user *buffer, size_t *lenp)
515 #define IEEE80211_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer, lenp, ppos) \
516         proc_dointvec(ctl, write, filp, buffer, lenp)
517 #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
518 #define IEEE80211_SYSCTL_DECL(f, ctl, write, filp, buffer, lenp, ppos) \
519         f(ctl_table *ctl, int write, struct file *filp, \
520           void __user *buffer, size_t *lenp, loff_t *ppos)
521 #define IEEE80211_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer, lenp, ppos) \
522         proc_dointvec(ctl, write, filp, buffer, lenp, ppos)
523 #else /* Linux 2.6.32+ */
524 #define IEEE80211_SYSCTL_DECL(f, ctl, write, filp, buffer, lenp, ppos) \
525         f(ctl_table *ctl, int write, \
526           void __user *buffer, size_t *lenp, loff_t *ppos)
527 #define IEEE80211_SYSCTL_PROC_DOINTVEC(ctl, write, filp, buffer, lenp, ppos) \
528         proc_dointvec(ctl, write, buffer, lenp, ppos)
529 #endif
530
531 void ieee80211_sysctl_vattach(struct ieee80211vap *);
532 void ieee80211_sysctl_vdetach(struct ieee80211vap *);
533 int ieee80211_proc_vcreate(struct ieee80211vap *, struct file_operations *,
534                char *);
535 void ieee80211_proc_cleanup(struct ieee80211vap *);
536
537 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
538 #define IEEE80211_VLAN_TAG_USED 1
539
540 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,20)
541 #define vlan_hwaccel_receive_skb(skb, grp, tag) vlan_hwaccel_rx(skb, grp, tag)
542 #endif
543
544 #ifndef VLAN_GROUP_ARRAY_PART_LEN
545 #define vlan_group_set_device(group, vid, dev) do { \
546         group->vlan_devices[vid] = dev; \
547 } while (0);
548 #endif
549
550 #else
551 #define IEEE80211_VLAN_TAG_USED 0
552 #endif
553 void ieee80211_vlan_vattach(struct ieee80211vap *);
554 void ieee80211_vlan_vdetach(struct ieee80211vap *);
555
556 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
557 #define free_netdev(dev)        kfree(dev)
558 #endif
559
560 int ieee80211_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
561 void ieee80211_ioctl_vattach(struct ieee80211vap *);
562 void ieee80211_ioctl_vdetach(struct ieee80211vap *);
563 struct ifreq;
564 int ieee80211_ioctl_create_vap(struct ieee80211com *, struct ifreq *,
565         struct net_device *);
566 int ieee80211_create_vap(struct ieee80211com *, char *, struct net_device *,
567         int, int);
568 void ieee80211_vlan_register(struct net_device *dev, struct vlan_group *grp);
569 void ieee80211_vlan_add_vid(struct net_device *dev, unsigned short vid);
570 void ieee80211_vlan_kill_vid(struct net_device *dev, unsigned short vid);
571
572 #endif /* _NET80211_IEEE80211_LINUX_H_ */