[ar71xx] fix dir-825-b1 default network config after r21905
[openwrt.git] / package / madwifi / patches / 124-linux24_compat.patch
index 8721ec7..88601a4 100644 (file)
@@ -1,9 +1,7 @@
-Index: madwifi-ng-r2799-20071030/ath/if_athvar.h
-===================================================================
---- madwifi-ng-r2799-20071030.orig/ath/if_athvar.h     2007-10-31 14:04:49.429438302 +0100
-+++ madwifi-ng-r2799-20071030/ath/if_athvar.h  2007-10-31 14:04:50.117477510 +0100
-@@ -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-r2799-20071030/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 <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
This page took 0.032089 seconds and 4 git commands to generate.