X-Git-Url: https://git.rohieb.name/openwrt.git/blobdiff_plain/0e9ca337996b5b4ef392bc92cde7f4bc9699b3ea..613e530afeab2eb78d7b4100420fd305662beab1:/package/madwifi/patches-r3776/124-linux24_compat.patch diff --git a/package/madwifi/patches-r3776/124-linux24_compat.patch b/package/madwifi/patches-r3776/124-linux24_compat.patch new file mode 100644 index 000000000..0ef7d9274 --- /dev/null +++ b/package/madwifi/patches-r3776/124-linux24_compat.patch @@ -0,0 +1,210 @@ +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