Index: madwifi-trunk-r3776/ath/if_athvar.h =================================================================== --- madwifi-trunk-r3776.orig/ath/if_athvar.h 2008-07-17 00:21:39.000000000 +0200 +++ madwifi-trunk-r3776/ath/if_athvar.h 2008-07-17 00:50:03.000000000 +0200 @@ -129,6 +129,11 @@ #define ATH_GET_NETDEV_DEV(ndev) ((ndev)->class_dev.dev) #endif +#ifndef NETDEV_TX_OK +#define NETDEV_TX_OK 0 +#define NETDEV_TX_BUSY 1 +#endif + #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,23) static inline struct net_device *_alloc_netdev(int sizeof_priv, const char *mask, void (*setup)(struct net_device *)) Index: madwifi-trunk-r3776/ath/if_ath_radar.c =================================================================== --- madwifi-trunk-r3776.orig/ath/if_ath_radar.c 2008-07-17 00:21:39.000000000 +0200 +++ madwifi-trunk-r3776/ath/if_ath_radar.c 2008-07-17 00:50:03.000000000 +0200 @@ -89,6 +89,13 @@ #define nofloat_pct(_value, _pct) \ ( (_value * (1000 + _pct)) / 1000 ) +#ifndef list_for_each_entry_reverse +#define list_for_each_entry_reverse(pos, head, member) \ + for (pos = list_entry((head)->prev, typeof(*pos), member); \ + prefetch(pos->member.prev), &pos->member != (head); \ + pos = list_entry(pos->member.prev, typeof(*pos), member)) +#endif + struct radar_pattern_specification { /* The name of the rule/specification (i.e. what did we detect) */ const char *name; Index: madwifi-trunk-r3776/ath/if_ath.c =================================================================== --- madwifi-trunk-r3776.orig/ath/if_ath.c 2008-07-17 00:47:22.000000000 +0200 +++ madwifi-trunk-r3776/ath/if_ath.c 2008-07-17 00:50:03.000000000 +0200 @@ -4878,6 +4878,46 @@ return (txqs & (1 << qnum)); } +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15) +static inline int atomic_cmpxchg(atomic_t *v, int old, int new) +{ + int ret; + unsigned long flags; + + local_irq_save(flags); + ret = v->counter; + if (likely(ret == old)) + v->counter = new; + local_irq_restore(flags); + + return ret; +} + +/** + * atomic_add_unless - add unless the number is a given value + * @v: pointer of type atomic_t + * @a: the amount to add to v... + * @u: ...unless v is equal to u. + * + * Atomically adds @a to @v, so long as it was not @u. + * Returns non-zero if @v was not @u, and zero otherwise. + */ +static __inline__ int atomic_add_unless(atomic_t *v, int a, int u) +{ + int c, old; + c = atomic_read(v); + for (;;) { + if (unlikely(c == (u))) + break; + old = atomic_cmpxchg((v), c, c + (a)); + if (likely(old == c)) + break; + c = old; + } + return c != (u); +} +#endif + /* * Generate beacon frame and queue cab data for a VAP. */ Index: madwifi-trunk-r3776/net80211/sort.c =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ madwifi-trunk-r3776/net80211/sort.c 2008-07-17 00:50:03.000000000 +0200 @@ -0,0 +1,120 @@ +/* + * A fast, small, non-recursive O(nlog n) sort for the Linux kernel + * + * Jan 23 2005 Matt Mackall + */ + +#include +#include +#include + +static void u32_swap(void *a, void *b, int size) +{ + u32 t = *(u32 *)a; + *(u32 *)a = *(u32 *)b; + *(u32 *)b = t; +} + +static void generic_swap(void *a, void *b, int size) +{ + char t; + + do { + t = *(char *)a; + *(char *)a++ = *(char *)b; + *(char *)b++ = t; + } while (--size > 0); +} + +/** + * sort - sort an array of elements + * @base: pointer to data to sort + * @num: number of elements + * @size: size of each element + * @cmp: pointer to comparison function + * @swap: pointer to swap function or NULL + * + * This function does a heapsort on the given array. You may provide a + * swap function optimized to your element type. + * + * Sorting time is O(n log n) both on average and worst-case. While + * qsort is about 20% faster on average, it suffers from exploitable + * O(n*n) worst-case behavior and extra memory requirements that make + * it less suitable for kernel use. + */ + +static void sort(void *base, size_t num, size_t size, + int (*cmp)(const void *, const void *), + void (*swap)(void *, void *, int size)) +{ + /* pre-scale counters for performance */ + int i = (num/2 - 1) * size, n = num * size, c, r; + + if (!swap) + swap = (size == 4 ? u32_swap : generic_swap); + + /* heapify */ + for ( ; i >= 0; i -= size) { + for (r = i; r * 2 + size < n; r = c) { + c = r * 2 + size; + if (c < n - size && cmp(base + c, base + c + size) < 0) + c += size; + if (cmp(base + r, base + c) >= 0) + break; + swap(base + r, base + c, size); + } + } + + /* sort */ + for (i = n - size; i >= 0; i -= size) { + swap(base, base + i, size); + for (r = 0; r * 2 + size < i; r = c) { + c = r * 2 + size; + if (c < i - size && cmp(base + c, base + c + size) < 0) + c += size; + if (cmp(base + r, base + c) >= 0) + break; + swap(base + r, base + c, size); + } + } +} + +EXPORT_SYMBOL(sort); + +#if 0 +/* a simple boot-time regression test */ + +int cmpint(const void *a, const void *b) +{ + return *(int *)a - *(int *)b; +} + +static int sort_test(void) +{ + int *a, i, r = 1; + + a = kmalloc(1000 * sizeof(int), GFP_KERNEL); + BUG_ON(!a); + + printk("testing sort()\n"); + + for (i = 0; i < 1000; i++) { + r = (r * 725861) % 6599; + a[i] = r; + } + + sort(a, 1000, sizeof(int), cmpint, NULL); + + for (i = 0; i < 999; i++) + if (a[i] > a[i+1]) { + printk("sort() failed!\n"); + break; + } + + kfree(a); + + return 0; +} + +module_init(sort_test); +#endif