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 <mpm@selenic.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+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