mirror of
git://projects.qi-hardware.com/openwrt-xburst.git
synced 2024-08-20 19:14:36 +03:00
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@13096 3c298f89-4303-0410-b956-a3cf2f4a3e73
203 lines
4.6 KiB
Diff
203 lines
4.6 KiB
Diff
--- 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
|
|
+#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 *))
|
|
--- 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
|