X-Git-Url: https://git.rohieb.name/openwrt.git/blobdiff_plain/5ae7e31f6f37c24f9c87a4f8c5b9fbdfa9de55ae..071f766b1ddbdd19a8c97ed2773e892c039a35d1:/package/madwifi/patches/124-linux24_compat.patch?ds=inline diff --git a/package/madwifi/patches/124-linux24_compat.patch b/package/madwifi/patches/124-linux24_compat.patch index 0340cf6ea..88601a4c7 100644 --- a/package/madwifi/patches/124-linux24_compat.patch +++ b/package/madwifi/patches/124-linux24_compat.patch @@ -1,9 +1,7 @@ -Index: madwifi-ng-r2756-20071018/ath/if_athvar.h -=================================================================== ---- madwifi-ng-r2756-20071018.orig/ath/if_athvar.h 2007-10-24 06:20:19.101777824 +0200 -+++ madwifi-ng-r2756-20071018/ath/if_athvar.h 2007-10-24 06:20:19.789817035 +0200 -@@ -128,6 +128,11 @@ - #define NETDEV_TX_BUSY 1 +--- a/ath/if_athvar.h ++++ b/ath/if_athvar.h +@@ -126,6 +126,11 @@ typedef void irqreturn_t; + #define ATH_GET_NETDEV_DEV(ndev) ((ndev)->class_dev.dev) #endif +#ifndef NETDEV_TX_OK @@ -14,3 +12,191 @@ Index: madwifi-ng-r2756-20071018/ath/if_athvar.h #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 *)) +--- a/ath/if_ath_radar.c ++++ b/ath/if_ath_radar.c +@@ -92,6 +92,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; +--- a/ath/if_ath.c ++++ b/ath/if_ath.c +@@ -4705,6 +4705,46 @@ ath_beacon_setup(struct ath_softc *sc, s + #undef USE_SHPREAMBLE + } + ++#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. + */ +--- /dev/null ++++ b/net80211/sort.c +@@ -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