summaryrefslogtreecommitdiff
path: root/package/broadcom-wl/src
diff options
context:
space:
mode:
authorFelix Fietkau <nbd@openwrt.org>2008-01-06 19:28:07 +0000
committerFelix Fietkau <nbd@openwrt.org>2008-01-06 19:28:07 +0000
commit178721f76bf6e298b36f6cbfc725ea3ce689a57c (patch)
tree72016cc3537dd7524b206cab8c8d44b197efec1d /package/broadcom-wl/src
parent563d234596124a2e8a3f8489b8a82bd018ed87a7 (diff)
downloadmtk-20170518-178721f76bf6e298b36f6cbfc725ea3ce689a57c.zip
mtk-20170518-178721f76bf6e298b36f6cbfc725ea3ce689a57c.tar.gz
mtk-20170518-178721f76bf6e298b36f6cbfc725ea3ce689a57c.tar.bz2
update brcm-2.4 to 2.4.35.4, integrate new broadcom system code, update broadcom-wl to a contributed version (v4.150.10.5) - no bcm57xx support yet, will follow shortly
SVN-Revision: 10137
Diffstat (limited to 'package/broadcom-wl/src')
-rw-r--r--package/broadcom-wl/src/driver/Makefile5
-rw-r--r--package/broadcom-wl/src/driver/bcmutils.c2306
-rw-r--r--package/broadcom-wl/src/driver/bcmutils.h582
-rw-r--r--package/broadcom-wl/src/driver/hnddma.c3164
-rw-r--r--package/broadcom-wl/src/driver/hnddma.h12
-rw-r--r--package/broadcom-wl/src/driver/linux_osl.c952
-rw-r--r--package/broadcom-wl/src/driver/linux_osl.h322
-rw-r--r--package/broadcom-wl/src/driver/patchtable.pl61
-rw-r--r--package/broadcom-wl/src/driver/pktq.h97
-rw-r--r--package/broadcom-wl/src/driver/proto/802.11.h1387
-rw-r--r--package/broadcom-wl/src/driver/proto/802.11e.h123
-rw-r--r--package/broadcom-wl/src/driver/proto/802.1d.h38
-rw-r--r--package/broadcom-wl/src/driver/proto/802.3.h20
-rw-r--r--package/broadcom-wl/src/driver/proto/bcmarp.h60
-rw-r--r--package/broadcom-wl/src/driver/proto/bcmdhcp.h36
-rw-r--r--package/broadcom-wl/src/driver/proto/bcmeth.h101
-rw-r--r--package/broadcom-wl/src/driver/proto/bcmevent.h166
-rw-r--r--package/broadcom-wl/src/driver/proto/bcmip.h152
-rw-r--r--package/broadcom-wl/src/driver/proto/bcmtcp.h68
-rw-r--r--package/broadcom-wl/src/driver/proto/bcmudp.h48
-rw-r--r--package/broadcom-wl/src/driver/proto/eap.h45
-rw-r--r--package/broadcom-wl/src/driver/proto/eapol.h179
-rw-r--r--package/broadcom-wl/src/driver/proto/ethernet.h175
-rw-r--r--package/broadcom-wl/src/driver/proto/vlan.h52
-rw-r--r--package/broadcom-wl/src/driver/proto/wpa.h158
-rw-r--r--package/broadcom-wl/src/driver/sbhnddma.h4
-rw-r--r--package/broadcom-wl/src/wlc/wlc.c225
-rw-r--r--package/broadcom-wl/src/wlcompat/Makefile3
-rw-r--r--package/broadcom-wl/src/wlcompat/wlcompat.c26
29 files changed, 7990 insertions, 2577 deletions
diff --git a/package/broadcom-wl/src/driver/Makefile b/package/broadcom-wl/src/driver/Makefile
index 0a16bdc..c75795a 100644
--- a/package/broadcom-wl/src/driver/Makefile
+++ b/package/broadcom-wl/src/driver/Makefile
@@ -23,9 +23,6 @@ obj-m := $(O_TARGET)
wl_mod$(MOD_NAME).o: wl_apsta$(MOD_NAME).o
perl -ne 's,eth%d,wl%d\x00,g,print' < $< > $@
-wl$(MOD_NAME).o.patch: wl$(MOD_NAME).o
- $(OBJDUMP) -d $< | perl patchtable.pl > $@
-
-modules: wl$(MOD_NAME).o.patch
+modules: wl$(MOD_NAME).o
include $(TOPDIR)/Rules.make
diff --git a/package/broadcom-wl/src/driver/bcmutils.c b/package/broadcom-wl/src/driver/bcmutils.c
index 7592f23..88337d6 100644
--- a/package/broadcom-wl/src/driver/bcmutils.c
+++ b/package/broadcom-wl/src/driver/bcmutils.c
@@ -1,730 +1,1590 @@
/*
- * Misc useful OS-independent routines.
+ * Driver O/S-independent utility routines
*
- * Copyright 2006, Broadcom Corporation
+ * Copyright 2007, Broadcom Corporation
* All Rights Reserved.
*
* THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
* KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
* SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
- * $Id: bcmutils.c,v 1.1.1.12 2006/02/27 03:43:16 honor Exp $
+ * $Id$
*/
#include <typedefs.h>
#include <bcmdefs.h>
#include <stdarg.h>
+#include "bcmutils.h"
#include <osl.h>
-#include "linux_osl.h"
-#include "pktq.h"
-#include <bcmutils.h>
#include <sbutils.h>
#include <bcmnvram.h>
#include <bcmendian.h>
#include <bcmdevs.h>
-#include "bcmip.h"
-
-#define ETHER_TYPE_8021Q 0x8100
-#define ETHER_TYPE_IP 0x0800
-#define VLAN_PRI_SHIFT 13
-#define VLAN_PRI_MASK 7
-
-
-struct ether_header {
- uint8 ether_dhost[6];
- uint8 ether_shost[6];
- uint16 ether_type;
-} __attribute__((packed));
-
-
-struct ethervlan_header {
- uint8 ether_dhost[6];
- uint8 ether_shost[6];
- uint16 vlan_type; /* 0x8100 */
- uint16 vlan_tag; /* priority, cfi and vid */
- uint16 ether_type;
-};
+#include "proto/ethernet.h"
+#include "proto/vlan.h"
+#include "proto/bcmip.h"
+#include "proto/bcmtcp.h"
+#include "proto/802.1d.h"
+
+#ifdef BCMPERFSTATS
+#include <bcmperf.h>
+#endif
+
+#if 0
+/* nvram vars cache */
+static char *nvram_vars = NULL;
+static int vars_len = -1;
+#endif
/* copy a pkt buffer chain into a buffer */
uint
-pktcopy(osl_t *osh, void *p, uint offset, int len, uchar *buf)
+pktcopy (osl_t * osh, void *p, uint offset, int len, uchar * buf)
{
- uint n, ret = 0;
-
- if (len < 0)
- len = 4096; /* "infinite" */
-
- /* skip 'offset' bytes */
- for (; p && offset; p = PKTNEXT(osh, p)) {
- if (offset < (uint)PKTLEN(osh, p))
- break;
- offset -= PKTLEN(osh, p);
- }
-
- if (!p)
- return 0;
-
- /* copy the data */
- for (; p && len; p = PKTNEXT(osh, p)) {
- n = MIN((uint)PKTLEN(osh, p) - offset, (uint)len);
- bcopy(PKTDATA(osh, p) + offset, buf, n);
- buf += n;
- len -= n;
- ret += n;
- offset = 0;
- }
-
- return ret;
+ uint n, ret = 0;
+
+ if (len < 0)
+ len = 4096; /* "infinite" */
+
+ /* skip 'offset' bytes */
+ for (; p && offset; p = PKTNEXT (osh, p))
+ {
+ if (offset < (uint) PKTLEN (osh, p))
+ break;
+ offset -= PKTLEN (osh, p);
+ }
+
+ if (!p)
+ return 0;
+
+ /* copy the data */
+ for (; p && len; p = PKTNEXT (osh, p))
+ {
+ n = MIN ((uint) PKTLEN (osh, p) - offset, (uint) len);
+ bcopy (PKTDATA (osh, p) + offset, buf, n);
+ buf += n;
+ len -= n;
+ ret += n;
+ offset = 0;
+ }
+
+ return ret;
}
/* return total length of buffer chain */
uint
-pkttotlen(osl_t *osh, void *p)
+pkttotlen (osl_t * osh, void *p)
{
- uint total;
+ uint total;
- total = 0;
- for (; p; p = PKTNEXT(osh, p))
- total += PKTLEN(osh, p);
- return (total);
+ total = 0;
+ for (; p; p = PKTNEXT (osh, p))
+ total += PKTLEN (osh, p);
+ return (total);
}
/* return the last buffer of chained pkt */
void *
-pktlast(osl_t *osh, void *p)
+pktlast (osl_t * osh, void *p)
{
- for (; PKTNEXT(osh, p); p = PKTNEXT(osh, p))
- ;
+ for (; PKTNEXT (osh, p); p = PKTNEXT (osh, p))
+ ;
- return (p);
+ return (p);
}
/*
* osl multiple-precedence packet queue
- * hi_prec is always >= the number of the highest non-empty queue
+ * hi_prec is always >= the number of the highest non-empty precedence
*/
void *
-pktq_penq(struct pktq *pq, int prec, void *p)
+pktq_penq (struct pktq *pq, int prec, void *p)
{
- struct pktq_prec *q;
+ struct pktq_prec *q;
- ASSERT(prec >= 0 && prec < pq->num_prec);
- ASSERT(PKTLINK(p) == NULL); /* queueing chains not allowed */
+ ASSERT (prec >= 0 && prec < pq->num_prec);
+ ASSERT (PKTLINK (p) == NULL); /* queueing chains not allowed */
- ASSERT(!pktq_full(pq));
- ASSERT(!pktq_pfull(pq, prec));
+ ASSERT (!pktq_full (pq));
+ ASSERT (!pktq_pfull (pq, prec));
- q = &pq->q[prec];
+ q = &pq->q[prec];
- if (q->head)
- PKTSETLINK(q->tail, p);
- else
- q->head = p;
+ if (q->head)
+ PKTSETLINK (q->tail, p);
+ else
+ q->head = p;
- q->tail = p;
- q->len++;
+ q->tail = p;
+ q->len++;
- pq->len++;
+ pq->len++;
- if (pq->hi_prec < prec)
- pq->hi_prec = (uint8)prec;
+ if (pq->hi_prec < prec)
+ pq->hi_prec = (uint8) prec;
- return p;
+ return p;
}
void *
-pktq_penq_head(struct pktq *pq, int prec, void *p)
+pktq_penq_head (struct pktq *pq, int prec, void *p)
{
- struct pktq_prec *q;
+ struct pktq_prec *q;
- ASSERT(prec >= 0 && prec < pq->num_prec);
- ASSERT(PKTLINK(p) == NULL); /* queueing chains not allowed */
+ ASSERT (prec >= 0 && prec < pq->num_prec);
+ ASSERT (PKTLINK (p) == NULL); /* queueing chains not allowed */
- ASSERT(!pktq_full(pq));
- ASSERT(!pktq_pfull(pq, prec));
+ ASSERT (!pktq_full (pq));
+ ASSERT (!pktq_pfull (pq, prec));
- q = &pq->q[prec];
+ q = &pq->q[prec];
- if (q->head == NULL)
- q->tail = p;
+ if (q->head == NULL)
+ q->tail = p;
- PKTSETLINK(p, q->head);
- q->head = p;
- q->len++;
+ PKTSETLINK (p, q->head);
+ q->head = p;
+ q->len++;
- pq->len++;
+ pq->len++;
- if (pq->hi_prec < prec)
- pq->hi_prec = (uint8)prec;
+ if (pq->hi_prec < prec)
+ pq->hi_prec = (uint8) prec;
- return p;
+ return p;
}
void *
-pktq_pdeq(struct pktq *pq, int prec)
+pktq_pdeq (struct pktq *pq, int prec)
{
- struct pktq_prec *q;
- void *p;
+ struct pktq_prec *q;
+ void *p;
- ASSERT(prec >= 0 && prec < pq->num_prec);
+ ASSERT (prec >= 0 && prec < pq->num_prec);
- q = &pq->q[prec];
+ q = &pq->q[prec];
- if ((p = q->head) == NULL)
- return NULL;
+ if ((p = q->head) == NULL)
+ return NULL;
- if ((q->head = PKTLINK(p)) == NULL)
- q->tail = NULL;
+ if ((q->head = PKTLINK (p)) == NULL)
+ q->tail = NULL;
- q->len--;
+ q->len--;
- pq->len--;
+ pq->len--;
- PKTSETLINK(p, NULL);
+ PKTSETLINK (p, NULL);
- return p;
+ return p;
}
void *
-pktq_pdeq_tail(struct pktq *pq, int prec)
+pktq_pdeq_tail (struct pktq *pq, int prec)
{
- struct pktq_prec *q;
- void *p, *prev;
+ struct pktq_prec *q;
+ void *p, *prev;
- ASSERT(prec >= 0 && prec < pq->num_prec);
+ ASSERT (prec >= 0 && prec < pq->num_prec);
- q = &pq->q[prec];
+ q = &pq->q[prec];
- if ((p = q->head) == NULL)
- return NULL;
+ if ((p = q->head) == NULL)
+ return NULL;
- for (prev = NULL; p != q->tail; p = PKTLINK(p))
- prev = p;
+ for (prev = NULL; p != q->tail; p = PKTLINK (p))
+ prev = p;
- if (prev)
- PKTSETLINK(prev, NULL);
- else
- q->head = NULL;
+ if (prev)
+ PKTSETLINK (prev, NULL);
+ else
+ q->head = NULL;
- q->tail = prev;
- q->len--;
+ q->tail = prev;
+ q->len--;
- pq->len--;
+ pq->len--;
- return p;
+ return p;
}
void
-pktq_pflush(osl_t *osh, struct pktq *pq, int prec, bool dir)
-{
- struct pktq_prec *q;
- void *p;
-
- q = &pq->q[prec];
- p = q->head;
- while (p) {
- q->head = PKTLINK(p);
- PKTSETLINK(p, NULL);
- PKTFREE(osh, p, dir);
- q->len--;
- pq->len--;
- p = q->head;
- }
- ASSERT(q->len == 0);
- q->tail = NULL;
+pktq_pflush (osl_t * osh, struct pktq *pq, int prec, bool dir)
+{
+ struct pktq_prec *q;
+ void *p;
+
+ q = &pq->q[prec];
+ p = q->head;
+ while (p)
+ {
+ q->head = PKTLINK (p);
+ PKTSETLINK (p, NULL);
+ PKTFREE (osh, p, dir);
+ q->len--;
+ pq->len--;
+ p = q->head;
+ }
+ ASSERT (q->len == 0);
+ q->tail = NULL;
}
+#if 0
bool
-pktq_pdel(struct pktq *pq, void *pktbuf, int prec)
+pktq_pdel (struct pktq *pq, void *pktbuf, int prec)
{
- struct pktq_prec *q;
- void *p;
-
- ASSERT(prec >= 0 && prec < pq->num_prec);
+ struct pktq_prec *q;
+ void *p;
- if (!pktbuf)
- return FALSE;
+ ASSERT (prec >= 0 && prec < pq->num_prec);
- q = &pq->q[prec];
+ if (!pktbuf)
+ return FALSE;
- if (q->head == pktbuf) {
- if ((q->head = PKTLINK(pktbuf)) == NULL)
- q->tail = NULL;
- } else {
- for (p = q->head; p && PKTLINK(p) != pktbuf; p = PKTLINK(p))
- ;
- if (p == NULL)
- return FALSE;
+ q = &pq->q[prec];
- PKTSETLINK(p, PKTLINK(pktbuf));
- if (q->tail == pktbuf)
- q->tail = p;
- }
+ if (q->head == pktbuf)
+ {
+ if ((q->head = PKTLINK (pktbuf)) == NULL)
+ q->tail = NULL;
+ }
+ else
+ {
+ for (p = q->head; p && PKTLINK (p) != pktbuf; p = PKTLINK (p))
+ ;
+ if (p == NULL)
+ return FALSE;
+
+ PKTSETLINK (p, PKTLINK (pktbuf));
+ if (q->tail == pktbuf)
+ q->tail = p;
+ }
- q->len--;
- pq->len--;
- PKTSETLINK(pktbuf, NULL);
- return TRUE;
+ q->len--;
+ pq->len--;
+ PKTSETLINK (pktbuf, NULL);
+ return TRUE;
}
+#endif
void
-pktq_init(struct pktq *pq, int num_prec, int max_len)
+pktq_init (struct pktq *pq, int num_prec, int max_len)
{
- int prec;
+ int prec;
- ASSERT(num_prec > 0 && num_prec <= PKTQ_MAX_PREC);
+ ASSERT (num_prec > 0 && num_prec <= PKTQ_MAX_PREC);
- bzero(pq, sizeof(*pq));
+ /* pq is variable size; only zero out what's requested */
+ bzero (pq,
+ OFFSETOF (struct pktq, q) + (sizeof (struct pktq_prec) * num_prec));
- pq->num_prec = (uint16)num_prec;
+ pq->num_prec = (uint16) num_prec;
- pq->max = (uint16)max_len;
+ pq->max = (uint16) max_len;
- for (prec = 0; prec < num_prec; prec++)
- pq->q[prec].max = pq->max;
+ for (prec = 0; prec < num_prec; prec++)
+ pq->q[prec].max = pq->max;
+}
+
+int
+pktq_setmax (struct pktq *pq, int max_len)
+{
+ int prec;
+
+ if (!max_len)
+ return pq->max;
+
+ pq->max = (uint16) max_len;
+ for (prec = 0; prec < pq->num_prec; prec++)
+ pq->q[prec].max = pq->max;
+
+ return pq->max;
}
void *
-pktq_deq(struct pktq *pq, int *prec_out)
+pktq_deq (struct pktq *pq, int *prec_out)
{
- struct pktq_prec *q;
- void *p;
- int prec;
+ struct pktq_prec *q;
+ void *p;
+ int prec;
- if (pq->len == 0)
- return NULL;
+ if (pq->len == 0)
+ return NULL;
- while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
- pq->hi_prec--;
+ while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
+ pq->hi_prec--;
- q = &pq->q[prec];
+ q = &pq->q[prec];
- if ((p = q->head) == NULL)
- return NULL;
+ if ((p = q->head) == NULL)
+ return NULL;
- if ((q->head = PKTLINK(p)) == NULL)
- q->tail = NULL;
+ if ((q->head = PKTLINK (p)) == NULL)
+ q->tail = NULL;
- q->len--;
+ q->len--;
- pq->len--;
+ pq->len--;
- if (prec_out)
- *prec_out = prec;
+ if (prec_out)
+ *prec_out = prec;
- PKTSETLINK(p, NULL);
+ PKTSETLINK (p, NULL);
- return p;
+ return p;
}
void *
-pktq_deq_tail(struct pktq *pq, int *prec_out)
+pktq_deq_tail (struct pktq *pq, int *prec_out)
{
- struct pktq_prec *q;
- void *p, *prev;
- int prec;
+ struct pktq_prec *q;
+ void *p, *prev;
+ int prec;
- if (pq->len == 0)
- return NULL;
+ if (pq->len == 0)
+ return NULL;
- for (prec = 0; prec < pq->hi_prec; prec++)
- if (pq->q[prec].head)
- break;
+ for (prec = 0; prec < pq->hi_prec; prec++)
+ if (pq->q[prec].head)
+ break;
- q = &pq->q[prec];
+ q = &pq->q[prec];
- if ((p = q->head) == NULL)
- return NULL;
+ if ((p = q->head) == NULL)
+ return NULL;
- for (prev = NULL; p != q->tail; p = PKTLINK(p))
- prev = p;
+ for (prev = NULL; p != q->tail; p = PKTLINK (p))
+ prev = p;
- if (prev)
- PKTSETLINK(prev, NULL);
- else
- q->head = NULL;
+ if (prev)
+ PKTSETLINK (prev, NULL);
+ else
+ q->head = NULL;
- q->tail = prev;
- q->len--;
+ q->tail = prev;
+ q->len--;
- pq->len--;
+ pq->len--;
- if (prec_out)
- *prec_out = prec;
+ if (prec_out)
+ *prec_out = prec;
- PKTSETLINK(p, NULL);
+ PKTSETLINK (p, NULL);
- return p;
+ return p;
}
+#if 0
void *
-pktq_peek(struct pktq *pq, int *prec_out)
+pktq_peek (struct pktq *pq, int *prec_out)
{
- int prec;
+ int prec;
- if (pq->len == 0)
- return NULL;
+ if (pq->len == 0)
+ return NULL;
- while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
- pq->hi_prec--;
+ while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
+ pq->hi_prec--;
- if (prec_out)
- *prec_out = prec;
+ if (prec_out)
+ *prec_out = prec;
- return (pq->q[prec].head);
+ return (pq->q[prec].head);
}
+#endif
void *
-pktq_peek_tail(struct pktq *pq, int *prec_out)
+pktq_peek_tail (struct pktq *pq, int *prec_out)
{
- int prec;
+ int prec;
- if (pq->len == 0)
- return NULL;
+ if (pq->len == 0)
+ return NULL;
- for (prec = 0; prec < pq->hi_prec; prec++)
- if (pq->q[prec].head)
- break;
+ for (prec = 0; prec < pq->hi_prec; prec++)
+ if (pq->q[prec].head)
+ break;
- if (prec_out)
- *prec_out = prec;
+ if (prec_out)
+ *prec_out = prec;
- return (pq->q[prec].tail);
+ return (pq->q[prec].tail);
}
void
-pktq_flush(osl_t *osh, struct pktq *pq, bool dir)
+pktq_flush (osl_t * osh, struct pktq *pq, bool dir)
{
- int prec;
- for (prec = 0; prec < pq->num_prec; prec++)
- pktq_pflush(osh, pq, prec, dir);
- ASSERT(pq->len == 0);
+ int prec;
+ for (prec = 0; prec < pq->num_prec; prec++)
+ pktq_pflush (osh, pq, prec, dir);
+ ASSERT (pq->len == 0);
}
/* Return sum of lengths of a specific set of precedences */
int
-pktq_mlen(struct pktq *pq, uint prec_bmp)
+pktq_mlen (struct pktq *pq, uint prec_bmp)
{
- int prec, len;
+ int prec, len;
- len = 0;
+ len = 0;
- for (prec = 0; prec <= pq->hi_prec; prec++)
- if (prec_bmp & (1 << prec))
- len += pq->q[prec].len;
+ for (prec = 0; prec <= pq->hi_prec; prec++)
+ if (prec_bmp & (1 << prec))
+ len += pq->q[prec].len;
- return len;
+ return len;
}
/* Priority dequeue from a specific set of precedences */
void *
-pktq_mdeq(struct pktq *pq, uint prec_bmp, int *prec_out)
+pktq_mdeq (struct pktq *pq, uint prec_bmp, int *prec_out)
{
- struct pktq_prec *q;
- void *p;
- int prec;
+ struct pktq_prec *q;
+ void *p;
+ int prec;
- if (pq->len == 0)
- return NULL;
+ if (pq->len == 0)
+ return NULL;
- while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
- pq->hi_prec--;
+ while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
+ pq->hi_prec--;
- while ((prec_bmp & (1 << prec)) == 0 || pq->q[prec].head == NULL)
- if (prec-- == 0)
- return NULL;
+ while ((prec_bmp & (1 << prec)) == 0 || pq->q[prec].head == NULL)
+ if (prec-- == 0)
+ return NULL;
- q = &pq->q[prec];
+ q = &pq->q[prec];
- if ((p = q->head) == NULL)
- return NULL;
+ if ((p = q->head) == NULL)
+ return NULL;
- if ((q->head = PKTLINK(p)) == NULL)
- q->tail = NULL;
+ if ((q->head = PKTLINK (p)) == NULL)
+ q->tail = NULL;
- q->len--;
+ q->len--;
- if (prec_out)
- *prec_out = prec;
+ if (prec_out)
+ *prec_out = prec;
- pq->len--;
+ pq->len--;
- PKTSETLINK(p, NULL);
+ PKTSETLINK (p, NULL);
- return p;
+ return p;
}
-char*
-bcmstrcat(char *dest, const char *src)
+const unsigned char bcm_ctype[] = {
+ _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, /* 0-7 */
+ _BCM_C, _BCM_C | _BCM_S, _BCM_C | _BCM_S, _BCM_C | _BCM_S, _BCM_C | _BCM_S,
+ _BCM_C | _BCM_S, _BCM_C,
+ _BCM_C, /* 8-15 */
+ _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, /* 16-23 */
+ _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, _BCM_C, /* 24-31 */
+ _BCM_S | _BCM_SP, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, /* 32-39 */
+ _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, /* 40-47 */
+ _BCM_D, _BCM_D, _BCM_D, _BCM_D, _BCM_D, _BCM_D, _BCM_D, _BCM_D, /* 48-55 */
+ _BCM_D, _BCM_D, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, /* 56-63 */
+ _BCM_P, _BCM_U | _BCM_X, _BCM_U | _BCM_X, _BCM_U | _BCM_X, _BCM_U | _BCM_X,
+ _BCM_U | _BCM_X,
+ _BCM_U | _BCM_X, _BCM_U, /* 64-71 */
+ _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, /* 72-79 */
+ _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, /* 80-87 */
+ _BCM_U, _BCM_U, _BCM_U, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, /* 88-95 */
+ _BCM_P, _BCM_L | _BCM_X, _BCM_L | _BCM_X, _BCM_L | _BCM_X, _BCM_L | _BCM_X,
+ _BCM_L | _BCM_X,
+ _BCM_L | _BCM_X, _BCM_L, /* 96-103 */
+ _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, /* 104-111 */
+ _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, /* 112-119 */
+ _BCM_L, _BCM_L, _BCM_L, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_C, /* 120-127 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 128-143 */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 144-159 */
+ _BCM_S | _BCM_SP, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P,
+ _BCM_P, _BCM_P,
+ _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, /* 160-175 */
+ _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P,
+ _BCM_P, _BCM_P,
+ _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, /* 176-191 */
+ _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U,
+ _BCM_U, _BCM_U,
+ _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, /* 192-207 */
+ _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_P, _BCM_U,
+ _BCM_U, _BCM_U,
+ _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_L, /* 208-223 */
+ _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L,
+ _BCM_L, _BCM_L,
+ _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, /* 224-239 */
+ _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_P, _BCM_L,
+ _BCM_L, _BCM_L,
+ _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L /* 240-255 */
+};
+
+ulong BCMROMFN (bcm_strtoul) (char *cp, char **endp, uint base)
{
- strcpy(&dest[strlen(dest)], src);
- return (dest);
+ ulong result, value;
+ bool minus;
+
+ minus = FALSE;
+
+ while (bcm_isspace (*cp))
+ cp++;
+
+ if (cp[0] == '+')
+ cp++;
+ else if (cp[0] == '-')
+ {
+ minus = TRUE;
+ cp++;
+ }
+
+ if (base == 0)
+ {
+ if (cp[0] == '0')
+ {
+ if ((cp[1] == 'x') || (cp[1] == 'X'))
+ {
+ base = 16;
+ cp = &cp[2];
+ }
+ else
+ {
+ base = 8;
+ cp = &cp[1];
+ }
+ }
+ else
+ base = 10;
+ }
+ else if (base == 16 && (cp[0] == '0') && ((cp[1] == 'x') || (cp[1] == 'X')))
+ {
+ cp = &cp[2];
+ }
+
+ result = 0;
+
+ while (bcm_isxdigit (*cp) &&
+ (value =
+ bcm_isdigit (*cp) ? *cp - '0' : bcm_toupper (*cp) - 'A' + 10) <
+ base)
+ {
+ result = result * base + value;
+ cp++;
+ }
+
+ if (minus)
+ result = (ulong) (result * -1);
+
+ if (endp)
+ *endp = (char *) cp;
+
+ return (result);
}
-char*
-bcm_ether_ntoa(struct ether_addr *ea, char *buf)
+#if 0
+int BCMROMFN (bcm_atoi) (char *s)
{
- sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x",
- ea->octet[0]&0xff, ea->octet[1]&0xff, ea->octet[2]&0xff,
- ea->octet[3]&0xff, ea->octet[4]&0xff, ea->octet[5]&0xff);
- return (buf);
+ return (int) bcm_strtoul (s, NULL, 10);
}
+/* return pointer to location of substring 'needle' in 'haystack' */
+char *BCMROMFN (bcmstrstr) (char *haystack, char *needle)
+{
+ int len, nlen;
+ int i;
+
+ if ((haystack == NULL) || (needle == NULL))
+ return (haystack);
+
+ nlen = strlen (needle);
+ len = strlen (haystack) - nlen + 1;
+
+ for (i = 0; i < len; i++)
+ if (memcmp (needle, &haystack[i], nlen) == 0)
+ return (&haystack[i]);
+ return (NULL);
+}
+
+char *BCMROMFN (bcmstrcat) (char *dest, const char *src)
+{
+ strcpy (&dest[strlen (dest)], src);
+ return (dest);
+}
+
+char *BCMROMFN (bcmstrncat) (char *dest, const char *src, uint size)
+{
+ char *endp;
+ char *p;
+
+ p = dest + strlen (dest);
+ endp = p + size;
+
+ while (p != endp && (*p++ = *src++) != '\0')
+ ;
+
+ return (dest);
+}
+#endif
+
/* parse a xx:xx:xx:xx:xx:xx format ethernet address */
+int BCMROMFN (bcm_ether_atoe) (char *p, struct ether_addr * ea)
+{
+ int i = 0;
+
+ for (;;)
+ {
+ ea->octet[i++] = (char) bcm_strtoul (p, &p, 16);
+ if (!*p++ || i == 6)
+ break;
+ }
+
+ return (i == 6);
+}
+
+#if defined(CONFIG_USBRNDIS_RETAIL) || defined(NDIS_MINIPORT_DRIVER)
+/* registry routine buffer preparation utility functions:
+ * parameter order is like strncpy, but returns count
+ * of bytes copied. Minimum bytes copied is null char(1)/wchar(2)
+ */
+ulong
+wchar2ascii (char *abuf, ushort * wbuf, ushort wbuflen, ulong abuflen)
+{
+ ulong copyct = 1;
+ ushort i;
+
+ if (abuflen == 0)
+ return 0;
+
+ /* wbuflen is in bytes */
+ wbuflen /= sizeof (ushort);
+
+ for (i = 0; i < wbuflen; ++i)
+ {
+ if (--abuflen == 0)
+ break;
+ *abuf++ = (char) *wbuf++;
+ ++copyct;
+ }
+ *abuf = '\0';
+
+ return copyct;
+}
+#endif /* CONFIG_USBRNDIS_RETAIL || NDIS_MINIPORT_DRIVER */
+
+#if 0
+char *
+bcm_ether_ntoa (struct ether_addr *ea, char *buf)
+{
+ snprintf (buf, 18, "%02x:%02x:%02x:%02x:%02x:%02x",
+ ea->octet[0] & 0xff, ea->octet[1] & 0xff, ea->octet[2] & 0xff,
+ ea->octet[3] & 0xff, ea->octet[4] & 0xff, ea->octet[5] & 0xff);
+ return (buf);
+}
+
+char *
+bcm_ip_ntoa (struct ipv4_addr *ia, char *buf)
+{
+ snprintf (buf, 16, "%d.%d.%d.%d",
+ ia->addr[0], ia->addr[1], ia->addr[2], ia->addr[3]);
+ return (buf);
+}
+void
+bcm_mdelay (uint ms)
+{
+ uint i;
+
+ for (i = 0; i < ms; i++)
+ {
+ OSL_DELAY (1000);
+ }
+}
+#endif
+
+#if 0
+
+/*
+ * Search the name=value vars for a specific one and return its value.
+ * Returns NULL if not found.
+ */
+char *
+getvar (char *vars, const char *name)
+{
+#ifdef _MINOSL_
+ return NULL;
+#else
+ char *s;
+ int len;
+
+ if (!name)
+ return NULL;
+
+ len = strlen (name);
+ if (len == 0)
+ return NULL;
+
+ /* first look in vars[] */
+ for (s = vars; s && *s;)
+ {
+ /* CSTYLED */
+ if ((bcmp (s, name, len) == 0) && (s[len] == '='))
+ return (&s[len + 1]);
+
+ while (*s++)
+ ;
+ }
+
+ /* then query nvram */
+ return (nvram_get (name));
+#endif /* _MINOSL_ */
+}
+
+/*
+ * Search the vars for a specific one and return its value as
+ * an integer. Returns 0 if not found.
+ */
int
-bcm_ether_atoe(char *p, struct ether_addr *ea)
+getintvar (char *vars, const char *name)
+{
+#ifdef _MINOSL_
+ return 0;
+#else
+ char *val;
+
+ if ((val = getvar (vars, name)) == NULL)
+ return (0);
+
+ return (bcm_strtoul (val, NULL, 0));
+#endif /* _MINOSL_ */
+}
+
+
+/* Search for token in comma separated token-string */
+static int
+findmatch (char *string, char *name)
{
- int i = 0;
+ uint len;
+ char *c;
+
+ len = strlen (name);
+ /* CSTYLED */
+ while ((c = strchr (string, ',')) != NULL)
+ {
+ if (len == (uint) (c - string) && !strncmp (string, name, len))
+ return 1;
+ string = c + 1;
+ }
+
+ return (!strcmp (string, name));
+}
- for (;;) {
- ea->octet[i++] = (char) bcm_strtoul(p, &p, 16);
- if (!*p++ || i == 6)
- break;
+/* Return gpio pin number assigned to the named pin
+ *
+ * Variable should be in format:
+ *
+ * gpio<N>=pin_name,pin_name
+ *
+ * This format allows multiple features to share the gpio with mutual
+ * understanding.
+ *
+ * 'def_pin' is returned if a specific gpio is not defined for the requested functionality
+ * and if def_pin is not used by others.
+ */
+uint
+getgpiopin (char *vars, char *pin_name, uint def_pin)
+{
+ char name[] = "gpioXXXX";
+ char *val;
+ uint pin;
+
+ /* Go thru all possibilities till a match in pin name */
+ for (pin = 0; pin < GPIO_NUMPINS; pin++)
+ {
+ snprintf (name, sizeof (name), "gpio%d", pin);
+ val = getvar (vars, name);
+ if (val && findmatch (val, pin_name))
+ return pin;
+ }
+
+ if (def_pin != GPIO_PIN_NOTDEFINED)
+ {
+ /* make sure the default pin is not used by someone else */
+ snprintf (name, sizeof (name), "gpio%d", def_pin);
+ if (getvar (vars, name))
+ {
+ def_pin = GPIO_PIN_NOTDEFINED;
}
+ }
+
+ return def_pin;
+}
+#endif
+
+#ifdef BCMPERFSTATS
- return (i == 6);
+#define LOGSIZE 256 /* should be power of 2 to avoid div below */
+static struct
+{
+ uint cycles;
+ char *fmt;
+ uint a1;
+ uint a2;
+} logtab[LOGSIZE];
+
+/* last entry logged */
+static uint logi = 0;
+/* next entry to read */
+static uint readi = 0;
+
+void
+bcm_perf_enable ()
+{
+ BCMPERF_ENABLE_INSTRCOUNT ();
+ BCMPERF_ENABLE_ICACHE_MISS ();
+ BCMPERF_ENABLE_ICACHE_HIT ();
}
-/* Takes an Ethernet frame and sets out-of-bound PKTPRIO
- * Also updates the inplace vlan tag if requested
+void
+bcmlog (char *fmt, uint a1, uint a2)
+{
+ static uint last = 0;
+ uint cycles, i;
+ OSL_GETCYCLES (cycles);
+
+ i = logi;
+
+ logtab[i].cycles = cycles - last;
+ logtab[i].fmt = fmt;
+ logtab[i].a1 = a1;
+ logtab[i].a2 = a2;
+
+ logi = (i + 1) % LOGSIZE;
+ last = cycles;
+}
+
+
+void
+bcmstats (char *fmt)
+{
+ static uint last = 0;
+ static uint32 ic_miss = 0;
+ static uint32 instr_count = 0;
+ uint32 ic_miss_cur;
+ uint32 instr_count_cur;
+ uint cycles, i;
+
+ OSL_GETCYCLES (cycles);
+ BCMPERF_GETICACHE_MISS (ic_miss_cur);
+ BCMPERF_GETINSTRCOUNT (instr_count_cur);
+
+ i = logi;
+
+ logtab[i].cycles = cycles - last;
+ logtab[i].a1 = ic_miss_cur - ic_miss;
+ logtab[i].a2 = instr_count_cur - instr_count;
+ logtab[i].fmt = fmt;
+
+ logi = (i + 1) % LOGSIZE;
+
+ last = cycles;
+ instr_count = instr_count_cur;
+ ic_miss = ic_miss_cur;
+}
+
+
+void
+bcmdumplog (char *buf, int size)
+{
+ char *limit, *line;
+ int j = 0;
+ int num;
+
+ limit = buf + size - 80;
+ *buf = '\0';
+
+ num = logi - readi;
+
+ if (num < 0)
+ num += LOGSIZE;
+
+ /* print in chronological order */
+
+ for (j = 0; j < num && (buf < limit); readi = (readi + 1) % LOGSIZE, j++)
+ {
+ if (logtab[readi].fmt == NULL)
+ continue;
+ line = buf;
+ buf += sprintf (buf, "%d\t", logtab[readi].cycles);
+ buf +=
+ sprintf (buf, logtab[readi].fmt, logtab[readi].a1, logtab[readi].a2);
+ buf += sprintf (buf, "\n");
+ }
+
+}
+
+
+/*
+ * Dump one log entry at a time.
+ * Return index of next entry or -1 when no more .
*/
+int
+bcmdumplogent (char *buf, uint i)
+{
+ bool hit;
+
+ /*
+ * If buf is NULL, return the starting index,
+ * interpreting i as the indicator of last 'i' entries to dump.
+ */
+ if (buf == NULL)
+ {
+ i = ((i > 0) && (i < (LOGSIZE - 1))) ? i : (LOGSIZE - 1);
+ return ((logi - i) % LOGSIZE);
+ }
+
+ *buf = '\0';
+
+ ASSERT (i < LOGSIZE);
+
+ if (i == logi)
+ return (-1);
+
+ hit = FALSE;
+ for (; (i != logi) && !hit; i = (i + 1) % LOGSIZE)
+ {
+ if (logtab[i].fmt == NULL)
+ continue;
+ buf += sprintf (buf, "%d: %d\t", i, logtab[i].cycles);
+ buf += sprintf (buf, logtab[i].fmt, logtab[i].a1, logtab[i].a2);
+ buf += sprintf (buf, "\n");
+ hit = TRUE;
+ }
+
+ return (i);
+}
+
+#endif /* BCMPERFSTATS */
+
+#ifdef BCMDBG
+/* pretty hex print a pkt buffer chain */
void
-pktsetprio(void *pkt, bool update_vtag)
+prpkt (const char *msg, osl_t * osh, void *p0)
{
- struct ether_header *eh;
- struct ethervlan_header *evh;
- uint8 *pktdata;
- int priority = 0;
+ void *p;
- pktdata = (uint8 *) PKTDATA(NULL, pkt);
- ASSERT(ISALIGNED((uintptr)pktdata, sizeof(uint16)));
+ if (msg && (msg[0] != '\0'))
+ printf ("%s:\n", msg);
- eh = (struct ether_header *) pktdata;
+ for (p = p0; p; p = PKTNEXT (osh, p))
+ prhex (NULL, PKTDATA (osh, p), PKTLEN (osh, p));
+}
+#endif /* BCMDBG */
- if (ntoh16(eh->ether_type) == ETHER_TYPE_8021Q) {
- uint16 vlan_tag;
- int vlan_prio, dscp_prio = 0;
+/* Takes an Ethernet frame and sets out-of-bound PKTPRIO.
+ * Also updates the inplace vlan tag if requested.
+ * For debugging, it returns an indication of what it did.
+ */
+uint
+pktsetprio (void *pkt, bool update_vtag)
+{
+ struct ether_header *eh;
+ struct ethervlan_header *evh;
+ uint8 *pktdata;
+ int priority = 0;
+ int rc = 0;
- evh = (struct ethervlan_header *)eh;
+ pktdata = (uint8 *) PKTDATA (NULL, pkt);
+ ASSERT (ISALIGNED ((uintptr) pktdata, sizeof (uint16)));
- vlan_tag = ntoh16(evh->vlan_tag);
- vlan_prio = (int) (vlan_tag >> VLAN_PRI_SHIFT) & VLAN_PRI_MASK;
+ eh = (struct ether_header *) pktdata;
- if (ntoh16(evh->ether_type) == ETHER_TYPE_IP) {
- uint8 *ip_body = pktdata + sizeof(struct ethervlan_header);
- uint8 tos_tc = IP_TOS(ip_body);
- dscp_prio = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
- }
+ if (ntoh16 (eh->ether_type) == ETHER_TYPE_8021Q)
+ {
+ uint16 vlan_tag;
+ int vlan_prio, dscp_prio = 0;
+
+ evh = (struct ethervlan_header *) eh;
- /* DSCP priority gets precedence over 802.1P (vlan tag) */
- priority = (dscp_prio != 0) ? dscp_prio : vlan_prio;
-
- /*
- * If the DSCP priority is not the same as the VLAN priority,
- * then overwrite the priority field in the vlan tag, with the
- * DSCP priority value. This is required for Linux APs because
- * the VLAN driver on Linux, overwrites the skb->priority field
- * with the priority value in the vlan tag
- */
- if (update_vtag && (priority != vlan_prio)) {
- vlan_tag &= ~(VLAN_PRI_MASK << VLAN_PRI_SHIFT);
- vlan_tag |= (uint16)priority << VLAN_PRI_SHIFT;
- evh->vlan_tag = hton16(vlan_tag);
+ vlan_tag = ntoh16 (evh->vlan_tag);
+ vlan_prio = (int) (vlan_tag >> VLAN_PRI_SHIFT) & VLAN_PRI_MASK;
+
+ if (ntoh16 (evh->ether_type) == ETHER_TYPE_IP)
+ {
+ uint8 *ip_body = pktdata + sizeof (struct ethervlan_header);
+ uint8 tos_tc = IP_TOS (ip_body);
+ dscp_prio = (int) (tos_tc >> IPV4_TOS_PREC_SHIFT);
+ if ((IP_VER (ip_body) == IP_VER_4)
+ && (IPV4_PROT (ip_body) == IP_PROT_TCP))
+ {
+ int ip_len;
+ int src_port;
+ bool src_port_exc;
+ uint8 *tcp_hdr;
+
+ ip_len = IPV4_PAYLOAD_LEN (ip_body);
+ tcp_hdr = IPV4_NO_OPTIONS_PAYLOAD (ip_body);
+ src_port = TCP_SRC_PORT (tcp_hdr);
+ src_port_exc = (src_port == 10110) || (src_port == 10120) ||
+ (src_port == 10130) || (src_port == 10140);
+
+ if ((ip_len == 40) && src_port_exc && TCP_IS_ACK (tcp_hdr))
+ {
+ dscp_prio = 7;
}
- } else if (ntoh16(eh->ether_type) == ETHER_TYPE_IP) {
- uint8 *ip_body = pktdata + sizeof(struct ether_header);
- uint8 tos_tc = IP_TOS(ip_body);
- priority = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
+ }
}
- ASSERT(priority >= 0 && priority <= MAXPRIO);
- PKTSETPRIO(pkt, priority);
+ /* DSCP priority gets precedence over 802.1P (vlan tag) */
+ if (dscp_prio != 0)
+ {
+ priority = dscp_prio;
+ rc |= PKTPRIO_VDSCP;
+ }
+ else
+ {
+ priority = vlan_prio;
+ rc |= PKTPRIO_VLAN;
+ }
+ /*
+ * If the DSCP priority is not the same as the VLAN priority,
+ * then overwrite the priority field in the vlan tag, with the
+ * DSCP priority value. This is required for Linux APs because
+ * the VLAN driver on Linux, overwrites the skb->priority field
+ * with the priority value in the vlan tag
+ */
+ if (update_vtag && (priority != vlan_prio))
+ {
+ vlan_tag &= ~(VLAN_PRI_MASK << VLAN_PRI_SHIFT);
+ vlan_tag |= (uint16) priority << VLAN_PRI_SHIFT;
+ evh->vlan_tag = hton16 (vlan_tag);
+ rc |= PKTPRIO_UPD;
+ }
+ }
+ else if (ntoh16 (eh->ether_type) == ETHER_TYPE_IP)
+ {
+ uint8 *ip_body = pktdata + sizeof (struct ether_header);
+ uint8 tos_tc = IP_TOS (ip_body);
+ priority = (int) (tos_tc >> IPV4_TOS_PREC_SHIFT);
+ rc |= PKTPRIO_DSCP;
+ if ((IP_VER (ip_body) == IP_VER_4)
+ && (IPV4_PROT (ip_body) == IP_PROT_TCP))
+ {
+ int ip_len;
+ int src_port;
+ bool src_port_exc;
+ uint8 *tcp_hdr;
+
+ ip_len = IPV4_PAYLOAD_LEN (ip_body);
+ tcp_hdr = IPV4_NO_OPTIONS_PAYLOAD (ip_body);
+ src_port = TCP_SRC_PORT (tcp_hdr);
+ src_port_exc = (src_port == 10110) || (src_port == 10120) ||
+ (src_port == 10130) || (src_port == 10140);
+
+ if ((ip_len == 40) && src_port_exc && TCP_IS_ACK (tcp_hdr))
+ {
+ priority = 7;
+ }
+ }
+ }
+
+ ASSERT (priority >= 0 && priority <= MAXPRIO);
+ PKTSETPRIO (pkt, priority);
+ return (rc | priority);
}
static char bcm_undeferrstr[BCME_STRLEN];
static const char *bcmerrorstrtable[] = BCMERRSTRINGTABLE;
-/* Convert the Error codes into related Error strings */
+/* Convert the error codes into related error strings */
const char *
-bcmerrorstr(int bcmerror)
+bcmerrorstr (int bcmerror)
+{
+ /* check if someone added a bcmerror code but forgot to add errorstring */
+ ASSERT (ABS (BCME_LAST) == (ARRAYSIZE (bcmerrorstrtable) - 1));
+
+ if (bcmerror > 0 || bcmerror < BCME_LAST)
+ {
+ snprintf (bcm_undeferrstr, BCME_STRLEN, "Undefined error %d", bcmerror);
+ return bcm_undeferrstr;
+ }
+
+ ASSERT (strlen (bcmerrorstrtable[-bcmerror]) < BCME_STRLEN);
+
+ return bcmerrorstrtable[-bcmerror];
+}
+
+#if 0
+static void BCMINITFN (bcm_nvram_refresh) (char *flash)
{
- int abs_bcmerror;
+ int i;
+ int ret = 0;
+
+ ASSERT (flash);
+
+ /* default "empty" vars cache */
+ bzero (flash, 2);
+
+ if ((ret = nvram_getall (flash, NVRAM_SPACE)))
+ return;
+
+ /* determine nvram length */
+ for (i = 0; i < NVRAM_SPACE; i++)
+ {
+ if (flash[i] == '\0' && flash[i + 1] == '\0')
+ break;
+ }
- abs_bcmerror = ABS(bcmerror);
+ if (i > 1)
+ vars_len = i + 2;
+ else
+ vars_len = 0;
+}
+#endif
+
+#ifdef BCMDBG_PKT /* pkt logging for debugging */
+/* Add a packet to the pktlist */
+void
+pktlist_add (pktlist_info_t * pktlist, void *pkt)
+{
+ uint i;
+ ASSERT (pktlist->count < PKTLIST_SIZE);
+
+ /* Verify the packet is not already part of the list */
+ for (i = 0; i < pktlist->count; i++)
+ {
+ if (pktlist->list[i] == pkt)
+ ASSERT (0);
+ }
+ pktlist->list[pktlist->count] = pkt;
+ pktlist->count++;
+ return;
+}
- /* check if someone added a bcmerror code but forgot to add errorstring */
- ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(bcmerrorstrtable) - 1));
- if ((bcmerror > 0) || (abs_bcmerror > ABS(BCME_LAST))) {
- sprintf(bcm_undeferrstr, "undefined Error %d", bcmerror);
- return bcm_undeferrstr;
+/* Remove a packet from the pktlist */
+void
+pktlist_remove (pktlist_info_t * pktlist, void *pkt)
+{
+ uint i;
+ uint num = pktlist->count;
+
+ /* find the index where pkt exists */
+ for (i = 0; i < num; i++)
+ {
+ /* check for the existence of pkt in the list */
+ if (pktlist->list[i] == pkt)
+ {
+ /* replace with the last element */
+ pktlist->list[i] = pktlist->list[num - 1];
+ pktlist->count--;
+ return;
}
+ }
+ ASSERT (0);
+}
+
+/* Dump the pktlist (and the contents of each packet if 'data'
+ * is set). 'buf' should be large enough
+ */
+
+char *
+pktlist_dump (pktlist_info_t * pktlist, char *buf)
+{
+ char *obuf;
+ uint i;
+
+ obuf = buf;
+
+ buf += sprintf (buf, "Packet list dump:\n");
- ASSERT((strlen((char*)bcmerrorstrtable[abs_bcmerror])) < BCME_STRLEN);
+ for (i = 0; i < (pktlist->count); i++)
+ {
+ buf += sprintf (buf, "0x%p\t", pktlist->list[i]);
- return bcmerrorstrtable[abs_bcmerror];
+#ifdef NOTDEF /* Remove this ifdef to print pkttag and pktdata */
+ if (PKTTAG (pktlist->list[i]))
+ {
+ /* Print pkttag */
+ buf += sprintf (buf, "Pkttag(in hex): ");
+ buf +=
+ bcm_format_hex (buf, PKTTAG (pktlist->list[i]), OSL_PKTTAG_SZ);
+ }
+ buf += sprintf (buf, "Pktdata(in hex): ");
+ buf += bcm_format_hex (buf, PKTDATA (NULL, pktlist->list[i]),
+ PKTLEN (NULL, pktlist->list[i]));
+#endif /* NOTDEF */
+
+ buf += sprintf (buf, "\n");
+ }
+ return obuf;
}
+#endif /* BCMDBG_PKT */
+#if 0
+/* iovar table lookup */
+const bcm_iovar_t *
+bcm_iovar_lookup (const bcm_iovar_t * table, const char *name)
+{
+ const bcm_iovar_t *vi;
+ const char *lookup_name;
+
+ /* skip any ':' delimited option prefixes */
+ lookup_name = strrchr (name, ':');
+ if (lookup_name != NULL)
+ lookup_name++;
+ else
+ lookup_name = name;
+
+ ASSERT (table);
+
+ for (vi = table; vi->name; vi++)
+ {
+ if (!strcmp (vi->name, lookup_name))
+ return vi;
+ }
+ /* ran to end of table */
+
+ return NULL; /* var name not found */
+}
+#endif
int
-bcm_iovar_lencheck(const bcm_iovar_t *vi, void *arg, int len, bool set)
-{
- int bcmerror = 0;
-
- /* length check on io buf */
- switch (vi->type) {
- case IOVT_BOOL:
- case IOVT_INT8:
- case IOVT_INT16:
- case IOVT_INT32:
- case IOVT_UINT8:
- case IOVT_UINT16:
- case IOVT_UINT32:
- /* all integers are int32 sized args at the ioctl interface */
- if (len < (int)sizeof(int)) {
- bcmerror = BCME_BUFTOOSHORT;
- }
- break;
+bcm_iovar_lencheck (const bcm_iovar_t * vi, void *arg, int len, bool set)
+{
+ int bcmerror = 0;
+
+ /* length check on io buf */
+ switch (vi->type)
+ {
+ case IOVT_BOOL:
+ case IOVT_INT8:
+ case IOVT_INT16:
+ case IOVT_INT32:
+ case IOVT_UINT8:
+ case IOVT_UINT16:
+ case IOVT_UINT32:
+ /* all integers are int32 sized args at the ioctl interface */
+ if (len < (int) sizeof (int))
+ {
+ bcmerror = BCME_BUFTOOSHORT;
+ }
+ break;
- case IOVT_BUFFER:
- /* buffer must meet minimum length requirement */
- if (len < vi->minlen) {
- bcmerror = BCME_BUFTOOSHORT;
- }
- break;
-
- case IOVT_VOID:
- if (!set) {
- /* Cannot return nil... */
- bcmerror = BCME_UNSUPPORTED;
- } else if (len) {
- /* Set is an action w/o parameters */
- bcmerror = BCME_BUFTOOLONG;
- }
- break;
+ case IOVT_BUFFER:
+ /* buffer must meet minimum length requirement */
+ if (len < vi->minlen)
+ {
+ bcmerror = BCME_BUFTOOSHORT;
+ }
+ break;
- default:
- /* unknown type for length check in iovar info */
- ASSERT(0);
- bcmerror = BCME_UNSUPPORTED;
+ case IOVT_VOID:
+ if (!set)
+ {
+ /* Cannot return nil... */
+ bcmerror = BCME_UNSUPPORTED;
+ }
+ else if (len)
+ {
+ /* Set is an action w/o parameters */
+ bcmerror = BCME_BUFTOOLONG;
}
+ break;
+
+ default:
+ /* unknown type for length check in iovar info */
+ ASSERT (0);
+ bcmerror = BCME_UNSUPPORTED;
+ }
- return bcmerror;
+ return bcmerror;
}
#define CRC_INNER_LOOP(n, c, x) \
- (c) = ((c) >> 8) ^ crc##n##_table[((c) ^ (x)) & 0xff]
-
-static uint32 crc32_table[256] = {
- 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
- 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
- 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
- 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
- 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
- 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
- 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
- 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
- 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
- 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
- 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
- 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
- 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
- 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
- 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
- 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
- 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
- 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
- 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
- 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
- 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
- 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
- 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
- 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
- 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
- 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
- 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
- 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
- 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
- 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
- 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
- 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
- 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
- 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
- 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
- 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
- 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
- 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
- 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
- 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
- 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
- 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
- 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
- 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
- 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
- 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
- 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
- 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
- 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
- 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
- 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
- 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
- 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
- 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
- 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
- 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
- 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
- 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
- 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
- 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
- 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
- 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
- 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
- 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+ (c) = ((c) >> 8) ^ crc##n##_table[((c) ^ (x)) & 0xff]
+
+#if 0
+/*******************************************************************************
+ * crc8
+ *
+ * Computes a crc8 over the input data using the polynomial:
+ *
+ * x^8 + x^7 +x^6 + x^4 + x^2 + 1
+ *
+ * The caller provides the initial value (either CRC8_INIT_VALUE
+ * or the previous returned value) to allow for processing of
+ * discontiguous blocks of data. When generating the CRC the
+ * caller is responsible for complementing the final return value
+ * and inserting it into the byte stream. When checking, a final
+ * return value of CRC8_GOOD_VALUE indicates a valid CRC.
+ *
+ * Reference: Dallas Semiconductor Application Note 27
+ * Williams, Ross N., "A Painless Guide to CRC Error Detection Algorithms",
+ * ver 3, Aug 1993, ross@guest.adelaide.edu.au, Rocksoft Pty Ltd.,
+ * ftp://ftp.rocksoft.com/clients/rocksoft/papers/crc_v3.txt
+ *
+ * ****************************************************************************
+ */
+
+static const uint8 crc8_table[256] = {
+ 0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
+ 0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
+ 0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
+ 0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5,
+ 0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14,
+ 0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E,
+ 0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80,
+ 0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA,
+ 0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95,
+ 0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF,
+ 0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01,
+ 0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B,
+ 0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA,
+ 0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0,
+ 0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E,
+ 0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34,
+ 0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0,
+ 0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A,
+ 0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54,
+ 0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E,
+ 0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF,
+ 0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5,
+ 0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B,
+ 0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61,
+ 0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E,
+ 0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74,
+ 0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA,
+ 0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0,
+ 0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41,
+ 0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B,
+ 0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5,
+ 0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F
};
-uint32
-hndcrc32(
- uint8 *pdata, /* pointer to array of data to process */
- uint nbytes, /* number of input data bytes to process */
- uint32 crc /* either CRC32_INIT_VALUE or previous return value */
-)
+uint8 BCMROMFN (hndcrc8) (uint8 * pdata, /* pointer to array of data to process */
+ uint nbytes, /* number of input data bytes to process */
+ uint8 crc /* either CRC8_INIT_VALUE or previous return value */
+ )
{
- uint8 *pend;
-#ifdef __mips__
- uint8 tmp[4];
- ulong *tptr = (ulong *)tmp;
-
- /* in case the beginning of the buffer isn't aligned */
- pend = (uint8 *)((uint)(pdata + 3) & 0xfffffffc);
- nbytes -= (pend - pdata);
- while (pdata < pend)
- CRC_INNER_LOOP(32, crc, *pdata++);
-
- /* handle bulk of data as 32-bit words */
- pend = pdata + (nbytes & 0xfffffffc);
- while (pdata < pend) {
- *tptr = *(ulong *)pdata;
- pdata += sizeof(ulong *);
- CRC_INNER_LOOP(32, crc, tmp[0]);
- CRC_INNER_LOOP(32, crc, tmp[1]);
- CRC_INNER_LOOP(32, crc, tmp[2]);
- CRC_INNER_LOOP(32, crc, tmp[3]);
- }
+ /* hard code the crc loop instead of using CRC_INNER_LOOP macro
+ * to avoid the undefined and unnecessary (uint8 >> 8) operation.
+ */
+ while (nbytes-- > 0)
+ crc = crc8_table[(crc ^ *pdata++) & 0xff];
+
+ return crc;
+}
- /* 1-3 bytes at end of buffer */
- pend = pdata + (nbytes & 0x03);
- while (pdata < pend)
- CRC_INNER_LOOP(32, crc, *pdata++);
+/*******************************************************************************
+ * crc16
+ *
+ * Computes a crc16 over the input data using the polynomial:
+ *
+ * x^16 + x^12 +x^5 + 1
+ *
+ * The caller provides the initial value (either CRC16_INIT_VALUE
+ * or the previous returned value) to allow for processing of
+ * discontiguous blocks of data. When generating the CRC the
+ * caller is responsible for complementing the final return value
+ * and inserting it into the byte stream. When checking, a final
+ * return value of CRC16_GOOD_VALUE indicates a valid CRC.
+ *
+ * Reference: Dallas Semiconductor Application Note 27
+ * Williams, Ross N., "A Painless Guide to CRC Error Detection Algorithms",
+ * ver 3, Aug 1993, ross@guest.adelaide.edu.au, Rocksoft Pty Ltd.,
+ * ftp://ftp.rocksoft.com/clients/rocksoft/papers/crc_v3.txt
+ *
+ * ****************************************************************************
+ */
+static const uint16 crc16_table[256] = {
+ 0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF,
+ 0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7,
+ 0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E,
+ 0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876,
+ 0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD,
+ 0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5,
+ 0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C,
+ 0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974,
+ 0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB,
+ 0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3,
+ 0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A,
+ 0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72,
+ 0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9,
+ 0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1,
+ 0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738,
+ 0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70,
+ 0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7,
+ 0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF,
+ 0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036,
+ 0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E,
+ 0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5,
+ 0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD,
+ 0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134,
+ 0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C,
+ 0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3,
+ 0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB,
+ 0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232,
+ 0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A,
+ 0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1,
+ 0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9,
+ 0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330,
+ 0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78
+};
+
+uint16 BCMROMFN (hndcrc16) (uint8 * pdata, /* pointer to array of data to process */
+ uint nbytes, /* number of input data bytes to process */
+ uint16 crc /* either CRC16_INIT_VALUE or previous return value */
+ )
+{
+ while (nbytes-- > 0)
+ CRC_INNER_LOOP (16, crc, *pdata++);
+ return crc;
+}
+#endif
+
+static const uint32 crc32_table[256] = {
+ 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
+ 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+ 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+ 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+ 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
+ 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+ 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
+ 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+ 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+ 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+ 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
+ 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+ 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
+ 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+ 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+ 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+ 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
+ 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+ 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
+ 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+ 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+ 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+ 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
+ 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+ 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
+ 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+ 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+ 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+ 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
+ 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+ 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
+ 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+ 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
+ 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+ 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
+ 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+ 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
+ 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+ 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
+ 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+ 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
+ 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+ 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
+ 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+ 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+ 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+ 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
+ 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+ 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
+ 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+ 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
+ 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+ 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
+ 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+ 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
+ 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+ 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
+ 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+ 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
+ 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+ 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
+ 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+ 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+ 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+};
+
+uint32 BCMROMFN (hndcrc32) (uint8 * pdata, /* pointer to array of data to process */
+ uint nbytes, /* number of input data bytes to process */
+ uint32 crc /* either CRC32_INIT_VALUE or previous return value */
+ )
+{
+ uint8 *pend;
+#ifdef __mips__
+ uint8 tmp[4];
+ ulong *tptr = (ulong *) tmp;
+
+ /* in case the beginning of the buffer isn't aligned */
+ pend = (uint8 *) ((uint) (pdata + 3) & 0xfffffffc);
+ nbytes -= (pend - pdata);
+ while (pdata < pend)
+ CRC_INNER_LOOP (32, crc, *pdata++);
+
+ /* handle bulk of data as 32-bit words */
+ pend = pdata + (nbytes & 0xfffffffc);
+ while (pdata < pend)
+ {
+ *tptr = *(ulong *) pdata;
+ pdata += sizeof (ulong *);
+ CRC_INNER_LOOP (32, crc, tmp[0]);
+ CRC_INNER_LOOP (32, crc, tmp[1]);
+ CRC_INNER_LOOP (32, crc, tmp[2]);
+ CRC_INNER_LOOP (32, crc, tmp[3]);
+ }
+
+ /* 1-3 bytes at end of buffer */
+ pend = pdata + (nbytes & 0x03);
+ while (pdata < pend)
+ CRC_INNER_LOOP (32, crc, *pdata++);
#else
- pend = pdata + nbytes;
- while (pdata < pend)
- CRC_INNER_LOOP(32, crc, *pdata++);
+ pend = pdata + nbytes;
+ while (pdata < pend)
+ CRC_INNER_LOOP (32, crc, *pdata++);
#endif /* __mips__ */
- return crc;
+ return crc;
}
+#ifdef notdef
+#define CLEN 1499 /* CRC Length */
+#define CBUFSIZ (CLEN+4)
+#define CNBUFS 5 /* # of bufs */
+
+void
+testcrc32 (void)
+{
+ uint j, k, l;
+ uint8 *buf;
+ uint len[CNBUFS];
+ uint32 crcr;
+ uint32 crc32tv[CNBUFS] =
+ { 0xd2cb1faa, 0xd385c8fa, 0xf5b4f3f3, 0x55789e20, 0x00343110 };
+
+ ASSERT ((buf = MALLOC (CBUFSIZ * CNBUFS)) != NULL);
+
+ /* step through all possible alignments */
+ for (l = 0; l <= 4; l++)
+ {
+ for (j = 0; j < CNBUFS; j++)
+ {
+ len[j] = CLEN;
+ for (k = 0; k < len[j]; k++)
+ *(buf + j * CBUFSIZ + (k + l)) = (j + k) & 0xff;
+ }
+
+ for (j = 0; j < CNBUFS; j++)
+ {
+ crcr = crc32 (buf + j * CBUFSIZ + l, len[j], CRC32_INIT_VALUE);
+ ASSERT (crcr == crc32tv[j]);
+ }
+ }
+
+ MFREE (buf, CBUFSIZ * CNBUFS);
+ return;
+}
+#endif /* notdef */
/*
* Advance from the current 1-byte tag/1-byte length/variable-length value
@@ -732,27 +1592,26 @@ hndcrc32(
* If the current or next TLV is invalid (does not fit in given buffer length),
* NULL is returned.
* *buflen is not modified if the TLV elt parameter is invalid, or is decremented
- * by the TLV paramter's length if it is valid.
+ * by the TLV parameter's length if it is valid.
*/
-bcm_tlv_t *
-bcm_next_tlv(bcm_tlv_t *elt, int *buflen)
+bcm_tlv_t *BCMROMFN (bcm_next_tlv) (bcm_tlv_t * elt, int *buflen)
{
- int len;
+ int len;
- /* validate current elt */
- if (!bcm_valid_tlv(elt, *buflen))
- return NULL;
+ /* validate current elt */
+ if (!bcm_valid_tlv (elt, *buflen))
+ return NULL;
- /* advance to next elt */
- len = elt->len;
- elt = (bcm_tlv_t*)(elt->data + len);
- *buflen -= (2 + len);
+ /* advance to next elt */
+ len = elt->len;
+ elt = (bcm_tlv_t *) (elt->data + len);
+ *buflen -= (2 + len);
- /* validate next elt */
- if (!bcm_valid_tlv(elt, *buflen))
- return NULL;
+ /* validate next elt */
+ if (!bcm_valid_tlv (elt, *buflen))
+ return NULL;
- return elt;
+ return elt;
}
/*
@@ -760,114 +1619,417 @@ bcm_next_tlv(bcm_tlv_t *elt, int *buflen)
* triples, returning a pointer to the substring whose first element
* matches tag
*/
-bcm_tlv_t *
-bcm_parse_tlvs(void *buf, int buflen, uint key)
+bcm_tlv_t *BCMROMFN (bcm_parse_tlvs) (void *buf, int buflen, uint key)
{
- bcm_tlv_t *elt;
- int totlen;
+ bcm_tlv_t *elt;
+ int totlen;
- elt = (bcm_tlv_t*)buf;
- totlen = buflen;
+ elt = (bcm_tlv_t *) buf;
+ totlen = buflen;
- /* find tagged parameter */
- while (totlen >= 2) {
- int len = elt->len;
+ /* find tagged parameter */
+ while (totlen >= 2)
+ {
+ int len = elt->len;
- /* validate remaining totlen */
- if ((elt->id == key) && (totlen >= (len + 2)))
- return (elt);
+ /* validate remaining totlen */
+ if ((elt->id == key) && (totlen >= (len + 2)))
+ return (elt);
- elt = (bcm_tlv_t*)((uint8*)elt + (len + 2));
- totlen -= (len + 2);
- }
+ elt = (bcm_tlv_t *) ((uint8 *) elt + (len + 2));
+ totlen -= (len + 2);
+ }
- return NULL;
+ return NULL;
}
+#if 0
/*
* Traverse a string of 1-byte tag/1-byte length/variable-length value
* triples, returning a pointer to the substring whose first element
* matches tag. Stop parsing when we see an element whose ID is greater
* than the target key.
*/
-bcm_tlv_t *
-bcm_parse_ordered_tlvs(void *buf, int buflen, uint key)
+bcm_tlv_t *BCMROMFN (bcm_parse_ordered_tlvs) (void *buf, int buflen, uint key)
{
- bcm_tlv_t *elt;
- int totlen;
+ bcm_tlv_t *elt;
+ int totlen;
+
+ elt = (bcm_tlv_t *) buf;
+ totlen = buflen;
+
+ /* find tagged parameter */
+ while (totlen >= 2)
+ {
+ uint id = elt->id;
+ int len = elt->len;
+
+ /* Punt if we start seeing IDs > than target key */
+ if (id > key)
+ return (NULL);
+
+ /* validate remaining totlen */
+ if ((id == key) && (totlen >= (len + 2)))
+ return (elt);
+
+ elt = (bcm_tlv_t *) ((uint8 *) elt + (len + 2));
+ totlen -= (len + 2);
+ }
+ return NULL;
+}
- elt = (bcm_tlv_t*)buf;
- totlen = buflen;
+#ifdef BCMDBG
+int
+bcm_format_flags (const bcm_bit_desc_t * bd, uint32 flags, char *buf, int len)
+{
+ int i;
+ char *p = buf;
+ char hexstr[16];
+ int slen = 0;
+ uint32 bit;
+ const char *name;
+
+ if (len < 2 || !buf)
+ return 0;
+
+ buf[0] = '\0';
+ len -= 1;
+
+ for (i = 0; flags != 0; i++)
+ {
+ bit = bd[i].bit;
+ name = bd[i].name;
+ if (bit == 0 && flags)
+ {
+ /* print any unnamed bits */
+ sprintf (hexstr, "0x%X", flags);
+ name = hexstr;
+ flags = 0; /* exit loop */
+ }
+ else if ((flags & bit) == 0)
+ continue;
+ slen += strlen (name);
+ if (len < slen)
+ break;
+ if (p != buf)
+ p += sprintf (p, " "); /* btwn flag space */
+ strcat (p, name);
+ p += strlen (name);
+ flags &= ~bit;
+ len -= slen;
+ slen = 1; /* account for btwn flag space */
+ }
+
+ /* indicate the str was too short */
+ if (flags != 0)
+ {
+ if (len == 0)
+ p--; /* overwrite last char */
+ p += sprintf (p, ">");
+ }
+
+ return (int) (p - buf);
+}
- /* find tagged parameter */
- while (totlen >= 2) {
- uint id = elt->id;
- int len = elt->len;
+void
+deadbeef (void *p, uint len)
+{
+ static uint8 meat[] = { 0xde, 0xad, 0xbe, 0xef };
- /* Punt if we start seeing IDs > than target key */
- if (id > key)
- return (NULL);
+ while (len-- > 0)
+ {
+ *(uint8 *) p = meat[((uintptr) p) & 3];
+ p = (uint8 *) p + 1;
+ }
+}
- /* validate remaining totlen */
- if ((id == key) && (totlen >= (len + 2)))
- return (elt);
+/* pretty hex print a contiguous buffer */
+void
+prhex (const char *msg, uchar * buf, uint nbytes)
+{
+ char line[128], *p;
+ uint i;
- elt = (bcm_tlv_t*)((uint8*)elt + (len + 2));
- totlen -= (len + 2);
+ if (msg && (msg[0] != '\0'))
+ printf ("%s:\n", msg);
+
+ p = line;
+ for (i = 0; i < nbytes; i++)
+ {
+ if (i % 16 == 0)
+ {
+ p += sprintf (p, " %04d: ", i); /* line prefix */
}
- return NULL;
+ p += sprintf (p, "%02x ", buf[i]);
+ if (i % 16 == 15)
+ {
+ printf ("%s\n", line); /* flush line */
+ p = line;
+ }
+ }
+
+ /* flush last partial line */
+ if (p != line)
+ printf ("%s\n", line);
+}
+
+/* print bytes formatted as hex to a string. return the resulting string length */
+int
+bcm_format_hex (char *str, const void *bytes, int len)
+{
+ int i;
+ char *p = str;
+ const uint8 *src = (const uint8 *) bytes;
+
+ for (i = 0; i < len; i++)
+ {
+ p += sprintf (p, "%02X", *src);
+ src++;
+ }
+ return (int) (p - str);
}
+#endif /* BCMDBG */
-/* Initialization of bcmstrbuf structure */
+/* Produce a human-readable string for boardrev */
+char *
+bcm_brev_str (uint16 brev, char *buf)
+{
+ if (brev < 0x100)
+ snprintf (buf, 8, "%d.%d", (brev & 0xf0) >> 4, brev & 0xf);
+ else
+ snprintf (buf, 8, "%c%03x", ((brev & 0xf000) == 0x1000) ? 'P' : 'A',
+ brev & 0xfff);
+
+ return (buf);
+}
+
+#define BUFSIZE_TODUMP_ATONCE 512 /* Buffer size */
+
+/* dump large strings to console */
void
-bcm_binit(struct bcmstrbuf *b, char *buf, uint size)
+printfbig (char *buf)
{
- b->origsize = b->size = size;
- b->origbuf = b->buf = buf;
+ uint len, max_len;
+ char c;
+
+ len = strlen (buf);
+
+ max_len = BUFSIZE_TODUMP_ATONCE;
+
+ while (len > max_len)
+ {
+ c = buf[max_len];
+ buf[max_len] = '\0';
+ printf ("%s", buf);
+ buf[max_len] = c;
+
+ buf += max_len;
+ len -= max_len;
+ }
+ /* print the remaining string */
+ printf ("%s\n", buf);
+ return;
}
-/* Buffer sprintf wrapper to guard against buffer overflow */
-int
-bcm_bprintf(struct bcmstrbuf *b, const char *fmt, ...)
+/* routine to dump fields in a fileddesc structure */
+uint
+bcmdumpfields (readreg_rtn read_rtn, void *arg0, void *arg1,
+ struct fielddesc * fielddesc_array, char *buf, uint32 bufsize)
+{
+ uint filled_len;
+ int len;
+ struct fielddesc *cur_ptr;
+
+ filled_len = 0;
+ cur_ptr = fielddesc_array;
+
+ while (bufsize > 1)
+ {
+ if (cur_ptr->nameandfmt == NULL)
+ break;
+ len = snprintf (buf, bufsize, cur_ptr->nameandfmt,
+ read_rtn (arg0, arg1, cur_ptr->offset));
+ /* check for snprintf overflow or error */
+ if (len < 0 || (uint32) len >= bufsize)
+ len = bufsize - 1;
+ buf += len;
+ bufsize -= len;
+ filled_len += len;
+ cur_ptr++;
+ }
+ return filled_len;
+}
+#endif
+
+uint
+bcm_mkiovar (char *name, char *data, uint datalen, char *buf, uint buflen)
{
- va_list ap;
- int r;
+ uint len;
- va_start(ap, fmt);
- r = vsnprintf(b->buf, b->size, fmt, ap);
+ len = strlen (name) + 1;
- /* Non Ansi C99 compliant returns -1,
- * Ansi compliant return r >= b->size,
- * bcmstdlib returns 0, handle all
- */
- if ((r == -1) || (r >= (int)b->size) || (r == 0))
- {
- b->size = 0;
- }
- else
+ if ((len + datalen) > buflen)
+ return 0;
+
+ strncpy (buf, name, buflen);
+
+ /* append data onto the end of the name string */
+ memcpy (&buf[len], data, datalen);
+ len += datalen;
+
+ return len;
+}
+
+/* Quarter dBm units to mW
+ * Table starts at QDBM_OFFSET, so the first entry is mW for qdBm=153
+ * Table is offset so the last entry is largest mW value that fits in
+ * a uint16.
+ */
+
+#define QDBM_OFFSET 153 /* Offset for first entry */
+#define QDBM_TABLE_LEN 40 /* Table size */
+
+/* Smallest mW value that will round up to the first table entry, QDBM_OFFSET.
+ * Value is ( mW(QDBM_OFFSET - 1) + mW(QDBM_OFFSET) ) / 2
+ */
+#define QDBM_TABLE_LOW_BOUND 6493 /* Low bound */
+
+/* Largest mW value that will round down to the last table entry,
+ * QDBM_OFFSET + QDBM_TABLE_LEN-1.
+ * Value is ( mW(QDBM_OFFSET + QDBM_TABLE_LEN - 1) + mW(QDBM_OFFSET + QDBM_TABLE_LEN) ) / 2.
+ */
+#define QDBM_TABLE_HIGH_BOUND 64938 /* High bound */
+
+static const uint16 nqdBm_to_mW_map[QDBM_TABLE_LEN] = {
+/* qdBm: +0 +1 +2 +3 +4 +5 +6 +7 */
+/* 153: */ 6683, 7079, 7499, 7943, 8414, 8913, 9441, 10000,
+/* 161: */ 10593, 11220, 11885, 12589, 13335, 14125, 14962, 15849,
+/* 169: */ 16788, 17783, 18836, 19953, 21135, 22387, 23714, 25119,
+/* 177: */ 26607, 28184, 29854, 31623, 33497, 35481, 37584, 39811,
+/* 185: */ 42170, 44668, 47315, 50119, 53088, 56234, 59566, 63096
+};
+
+uint16 BCMROMFN (bcm_qdbm_to_mw) (uint8 qdbm)
+{
+ uint factor = 1;
+ int idx = qdbm - QDBM_OFFSET;
+
+ if (idx > QDBM_TABLE_LEN)
+ {
+ /* clamp to max uint16 mW value */
+ return 0xFFFF;
+ }
+
+ /* scale the qdBm index up to the range of the table 0-40
+ * where an offset of 40 qdBm equals a factor of 10 mW.
+ */
+ while (idx < 0)
+ {
+ idx += 40;
+ factor *= 10;
+ }
+
+ /* return the mW value scaled down to the correct factor of 10,
+ * adding in factor/2 to get proper rounding.
+ */
+ return ((nqdBm_to_mW_map[idx] + factor / 2) / factor);
+}
+
+uint8 BCMROMFN (bcm_mw_to_qdbm) (uint16 mw)
+{
+ uint8 qdbm;
+ int offset;
+ uint mw_uint = mw;
+ uint boundary;
+
+ /* handle boundary case */
+ if (mw_uint <= 1)
+ return 0;
+
+ offset = QDBM_OFFSET;
+
+ /* move mw into the range of the table */
+ while (mw_uint < QDBM_TABLE_LOW_BOUND)
+ {
+ mw_uint *= 10;
+ offset -= 40;
+ }
+
+ for (qdbm = 0; qdbm < QDBM_TABLE_LEN - 1; qdbm++)
+ {
+ boundary = nqdBm_to_mW_map[qdbm] + (nqdBm_to_mW_map[qdbm + 1] -
+ nqdBm_to_mW_map[qdbm]) / 2;
+ if (mw_uint < boundary)
+ break;
+ }
+
+ qdbm += (uint8) offset;
+
+ return (qdbm);
+}
+
+
+uint BCMROMFN (bcm_bitcount) (uint8 * bitmap, uint length)
+{
+ uint bitcount = 0, i;
+ uint8 tmp;
+ for (i = 0; i < length; i++)
+ {
+ tmp = bitmap[i];
+ while (tmp)
{
- b->size -= r;
- b->buf += r;
+ bitcount++;
+ tmp &= (tmp - 1);
}
+ }
+ return bitcount;
+}
- va_end(ap);
- return r;
+/* Initialization of bcmstrbuf structure */
+void
+bcm_binit (struct bcmstrbuf *b, char *buf, uint size)
+{
+ b->origsize = b->size = size;
+ b->origbuf = b->buf = buf;
}
-uint
-bcm_bitcount(uint8 *bitmap, uint length)
-{
- uint bitcount = 0, i;
- uint8 tmp;
- for (i = 0; i < length; i++) {
- tmp = bitmap[i];
- while (tmp) {
- bitcount++;
- tmp &= (tmp - 1);
- }
- }
- return bitcount;
+/* Buffer sprintf wrapper to guard against buffer overflow */
+int
+bcm_bprintf (struct bcmstrbuf *b, const char *fmt, ...)
+{
+ va_list ap;
+ int r;
+
+ va_start (ap, fmt);
+ r = vsnprintf (b->buf, b->size, fmt, ap);
+
+ /* Non Ansi C99 compliant returns -1,
+ * Ansi compliant return r >= b->size,
+ * bcmstdlib returns 0, handle all
+ */
+ if ((r == -1) || (r >= (int) b->size) || (r == 0))
+ {
+ b->size = 0;
+ }
+ else
+ {
+ b->size -= r;
+ b->buf += r;
+ }
+
+ va_end (ap);
+
+ return r;
+}
+
+char *
+bcm_ether_ntoa (struct ether_addr *ea, char *buf)
+{
+ snprintf (buf, 18, "%02x:%02x:%02x:%02x:%02x:%02x",
+ ea->octet[0] & 0xff, ea->octet[1] & 0xff, ea->octet[2] & 0xff,
+ ea->octet[3] & 0xff, ea->octet[4] & 0xff, ea->octet[5] & 0xff);
+ return (buf);
}
diff --git a/package/broadcom-wl/src/driver/bcmutils.h b/package/broadcom-wl/src/driver/bcmutils.h
new file mode 100644
index 0000000..9dcf08b
--- /dev/null
+++ b/package/broadcom-wl/src/driver/bcmutils.h
@@ -0,0 +1,582 @@
+/*
+ * Misc useful os-independent macros and functions.
+ *
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ * $Id$
+ */
+
+#ifndef _bcmutils_h_
+#define _bcmutils_h_
+#include "linux_osl.h"
+
+/* ctype replacement */
+#define _BCM_U 0x01 /* upper */
+#define _BCM_L 0x02 /* lower */
+#define _BCM_D 0x04 /* digit */
+#define _BCM_C 0x08 /* cntrl */
+#define _BCM_P 0x10 /* punct */
+#define _BCM_S 0x20 /* white space (space/lf/tab) */
+#define _BCM_X 0x40 /* hex digit */
+#define _BCM_SP 0x80 /* hard space (0x20) */
+
+extern const unsigned char bcm_ctype[];
+#define bcm_ismask(x) (bcm_ctype[(int)(unsigned char)(x)])
+
+#define bcm_isalnum(c) ((bcm_ismask(c)&(_BCM_U|_BCM_L|_BCM_D)) != 0)
+#define bcm_isalpha(c) ((bcm_ismask(c)&(_BCM_U|_BCM_L)) != 0)
+#define bcm_iscntrl(c) ((bcm_ismask(c)&(_BCM_C)) != 0)
+#define bcm_isdigit(c) ((bcm_ismask(c)&(_BCM_D)) != 0)
+#define bcm_isgraph(c) ((bcm_ismask(c)&(_BCM_P|_BCM_U|_BCM_L|_BCM_D)) != 0)
+#define bcm_islower(c) ((bcm_ismask(c)&(_BCM_L)) != 0)
+#define bcm_isprint(c) ((bcm_ismask(c)&(_BCM_P|_BCM_U|_BCM_L|_BCM_D|_BCM_SP)) != 0)
+#define bcm_ispunct(c) ((bcm_ismask(c)&(_BCM_P)) != 0)
+#define bcm_isspace(c) ((bcm_ismask(c)&(_BCM_S)) != 0)
+#define bcm_isupper(c) ((bcm_ismask(c)&(_BCM_U)) != 0)
+#define bcm_isxdigit(c) ((bcm_ismask(c)&(_BCM_D|_BCM_X)) != 0)
+#define bcm_tolower(c) (bcm_isupper((c)) ? ((c) + 'a' - 'A') : (c))
+#define bcm_toupper(c) (bcm_islower((c)) ? ((c) + 'A' - 'a') : (c))
+
+/* Buffer structure for collecting string-formatted data
+* using bcm_bprintf() API.
+* Use bcm_binit() to initialize before use
+*/
+
+struct bcmstrbuf {
+ char *buf; /* pointer to current position in origbuf */
+ unsigned int size; /* current (residual) size in bytes */
+ char *origbuf; /* unmodified pointer to orignal buffer */
+ unsigned int origsize; /* unmodified orignal buffer size in bytes */
+};
+
+/* ** driver-only section ** */
+#include <osl.h>
+
+#define GPIO_PIN_NOTDEFINED 0x20 /* Pin not defined */
+
+
+/* osl multi-precedence packet queue */
+#ifndef PKTQ_LEN_DEFAULT
+#define PKTQ_LEN_DEFAULT 128 /* Max 128 packets */
+#endif
+#ifndef PKTQ_MAX_PREC
+#define PKTQ_MAX_PREC 16 /* Maximum precedence levels */
+#endif
+
+typedef struct pktq_prec {
+ void *head; /* first packet to dequeue */
+ void *tail; /* last packet to dequeue */
+ uint16 len; /* number of queued packets */
+ uint16 max; /* maximum number of queued packets */
+} pktq_prec_t;
+
+
+/* multi-priority pkt queue */
+struct pktq {
+ uint16 num_prec; /* number of precedences in use */
+ uint16 hi_prec; /* rapid dequeue hint (>= highest non-empty prec) */
+ uint16 max; /* total max packets */
+ uint16 len; /* total number of packets */
+ /* q array must be last since # of elements can be either PKTQ_MAX_PREC or 1 */
+ struct pktq_prec q[PKTQ_MAX_PREC];
+};
+
+/* simple, non-priority pkt queue */
+struct spktq {
+ uint16 num_prec; /* number of precedences in use (always 1) */
+ uint16 hi_prec; /* rapid dequeue hint (>= highest non-empty prec) */
+ uint16 max; /* total max packets */
+ uint16 len; /* total number of packets */
+ /* q array must be last since # of elements can be either PKTQ_MAX_PREC or 1 */
+ struct pktq_prec q[1];
+};
+
+#define PKTQ_PREC_ITER(pq, prec) for (prec = (pq)->num_prec - 1; prec >= 0; prec--)
+
+/* forward definition of ether_addr structure used by some function prototypes */
+struct ether_addr;
+
+/* operations on a specific precedence in packet queue */
+
+#define pktq_psetmax(pq, prec, _max) ((pq)->q[prec].max = (_max))
+#define pktq_plen(pq, prec) ((pq)->q[prec].len)
+#define pktq_pavail(pq, prec) ((pq)->q[prec].max - (pq)->q[prec].len)
+#define pktq_pfull(pq, prec) ((pq)->q[prec].len >= (pq)->q[prec].max)
+#define pktq_pempty(pq, prec) ((pq)->q[prec].len == 0)
+
+#define pktq_ppeek(pq, prec) ((pq)->q[prec].head)
+#define pktq_ppeek_tail(pq, prec) ((pq)->q[prec].tail)
+
+extern void *pktq_penq(struct pktq *pq, int prec, void *p);
+extern void *pktq_penq_head(struct pktq *pq, int prec, void *p);
+extern void *pktq_pdeq(struct pktq *pq, int prec);
+extern void *pktq_pdeq_tail(struct pktq *pq, int prec);
+/* Empty the queue at particular precedence level */
+extern void pktq_pflush(osl_t *osh, struct pktq *pq, int prec, bool dir);
+/* Remove a specified packet from its queue */
+extern bool pktq_pdel(struct pktq *pq, void *p, int prec);
+
+/* operations on a set of precedences in packet queue */
+
+extern int pktq_mlen(struct pktq *pq, uint prec_bmp);
+extern void *pktq_mdeq(struct pktq *pq, uint prec_bmp, int *prec_out);
+
+/* operations on packet queue as a whole */
+
+#define pktq_len(pq) ((int)(pq)->len)
+#define pktq_max(pq) ((int)(pq)->max)
+#define pktq_avail(pq) ((int)((pq)->max - (pq)->len))
+#define pktq_full(pq) ((pq)->len >= (pq)->max)
+#define pktq_empty(pq) ((pq)->len == 0)
+
+/* operations for single precedence queues */
+#define pktenq(pq, p) pktq_penq(((struct pktq *)pq), 0, (p))
+#define pktenq_head(pq, p) pktq_penq_head(((struct pktq *)pq), 0, (p))
+#define pktdeq(pq) pktq_pdeq(((struct pktq *)pq), 0)
+#define pktdeq_tail(pq) pktq_pdeq_tail(((struct pktq *)pq), 0)
+#define pktqinit(pq, len) pktq_init(((struct pktq *)pq), 1, len)
+
+extern void pktq_init(struct pktq *pq, int num_prec, int max_len);
+/* prec_out may be NULL if caller is not interested in return value */
+extern void *pktq_deq(struct pktq *pq, int *prec_out);
+extern void *pktq_deq_tail(struct pktq *pq, int *prec_out);
+extern void *pktq_peek(struct pktq *pq, int *prec_out);
+extern void *pktq_peek_tail(struct pktq *pq, int *prec_out);
+extern void pktq_flush(osl_t *osh, struct pktq *pq, bool dir); /* Empty the entire queue */
+extern int pktq_setmax(struct pktq *pq, int max_len);
+
+/* externs */
+/* packet */
+extern uint pktcopy(osl_t *osh, void *p, uint offset, int len, uchar *buf);
+extern uint pkttotlen(osl_t *osh, void *p);
+extern void *pktlast(osl_t *osh, void *p);
+
+/* Get priority from a packet and pass it back in scb (or equiv) */
+extern uint pktsetprio(void *pkt, bool update_vtag);
+#define PKTPRIO_VDSCP 0x100 /* DSCP prio found after VLAN tag */
+#define PKTPRIO_VLAN 0x200 /* VLAN prio found */
+#define PKTPRIO_UPD 0x400 /* DSCP used to update VLAN prio */
+#define PKTPRIO_DSCP 0x800 /* DSCP prio found */
+
+/* string */
+extern int BCMROMFN(bcm_atoi)(char *s);
+extern ulong BCMROMFN(bcm_strtoul)(char *cp, char **endp, uint base);
+extern char *BCMROMFN(bcmstrstr)(char *haystack, char *needle);
+extern char *BCMROMFN(bcmstrcat)(char *dest, const char *src);
+extern char *BCMROMFN(bcmstrncat)(char *dest, const char *src, uint size);
+extern ulong wchar2ascii(char *abuf, ushort *wbuf, ushort wbuflen, ulong abuflen);
+/* ethernet address */
+extern char *bcm_ether_ntoa(struct ether_addr *ea, char *buf);
+extern int BCMROMFN(bcm_ether_atoe)(char *p, struct ether_addr *ea);
+
+/* ip address */
+struct ipv4_addr;
+extern char *bcm_ip_ntoa(struct ipv4_addr *ia, char *buf);
+
+/* delay */
+extern void bcm_mdelay(uint ms);
+/* variable access */
+extern char *getvar(char *vars, const char *name);
+extern int getintvar(char *vars, const char *name);
+extern uint getgpiopin(char *vars, char *pin_name, uint def_pin);
+#ifdef BCMDBG
+extern void prpkt(const char *msg, osl_t *osh, void *p0);
+#endif /* BCMDBG */
+#ifdef BCMPERFSTATS
+extern void bcm_perf_enable(void);
+extern void bcmstats(char *fmt);
+extern void bcmlog(char *fmt, uint a1, uint a2);
+extern void bcmdumplog(char *buf, int size);
+extern int bcmdumplogent(char *buf, uint idx);
+#else
+#define bcm_perf_enable()
+#define bcmstats(fmt)
+#define bcmlog(fmt, a1, a2)
+#define bcmdumplog(buf, size) *buf = '\0'
+#define bcmdumplogent(buf, idx) -1
+#endif /* BCMPERFSTATS */
+extern char *bcm_nvram_vars(uint *length);
+extern int bcm_nvram_cache(void *sbh);
+
+/* Support for sharing code across in-driver iovar implementations.
+ * The intent is that a driver use this structure to map iovar names
+ * to its (private) iovar identifiers, and the lookup function to
+ * find the entry. Macros are provided to map ids and get/set actions
+ * into a single number space for a switch statement.
+ */
+
+/* iovar structure */
+typedef struct bcm_iovar {
+ const char *name; /* name for lookup and display */
+ uint16 varid; /* id for switch */
+ uint16 flags; /* driver-specific flag bits */
+ uint16 type; /* base type of argument */
+ uint16 minlen; /* min length for buffer vars */
+} bcm_iovar_t;
+
+/* varid definitions are per-driver, may use these get/set bits */
+
+/* IOVar action bits for id mapping */
+#define IOV_GET 0 /* Get an iovar */
+#define IOV_SET 1 /* Set an iovar */
+
+/* Varid to actionid mapping */
+#define IOV_GVAL(id) ((id)*2)
+#define IOV_SVAL(id) (((id)*2)+IOV_SET)
+#define IOV_ISSET(actionid) ((actionid & IOV_SET) == IOV_SET)
+
+/* flags are per-driver based on driver attributes */
+
+extern const bcm_iovar_t *bcm_iovar_lookup(const bcm_iovar_t *table, const char *name);
+extern int bcm_iovar_lencheck(const bcm_iovar_t *table, void *arg, int len, bool set);
+
+/* Base type definitions */
+#define IOVT_VOID 0 /* no value (implictly set only) */
+#define IOVT_BOOL 1 /* any value ok (zero/nonzero) */
+#define IOVT_INT8 2 /* integer values are range-checked */
+#define IOVT_UINT8 3 /* unsigned int 8 bits */
+#define IOVT_INT16 4 /* int 16 bits */
+#define IOVT_UINT16 5 /* unsigned int 16 bits */
+#define IOVT_INT32 6 /* int 32 bits */
+#define IOVT_UINT32 7 /* unsigned int 32 bits */
+#define IOVT_BUFFER 8 /* buffer is size-checked as per minlen */
+#define BCM_IOVT_VALID(type) (((unsigned int)(type)) <= IOVT_BUFFER)
+
+/* Initializer for IOV type strings */
+#define BCM_IOV_TYPE_INIT { \
+ "void", \
+ "bool", \
+ "int8", \
+ "uint8", \
+ "int16", \
+ "uint16", \
+ "int32", \
+ "uint32", \
+ "buffer", \
+ "" }
+
+#define BCM_IOVT_IS_INT(type) (\
+ (type == IOVT_BOOL) || \
+ (type == IOVT_INT8) || \
+ (type == IOVT_UINT8) || \
+ (type == IOVT_INT16) || \
+ (type == IOVT_UINT16) || \
+ (type == IOVT_INT32) || \
+ (type == IOVT_UINT32))
+
+/* ** driver/apps-shared section ** */
+
+#define BCME_STRLEN 64 /* Max string length for BCM errors */
+#define VALID_BCMERROR(e) ((e <= 0) && (e >= BCME_LAST))
+
+
+/*
+ * error codes could be added but the defined ones shouldn't be changed/deleted
+ * these error codes are exposed to the user code
+ * when ever a new error code is added to this list
+ * please update errorstring table with the related error string and
+ * update osl files with os specific errorcode map
+*/
+
+#define BCME_OK 0 /* Success */
+#define BCME_ERROR -1 /* Error generic */
+#define BCME_BADARG -2 /* Bad Argument */
+#define BCME_BADOPTION -3 /* Bad option */
+#define BCME_NOTUP -4 /* Not up */
+#define BCME_NOTDOWN -5 /* Not down */
+#define BCME_NOTAP -6 /* Not AP */
+#define BCME_NOTSTA -7 /* Not STA */
+#define BCME_BADKEYIDX -8 /* BAD Key Index */
+#define BCME_RADIOOFF -9 /* Radio Off */
+#define BCME_NOTBANDLOCKED -10 /* Not band locked */
+#define BCME_NOCLK -11 /* No Clock */
+#define BCME_BADRATESET -12 /* BAD Rate valueset */
+#define BCME_BADBAND -13 /* BAD Band */
+#define BCME_BUFTOOSHORT -14 /* Buffer too short */
+#define BCME_BUFTOOLONG -15 /* Buffer too long */
+#define BCME_BUSY -16 /* Busy */
+#define BCME_NOTASSOCIATED -17 /* Not Associated */
+#define BCME_BADSSIDLEN -18 /* Bad SSID len */
+#define BCME_OUTOFRANGECHAN -19 /* Out of Range Channel */
+#define BCME_BADCHAN -20 /* Bad Channel */
+#define BCME_BADADDR -21 /* Bad Address */
+#define BCME_NORESOURCE -22 /* Not Enough Resources */
+#define BCME_UNSUPPORTED -23 /* Unsupported */
+#define BCME_BADLEN -24 /* Bad length */
+#define BCME_NOTREADY -25 /* Not Ready */
+#define BCME_EPERM -26 /* Not Permitted */
+#define BCME_NOMEM -27 /* No Memory */
+#define BCME_ASSOCIATED -28 /* Associated */
+#define BCME_RANGE -29 /* Not In Range */
+#define BCME_NOTFOUND -30 /* Not Found */
+#define BCME_WME_NOT_ENABLED -31 /* WME Not Enabled */
+#define BCME_TSPEC_NOTFOUND -32 /* TSPEC Not Found */
+#define BCME_ACM_NOTSUPPORTED -33 /* ACM Not Supported */
+#define BCME_NOT_WME_ASSOCIATION -34 /* Not WME Association */
+#define BCME_SDIO_ERROR -35 /* SDIO Bus Error */
+#define BCME_DONGLE_DOWN -36 /* Dongle Not Accessible */
+#define BCME_VERSION -37 /* Incorrect version */
+#define BCME_LAST BCME_VERSION
+
+/* These are collection of BCME Error strings */
+#define BCMERRSTRINGTABLE { \
+ "OK", \
+ "Undefined error", \
+ "Bad Argument", \
+ "Bad Option", \
+ "Not up", \
+ "Not down", \
+ "Not AP", \
+ "Not STA", \
+ "Bad Key Index", \
+ "Radio Off", \
+ "Not band locked", \
+ "No clock", \
+ "Bad Rate valueset", \
+ "Bad Band", \
+ "Buffer too short", \
+ "Buffer too long", \
+ "Busy", \
+ "Not Associated", \
+ "Bad SSID len", \
+ "Out of Range Channel", \
+ "Bad Channel", \
+ "Bad Address", \
+ "Not Enough Resources", \
+ "Unsupported", \
+ "Bad length", \
+ "Not Ready", \
+ "Not Permitted", \
+ "No Memory", \
+ "Associated", \
+ "Not In Range", \
+ "Not Found", \
+ "WME Not Enabled", \
+ "TSPEC Not Found", \
+ "ACM Not Supported", \
+ "Not WME Association", \
+ "SDIO Bus Error", \
+ "Dongle Not Accessible", \
+ "Incorrect version" \
+}
+
+#ifndef ABS
+#define ABS(a) (((a) < 0)?-(a):(a))
+#endif /* ABS */
+
+#ifndef MIN
+#define MIN(a, b) (((a) < (b))?(a):(b))
+#endif /* MIN */
+
+#ifndef MAX
+#define MAX(a, b) (((a) > (b))?(a):(b))
+#endif /* MAX */
+
+#define CEIL(x, y) (((x) + ((y)-1)) / (y))
+#define ROUNDUP(x, y) ((((x)+((y)-1))/(y))*(y))
+#define ISALIGNED(a, x) (((a) & ((x)-1)) == 0)
+#define ISPOWEROF2(x) ((((x)-1)&(x)) == 0)
+#define VALID_MASK(mask) !((mask) & ((mask) + 1))
+#ifndef OFFSETOF
+#define OFFSETOF(type, member) ((uint)(uintptr)&((type *)0)->member)
+#endif /* OFFSETOF */
+#ifndef ARRAYSIZE
+#define ARRAYSIZE(a) (sizeof(a)/sizeof(a[0]))
+#endif
+
+/* bit map related macros */
+#ifndef setbit
+#ifndef NBBY /* the BSD family defines NBBY */
+#define NBBY 8 /* 8 bits per byte */
+#endif /* #ifndef NBBY */
+#define setbit(a, i) (((uint8 *)a)[(i)/NBBY] |= 1<<((i)%NBBY))
+#define clrbit(a, i) (((uint8 *)a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))
+#define isset(a, i) (((const uint8 *)a)[(i)/NBBY] & (1<<((i)%NBBY)))
+#define isclr(a, i) ((((const uint8 *)a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
+#endif /* setbit */
+
+#define NBITS(type) (sizeof(type) * 8)
+#define NBITVAL(nbits) (1 << (nbits))
+#define MAXBITVAL(nbits) ((1 << (nbits)) - 1)
+#define NBITMASK(nbits) MAXBITVAL(nbits)
+#define MAXNBVAL(nbyte) MAXBITVAL((nbyte) * 8)
+
+/* basic mux operation - can be optimized on several architectures */
+#define MUX(pred, true, false) ((pred) ? (true) : (false))
+
+/* modulo inc/dec - assumes x E [0, bound - 1] */
+#define MODDEC(x, bound) MUX((x) == 0, (bound) - 1, (x) - 1)
+#define MODINC(x, bound) MUX((x) == (bound) - 1, 0, (x) + 1)
+
+/* modulo inc/dec, bound = 2^k */
+#define MODDEC_POW2(x, bound) (((x) - 1) & ((bound) - 1))
+#define MODINC_POW2(x, bound) (((x) + 1) & ((bound) - 1))
+
+/* modulo add/sub - assumes x, y E [0, bound - 1] */
+#define MODADD(x, y, bound) \
+ MUX((x) + (y) >= (bound), (x) + (y) - (bound), (x) + (y))
+#define MODSUB(x, y, bound) \
+ MUX(((int)(x)) - ((int)(y)) < 0, (x) - (y) + (bound), (x) - (y))
+
+/* module add/sub, bound = 2^k */
+#define MODADD_POW2(x, y, bound) (((x) + (y)) & ((bound) - 1))
+#define MODSUB_POW2(x, y, bound) (((x) - (y)) & ((bound) - 1))
+
+/* crc defines */
+#define CRC8_INIT_VALUE 0xff /* Initial CRC8 checksum value */
+#define CRC8_GOOD_VALUE 0x9f /* Good final CRC8 checksum value */
+#define CRC16_INIT_VALUE 0xffff /* Initial CRC16 checksum value */
+#define CRC16_GOOD_VALUE 0xf0b8 /* Good final CRC16 checksum value */
+#define CRC32_INIT_VALUE 0xffffffff /* Initial CRC32 checksum value */
+#define CRC32_GOOD_VALUE 0xdebb20e3 /* Good final CRC32 checksum value */
+
+/* bcm_format_flags() bit description structure */
+typedef struct bcm_bit_desc {
+ uint32 bit;
+ const char* name;
+} bcm_bit_desc_t;
+
+/* tag_ID/length/value_buffer tuple */
+typedef struct bcm_tlv {
+ uint8 id;
+ uint8 len;
+ uint8 data[1];
+} bcm_tlv_t;
+
+/* Check that bcm_tlv_t fits into the given buflen */
+#define bcm_valid_tlv(elt, buflen) ((buflen) >= 2 && (int)(buflen) >= (int)(2 + (elt)->len))
+
+/* buffer length for ethernet address from bcm_ether_ntoa() */
+#define ETHER_ADDR_STR_LEN 18 /* 18-bytes of Ethernet address buffer length */
+
+/* unaligned load and store macros */
+#ifdef IL_BIGENDIAN
+static INLINE uint32
+load32_ua(uint8 *a)
+{
+ return ((a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3]);
+}
+
+static INLINE void
+store32_ua(uint8 *a, uint32 v)
+{
+ a[0] = (v >> 24) & 0xff;
+ a[1] = (v >> 16) & 0xff;
+ a[2] = (v >> 8) & 0xff;
+ a[3] = v & 0xff;
+}
+
+static INLINE uint16
+load16_ua(uint8 *a)
+{
+ return ((a[0] << 8) | a[1]);
+}
+
+static INLINE void
+store16_ua(uint8 *a, uint16 v)
+{
+ a[0] = (v >> 8) & 0xff;
+ a[1] = v & 0xff;
+}
+
+#else /* IL_BIGENDIAN */
+
+static INLINE uint32
+load32_ua(uint8 *a)
+{
+ return ((a[3] << 24) | (a[2] << 16) | (a[1] << 8) | a[0]);
+}
+
+static INLINE void
+store32_ua(uint8 *a, uint32 v)
+{
+ a[3] = (v >> 24) & 0xff;
+ a[2] = (v >> 16) & 0xff;
+ a[1] = (v >> 8) & 0xff;
+ a[0] = v & 0xff;
+}
+
+static INLINE uint16
+load16_ua(uint8 *a)
+{
+ return ((a[1] << 8) | a[0]);
+}
+
+static INLINE void
+store16_ua(uint8 *a, uint16 v)
+{
+ a[1] = (v >> 8) & 0xff;
+ a[0] = v & 0xff;
+}
+
+#endif /* IL_BIGENDIAN */
+
+/* externs */
+/* crc */
+extern uint8 BCMROMFN(hndcrc8)(uint8 *p, uint nbytes, uint8 crc);
+extern uint16 BCMROMFN(hndcrc16)(uint8 *p, uint nbytes, uint16 crc);
+extern uint32 BCMROMFN(hndcrc32)(uint8 *p, uint nbytes, uint32 crc);
+/* format/print */
+#ifdef BCMDBG
+extern int bcm_format_flags(const bcm_bit_desc_t *bd, uint32 flags, char* buf, int len);
+extern int bcm_format_hex(char *str, const void *bytes, int len);
+extern void deadbeef(void *p, uint len);
+extern void prhex(const char *msg, uchar *buf, uint len);
+#endif /* BCMDBG */
+extern char *bcm_brev_str(uint16 brev, char *buf);
+extern void printfbig(char *buf);
+
+/* IE parsing */
+extern bcm_tlv_t *BCMROMFN(bcm_next_tlv)(bcm_tlv_t *elt, int *buflen);
+extern bcm_tlv_t *BCMROMFN(bcm_parse_tlvs)(void *buf, int buflen, uint key);
+extern bcm_tlv_t *BCMROMFN(bcm_parse_ordered_tlvs)(void *buf, int buflen, uint key);
+
+/* bcmerror */
+extern const char *bcmerrorstr(int bcmerror);
+
+/* multi-bool data type: set of bools, mbool is true if any is set */
+typedef uint32 mbool;
+#define mboolset(mb, bit) ((mb) |= (bit)) /* set one bool */
+#define mboolclr(mb, bit) ((mb) &= ~(bit)) /* clear one bool */
+#define mboolisset(mb, bit) (((mb) & (bit)) != 0) /* TRUE if one bool is set */
+#define mboolmaskset(mb, mask, val) ((mb) = (((mb) & ~(mask)) | (val)))
+
+/* power conversion */
+extern uint16 BCMROMFN(bcm_qdbm_to_mw)(uint8 qdbm);
+extern uint8 BCMROMFN(bcm_mw_to_qdbm)(uint16 mw);
+
+/* generic datastruct to help dump routines */
+struct fielddesc {
+ const char *nameandfmt;
+ uint32 offset;
+ uint32 len;
+};
+
+extern void bcm_binit(struct bcmstrbuf *b, char *buf, uint size);
+extern int bcm_bprintf(struct bcmstrbuf *b, const char *fmt, ...);
+
+typedef uint32 (*readreg_rtn)(void *arg0, void *arg1, uint32 offset);
+extern uint bcmdumpfields(readreg_rtn func_ptr, void *arg0, void *arg1, struct fielddesc *str,
+ char *buf, uint32 bufsize);
+
+extern uint bcm_mkiovar(char *name, char *data, uint datalen, char *buf, uint len);
+extern uint BCMROMFN(bcm_bitcount)(uint8 *bitmap, uint bytelength);
+
+#ifdef BCMDBG_PKT /* pkt logging for debugging */
+#define PKTLIST_SIZE 1000
+typedef struct {
+ void *list[PKTLIST_SIZE]; /* List of pointers to packets */
+ uint count; /* Total count of the packets */
+} pktlist_info_t;
+
+extern void pktlist_add(pktlist_info_t *pktlist, void *p);
+extern void pktlist_remove(pktlist_info_t *pktlist, void *p);
+extern char* pktlist_dump(pktlist_info_t *pktlist, char *buf);
+#endif /* BCMDBG_PKT */
+
+#endif /* _bcmutils_h_ */
diff --git a/package/broadcom-wl/src/driver/hnddma.c b/package/broadcom-wl/src/driver/hnddma.c
index 1b79dff..c6f6a13 100644
--- a/package/broadcom-wl/src/driver/hnddma.c
+++ b/package/broadcom-wl/src/driver/hnddma.c
@@ -2,7 +2,7 @@
* Generic Broadcom Home Networking Division (HND) DMA module.
* This supports the following chips: BCM42xx, 44xx, 47xx .
*
- * Copyright 2006, Broadcom Corporation
+ * Copyright 2007, Broadcom Corporation
* All Rights Reserved.
*
* THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
@@ -10,7 +10,7 @@
* SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
*
- * $Id: hnddma.c,v 1.11 2006/04/08 07:12:42 honor Exp $
+ * $Id$
*/
#include <typedefs.h>
@@ -19,7 +19,7 @@
#include "linux_osl.h"
#include <bcmendian.h>
#include <sbconfig.h>
-#include <bcmutils.h>
+#include "bcmutils.h"
#include <bcmdevs.h>
#include <sbutils.h>
@@ -27,71 +27,77 @@
#include "hnddma.h"
/* debug/trace */
+#ifdef BCMDBG
+#define DMA_ERROR(args) if (!(*di->msg_level & 1)); else printf args
+#define DMA_TRACE(args) if (!(*di->msg_level & 2)); else printf args
+#else
#define DMA_ERROR(args)
#define DMA_TRACE(args)
+#endif
/* default dma message level (if input msg_level pointer is null in dma_attach()) */
-static uint dma_msg_level =
- 0;
+static uint dma_msg_level = 0;
-#define MAXNAMEL 8 /* 8 char names */
+#define MAXNAMEL 8 /* 8 char names */
#define DI_INFO(dmah) (dma_info_t *)dmah
+typedef struct osl_dmainfo osldma_t;
/* dma engine software state */
-typedef struct dma_info {
- struct hnddma_pub hnddma; /* exported structure, don't use hnddma_t,
- * which could be const
- */
- uint *msg_level; /* message level pointer */
- char name[MAXNAMEL]; /* callers name for diag msgs */
-
- void *osh; /* os handle */
- sb_t *sbh; /* sb handle */
-
- bool dma64; /* dma64 enabled */
- bool addrext; /* this dma engine supports DmaExtendedAddrChanges */
-
- dma32regs_t *d32txregs; /* 32 bits dma tx engine registers */
- dma32regs_t *d32rxregs; /* 32 bits dma rx engine registers */
- dma64regs_t *d64txregs; /* 64 bits dma tx engine registers */
- dma64regs_t *d64rxregs; /* 64 bits dma rx engine registers */
-
- uint32 dma64align; /* either 8k or 4k depends on number of dd */
- dma32dd_t *txd32; /* pointer to dma32 tx descriptor ring */
- dma64dd_t *txd64; /* pointer to dma64 tx descriptor ring */
- uint ntxd; /* # tx descriptors tunable */
- uint txin; /* index of next descriptor to reclaim */
- uint txout; /* index of next descriptor to post */
- void **txp; /* pointer to parallel array of pointers to packets */
- osldma_t *tx_dmah; /* DMA TX descriptor ring handle */
- osldma_t **txp_dmah; /* DMA TX packet data handle */
- ulong txdpa; /* physical address of descriptor ring */
- uint txdalign; /* #bytes added to alloc'd mem to align txd */
- uint txdalloc; /* #bytes allocated for the ring */
-
- dma32dd_t *rxd32; /* pointer to dma32 rx descriptor ring */
- dma64dd_t *rxd64; /* pointer to dma64 rx descriptor ring */
- uint nrxd; /* # rx descriptors tunable */
- uint rxin; /* index of next descriptor to reclaim */
- uint rxout; /* index of next descriptor to post */
- void **rxp; /* pointer to parallel array of pointers to packets */
- osldma_t *rx_dmah; /* DMA RX descriptor ring handle */
- osldma_t **rxp_dmah; /* DMA RX packet data handle */
- ulong rxdpa; /* physical address of descriptor ring */
- uint rxdalign; /* #bytes added to alloc'd mem to align rxd */
- uint rxdalloc; /* #bytes allocated for the ring */
-
- /* tunables */
- uint rxbufsize; /* rx buffer size in bytes,
- not including the extra headroom
- */
- uint nrxpost; /* # rx buffers to keep posted */
- uint rxoffset; /* rxcontrol offset */
- uint ddoffsetlow; /* add to get dma address of descriptor ring, low 32 bits */
- uint ddoffsethigh; /* high 32 bits */
- uint dataoffsetlow; /* add to get dma address of data buffer, low 32 bits */
- uint dataoffsethigh; /* high 32 bits */
+typedef struct dma_info
+{
+ struct hnddma_pub hnddma; /* exported structure, don't use hnddma_t,
+ * which could be const
+ */
+ uint *msg_level; /* message level pointer */
+ char name[MAXNAMEL]; /* callers name for diag msgs */
+
+ void *osh; /* os handle */
+ sb_t *sbh; /* sb handle */
+
+ bool dma64; /* dma64 enabled */
+ bool addrext; /* this dma engine supports DmaExtendedAddrChanges */
+
+ dma32regs_t *d32txregs; /* 32 bits dma tx engine registers */
+ dma32regs_t *d32rxregs; /* 32 bits dma rx engine registers */
+ dma64regs_t *d64txregs; /* 64 bits dma tx engine registers */
+ dma64regs_t *d64rxregs; /* 64 bits dma rx engine registers */
+
+ uint32 dma64align; /* either 8k or 4k depends on number of dd */
+ dma32dd_t *txd32; /* pointer to dma32 tx descriptor ring */
+ dma64dd_t *txd64; /* pointer to dma64 tx descriptor ring */
+ uint ntxd; /* # tx descriptors tunable */
+ uint txin; /* index of next descriptor to reclaim */
+ uint txout; /* index of next descriptor to post */
+ void **txp; /* pointer to parallel array of pointers to packets */
+ osldma_t *tx_dmah; /* DMA TX descriptor ring handle */
+ osldma_t **txp_dmah; /* DMA TX packet data handle */
+ ulong txdpa; /* physical address of descriptor ring */
+ uint txdalign; /* #bytes added to alloc'd mem to align txd */
+ uint txdalloc; /* #bytes allocated for the ring */
+
+ dma32dd_t *rxd32; /* pointer to dma32 rx descriptor ring */
+ dma64dd_t *rxd64; /* pointer to dma64 rx descriptor ring */
+ uint nrxd; /* # rx descriptors tunable */
+ uint rxin; /* index of next descriptor to reclaim */
+ uint rxout; /* index of next descriptor to post */
+ void **rxp; /* pointer to parallel array of pointers to packets */
+ osldma_t *rx_dmah; /* DMA RX descriptor ring handle */
+ osldma_t **rxp_dmah; /* DMA RX packet data handle */
+ ulong rxdpa; /* physical address of descriptor ring */
+ uint rxdalign; /* #bytes added to alloc'd mem to align rxd */
+ uint rxdalloc; /* #bytes allocated for the ring */
+
+ /* tunables */
+ uint rxbufsize; /* rx buffer size in bytes,
+ not including the extra headroom
+ */
+ uint nrxpost; /* # rx buffers to keep posted */
+ uint rxoffset; /* rxcontrol offset */
+ uint ddoffsetlow; /* add to get dma address of descriptor ring, low 32 bits */
+ uint ddoffsethigh; /* high 32 bits */
+ uint dataoffsetlow; /* add to get dma address of data buffer, low 32 bits */
+ uint dataoffsethigh; /* high 32 bits */
} dma_info_t;
#ifdef BCMDMA64
@@ -117,1053 +123,1394 @@ typedef struct dma_info {
#define I2B(index, type) ((index) * sizeof(type))
#define PCI32ADDR_HIGH 0xc0000000 /* address[31:30] */
-#define PCI32ADDR_HIGH_SHIFT 30 /* address[31:30] */
+#define PCI32ADDR_HIGH_SHIFT 30 /* address[31:30] */
/* common prototypes */
-static bool _dma_isaddrext(dma_info_t *di);
-static bool _dma_alloc(dma_info_t *di, uint direction);
-static void _dma_detach(dma_info_t *di);
-static void _dma_ddtable_init(dma_info_t *di, uint direction, ulong pa);
-static void _dma_rxinit(dma_info_t *di);
-static void *_dma_rx(dma_info_t *di);
-static void _dma_rxfill(dma_info_t *di);
-static void _dma_rxreclaim(dma_info_t *di);
-static void _dma_rxenable(dma_info_t *di);
-static void * _dma_getnextrxp(dma_info_t *di, bool forceall);
-
-static void _dma_txblock(dma_info_t *di);
-static void _dma_txunblock(dma_info_t *di);
-static uint _dma_txactive(dma_info_t *di);
-
-static void* _dma_peeknexttxp(dma_info_t *di);
-static uintptr _dma_getvar(dma_info_t *di, const char *name);
-static void _dma_counterreset(dma_info_t *di);
-static void _dma_fifoloopbackenable(dma_info_t *di);
+static bool _dma_isaddrext (dma_info_t * di);
+static bool _dma_alloc (dma_info_t * di, uint direction);
+static void _dma_detach (dma_info_t * di);
+static void _dma_ddtable_init (dma_info_t * di, uint direction, ulong pa);
+static void _dma_rxinit (dma_info_t * di);
+static void *_dma_rx (dma_info_t * di);
+static void _dma_rxfill (dma_info_t * di);
+static void _dma_rxreclaim (dma_info_t * di);
+static void _dma_rxenable (dma_info_t * di);
+static void *_dma_getnextrxp (dma_info_t * di, bool forceall);
+
+static void _dma_txblock (dma_info_t * di);
+static void _dma_txunblock (dma_info_t * di);
+static uint _dma_txactive (dma_info_t * di);
+
+static void *_dma_peeknexttxp (dma_info_t * di);
+static uintptr _dma_getvar (dma_info_t * di, const char *name);
+static void _dma_counterreset (dma_info_t * di);
+static void _dma_fifoloopbackenable (dma_info_t * di);
/* ** 32 bit DMA prototypes */
-static bool dma32_alloc(dma_info_t *di, uint direction);
-static bool dma32_txreset(dma_info_t *di);
-static bool dma32_rxreset(dma_info_t *di);
-static bool dma32_txsuspendedidle(dma_info_t *di);
-static int dma32_txfast(dma_info_t *di, void *p0, bool commit);
-static void *dma32_getnexttxp(dma_info_t *di, bool forceall);
-static void *dma32_getnextrxp(dma_info_t *di, bool forceall);
-static void dma32_txrotate(dma_info_t *di);
-static bool dma32_rxidle(dma_info_t *di);
-static void dma32_txinit(dma_info_t *di);
-static bool dma32_txenabled(dma_info_t *di);
-static void dma32_txsuspend(dma_info_t *di);
-static void dma32_txresume(dma_info_t *di);
-static bool dma32_txsuspended(dma_info_t *di);
-static void dma32_txreclaim(dma_info_t *di, bool forceall);
-static bool dma32_txstopped(dma_info_t *di);
-static bool dma32_rxstopped(dma_info_t *di);
-static bool dma32_rxenabled(dma_info_t *di);
-static bool _dma32_addrext(osl_t *osh, dma32regs_t *dma32regs);
+static bool dma32_alloc (dma_info_t * di, uint direction);
+static bool dma32_txreset (dma_info_t * di);
+static bool dma32_rxreset (dma_info_t * di);
+static bool dma32_txsuspendedidle (dma_info_t * di);
+static int dma32_txfast (dma_info_t * di, void *p0, bool commit);
+static void *dma32_getnexttxp (dma_info_t * di, bool forceall);
+static void *dma32_getnextrxp (dma_info_t * di, bool forceall);
+static void dma32_txrotate (dma_info_t * di);
+static bool dma32_rxidle (dma_info_t * di);
+static void dma32_txinit (dma_info_t * di);
+static bool dma32_txenabled (dma_info_t * di);
+static void dma32_txsuspend (dma_info_t * di);
+static void dma32_txresume (dma_info_t * di);
+static bool dma32_txsuspended (dma_info_t * di);
+static void dma32_txreclaim (dma_info_t * di, bool forceall);
+static bool dma32_txstopped (dma_info_t * di);
+static bool dma32_rxstopped (dma_info_t * di);
+static bool dma32_rxenabled (dma_info_t * di);
+static bool _dma32_addrext (osl_t * osh, dma32regs_t * dma32regs);
/* ** 64 bit DMA prototypes and stubs */
#ifdef BCMDMA64
-static bool dma64_alloc(dma_info_t *di, uint direction);
-static bool dma64_txreset(dma_info_t *di);
-static bool dma64_rxreset(dma_info_t *di);
-static bool dma64_txsuspendedidle(dma_info_t *di);
-static int dma64_txfast(dma_info_t *di, void *p0, bool commit);
-static void *dma64_getnexttxp(dma_info_t *di, bool forceall);
-static void *dma64_getnextrxp(dma_info_t *di, bool forceall);
-static void dma64_txrotate(dma_info_t *di);
-
-static bool dma64_rxidle(dma_info_t *di);
-static void dma64_txinit(dma_info_t *di);
-static bool dma64_txenabled(dma_info_t *di);
-static void dma64_txsuspend(dma_info_t *di);
-static void dma64_txresume(dma_info_t *di);
-static bool dma64_txsuspended(dma_info_t *di);
-static void dma64_txreclaim(dma_info_t *di, bool forceall);
-static bool dma64_txstopped(dma_info_t *di);
-static bool dma64_rxstopped(dma_info_t *di);
-static bool dma64_rxenabled(dma_info_t *di);
-static bool _dma64_addrext(osl_t *osh, dma64regs_t *dma64regs);
+static bool dma64_alloc (dma_info_t * di, uint direction);
+static bool dma64_txreset (dma_info_t * di);
+static bool dma64_rxreset (dma_info_t * di);
+static bool dma64_txsuspendedidle (dma_info_t * di);
+static int dma64_txfast (dma_info_t * di, void *p0, bool commit);
+static void *dma64_getnexttxp (dma_info_t * di, bool forceall);
+static void *dma64_getnextrxp (dma_info_t * di, bool forceall);
+static void dma64_txrotate (dma_info_t * di);
+
+static bool dma64_rxidle (dma_info_t * di);
+static void dma64_txinit (dma_info_t * di);
+static bool dma64_txenabled (dma_info_t * di);
+static void dma64_txsuspend (dma_info_t * di);
+static void dma64_txresume (dma_info_t * di);
+static bool dma64_txsuspended (dma_info_t * di);
+static void dma64_txreclaim (dma_info_t * di, bool forceall);
+static bool dma64_txstopped (dma_info_t * di);
+static bool dma64_rxstopped (dma_info_t * di);
+static bool dma64_rxenabled (dma_info_t * di);
+static bool _dma64_addrext (osl_t * osh, dma64regs_t * dma64regs);
#else
-static bool dma64_alloc(dma_info_t *di, uint direction) { return FALSE; }
-static bool dma64_txreset(dma_info_t *di) { return FALSE; }
-static bool dma64_rxreset(dma_info_t *di) { return FALSE; }
-static bool dma64_txsuspendedidle(dma_info_t *di) { return FALSE;}
-static int dma64_txfast(dma_info_t *di, void *p0, bool commit) { return 0; }
-static void *dma64_getnexttxp(dma_info_t *di, bool forceall) { return NULL; }
-static void *dma64_getnextrxp(dma_info_t *di, bool forceall) { return NULL; }
-static void dma64_txrotate(dma_info_t *di) { return; }
-
-static bool dma64_rxidle(dma_info_t *di) { return FALSE; }
-static void dma64_txinit(dma_info_t *di) { return; }
-static bool dma64_txenabled(dma_info_t *di) { return FALSE; }
-static void dma64_txsuspend(dma_info_t *di) { return; }
-static void dma64_txresume(dma_info_t *di) { return; }
-static bool dma64_txsuspended(dma_info_t *di) {return FALSE; }
-static void dma64_txreclaim(dma_info_t *di, bool forceall) { return; }
-static bool dma64_txstopped(dma_info_t *di) { return FALSE; }
-static bool dma64_rxstopped(dma_info_t *di) { return FALSE; }
-static bool dma64_rxenabled(dma_info_t *di) { return FALSE; }
-static bool _dma64_addrext(osl_t *osh, dma64regs_t *dma64regs) { return FALSE; }
-
-#endif /* BCMDMA64 */
+static bool
+dma64_alloc (dma_info_t * di, uint direction)
+{
+ return FALSE;
+}
+static bool
+dma64_txreset (dma_info_t * di)
+{
+ return FALSE;
+}
+static bool
+dma64_rxreset (dma_info_t * di)
+{
+ return FALSE;
+}
+static bool
+dma64_txsuspendedidle (dma_info_t * di)
+{
+ return FALSE;
+}
+static int
+dma64_txfast (dma_info_t * di, void *p0, bool commit)
+{
+ return 0;
+}
+static void *
+dma64_getnexttxp (dma_info_t * di, bool forceall)
+{
+ return NULL;
+}
+static void *
+dma64_getnextrxp (dma_info_t * di, bool forceall)
+{
+ return NULL;
+}
+static void
+dma64_txrotate (dma_info_t * di)
+{
+ return;
+}
+static bool
+dma64_rxidle (dma_info_t * di)
+{
+ return FALSE;
+}
+static void
+dma64_txinit (dma_info_t * di)
+{
+ return;
+}
+static bool
+dma64_txenabled (dma_info_t * di)
+{
+ return FALSE;
+}
+static void
+dma64_txsuspend (dma_info_t * di)
+{
+ return;
+}
+static void
+dma64_txresume (dma_info_t * di)
+{
+ return;
+}
+static bool
+dma64_txsuspended (dma_info_t * di)
+{
+ return FALSE;
+}
+static void
+dma64_txreclaim (dma_info_t * di, bool forceall)
+{
+ return;
+}
+static bool
+dma64_txstopped (dma_info_t * di)
+{
+ return FALSE;
+}
+static bool
+dma64_rxstopped (dma_info_t * di)
+{
+ return FALSE;
+}
+static bool
+dma64_rxenabled (dma_info_t * di)
+{
+ return FALSE;
+}
+static bool
+_dma64_addrext (osl_t * osh, dma64regs_t * dma64regs)
+{
+ return FALSE;
+}
+
+#endif /* BCMDMA64 */
+
+#ifdef BCMDBG
+static void dma32_dumpring (dma_info_t * di, struct bcmstrbuf *b,
+ dma32dd_t * ring, uint start, uint end,
+ uint max_num);
+static void dma32_dump (dma_info_t * di, struct bcmstrbuf *b, bool dumpring);
+static void dma32_dumptx (dma_info_t * di, struct bcmstrbuf *b,
+ bool dumpring);
+static void dma32_dumprx (dma_info_t * di, struct bcmstrbuf *b,
+ bool dumpring);
+
+static void dma64_dumpring (dma_info_t * di, struct bcmstrbuf *b,
+ dma64dd_t * ring, uint start, uint end,
+ uint max_num);
+static void dma64_dump (dma_info_t * di, struct bcmstrbuf *b, bool dumpring);
+static void dma64_dumptx (dma_info_t * di, struct bcmstrbuf *b,
+ bool dumpring);
+static void dma64_dumprx (dma_info_t * di, struct bcmstrbuf *b,
+ bool dumpring);
+#endif
static di_fcn_t dma64proc = {
- (di_detach_t)_dma_detach,
- (di_txinit_t)dma64_txinit,
- (di_txreset_t)dma64_txreset,
- (di_txenabled_t)dma64_txenabled,
- (di_txsuspend_t)dma64_txsuspend,
- (di_txresume_t)dma64_txresume,
- (di_txsuspended_t)dma64_txsuspended,
- (di_txsuspendedidle_t)dma64_txsuspendedidle,
- (di_txfast_t)dma64_txfast,
- (di_txstopped_t)dma64_txstopped,
- (di_txreclaim_t)dma64_txreclaim,
- (di_getnexttxp_t)dma64_getnexttxp,
- (di_peeknexttxp_t)_dma_peeknexttxp,
- (di_txblock_t)_dma_txblock,
- (di_txunblock_t)_dma_txunblock,
- (di_txactive_t)_dma_txactive,
- (di_txrotate_t)dma64_txrotate,
-
- (di_rxinit_t)_dma_rxinit,
- (di_rxreset_t)dma64_rxreset,
- (di_rxidle_t)dma64_rxidle,
- (di_rxstopped_t)dma64_rxstopped,
- (di_rxenable_t)_dma_rxenable,
- (di_rxenabled_t)dma64_rxenabled,
- (di_rx_t)_dma_rx,
- (di_rxfill_t)_dma_rxfill,
- (di_rxreclaim_t)_dma_rxreclaim,
- (di_getnextrxp_t)_dma_getnextrxp,
-
- (di_fifoloopbackenable_t)_dma_fifoloopbackenable,
- (di_getvar_t)_dma_getvar,
- (di_counterreset_t)_dma_counterreset,
-
- NULL,
- NULL,
- NULL,
- 34
+ (di_detach_t) _dma_detach,
+ (di_txinit_t) dma64_txinit,
+ (di_txreset_t) dma64_txreset,
+ (di_txenabled_t) dma64_txenabled,
+ (di_txsuspend_t) dma64_txsuspend,
+ (di_txresume_t) dma64_txresume,
+ (di_txsuspended_t) dma64_txsuspended,
+ (di_txsuspendedidle_t) dma64_txsuspendedidle,
+ (di_txfast_t) dma64_txfast,
+ (di_txstopped_t) dma64_txstopped,
+ (di_txreclaim_t) dma64_txreclaim,
+ (di_getnexttxp_t) dma64_getnexttxp,
+ (di_peeknexttxp_t) _dma_peeknexttxp,
+ (di_txblock_t) _dma_txblock,
+ (di_txunblock_t) _dma_txunblock,
+ (di_txactive_t) _dma_txactive,
+ (di_txrotate_t) dma64_txrotate,
+
+ (di_rxinit_t) _dma_rxinit,
+ (di_rxreset_t) dma64_rxreset,
+ (di_rxidle_t) dma64_rxidle,
+ (di_rxstopped_t) dma64_rxstopped,
+ (di_rxenable_t) _dma_rxenable,
+ (di_rxenabled_t) dma64_rxenabled,
+ (di_rx_t) _dma_rx,
+ (di_rxfill_t) _dma_rxfill,
+ (di_rxreclaim_t) _dma_rxreclaim,
+ (di_getnextrxp_t) _dma_getnextrxp,
+
+ (di_fifoloopbackenable_t) _dma_fifoloopbackenable,
+ (di_getvar_t) _dma_getvar,
+ (di_counterreset_t) _dma_counterreset,
+
+#ifdef BCMDBG
+ (di_dump_t) dma64_dump,
+ (di_dumptx_t) dma64_dumptx,
+ (di_dumprx_t) dma64_dumprx,
+#else
+ NULL,
+ NULL,
+ NULL,
+#endif
+ 34
};
static di_fcn_t dma32proc = {
- (di_detach_t)_dma_detach,
- (di_txinit_t)dma32_txinit,
- (di_txreset_t)dma32_txreset,
- (di_txenabled_t)dma32_txenabled,
- (di_txsuspend_t)dma32_txsuspend,
- (di_txresume_t)dma32_txresume,
- (di_txsuspended_t)dma32_txsuspended,
- (di_txsuspendedidle_t)dma32_txsuspendedidle,
- (di_txfast_t)dma32_txfast,
- (di_txstopped_t)dma32_txstopped,
- (di_txreclaim_t)dma32_txreclaim,
- (di_getnexttxp_t)dma32_getnexttxp,
- (di_peeknexttxp_t)_dma_peeknexttxp,
- (di_txblock_t)_dma_txblock,
- (di_txunblock_t)_dma_txunblock,
- (di_txactive_t)_dma_txactive,
- (di_txrotate_t)dma32_txrotate,
-
- (di_rxinit_t)_dma_rxinit,
- (di_rxreset_t)dma32_rxreset,
- (di_rxidle_t)dma32_rxidle,
- (di_rxstopped_t)dma32_rxstopped,
- (di_rxenable_t)_dma_rxenable,
- (di_rxenabled_t)dma32_rxenabled,
- (di_rx_t)_dma_rx,
- (di_rxfill_t)_dma_rxfill,
- (di_rxreclaim_t)_dma_rxreclaim,
- (di_getnextrxp_t)_dma_getnextrxp,
-
- (di_fifoloopbackenable_t)_dma_fifoloopbackenable,
- (di_getvar_t)_dma_getvar,
- (di_counterreset_t)_dma_counterreset,
-
- NULL,
- NULL,
- NULL,
- 34
+ (di_detach_t) _dma_detach,
+ (di_txinit_t) dma32_txinit,
+ (di_txreset_t) dma32_txreset,
+ (di_txenabled_t) dma32_txenabled,
+ (di_txsuspend_t) dma32_txsuspend,
+ (di_txresume_t) dma32_txresume,
+ (di_txsuspended_t) dma32_txsuspended,
+ (di_txsuspendedidle_t) dma32_txsuspendedidle,
+ (di_txfast_t) dma32_txfast,
+ (di_txstopped_t) dma32_txstopped,
+ (di_txreclaim_t) dma32_txreclaim,
+ (di_getnexttxp_t) dma32_getnexttxp,
+ (di_peeknexttxp_t) _dma_peeknexttxp,
+ (di_txblock_t) _dma_txblock,
+ (di_txunblock_t) _dma_txunblock,
+ (di_txactive_t) _dma_txactive,
+ (di_txrotate_t) dma32_txrotate,
+
+ (di_rxinit_t) _dma_rxinit,
+ (di_rxreset_t) dma32_rxreset,
+ (di_rxidle_t) dma32_rxidle,
+ (di_rxstopped_t) dma32_rxstopped,
+ (di_rxenable_t) _dma_rxenable,
+ (di_rxenabled_t) dma32_rxenabled,
+ (di_rx_t) _dma_rx,
+ (di_rxfill_t) _dma_rxfill,
+ (di_rxreclaim_t) _dma_rxreclaim,
+ (di_getnextrxp_t) _dma_getnextrxp,
+
+ (di_fifoloopbackenable_t) _dma_fifoloopbackenable,
+ (di_getvar_t) _dma_getvar,
+ (di_counterreset_t) _dma_counterreset,
+
+#ifdef BCMDBG
+ (di_dump_t) dma32_dump,
+ (di_dumptx_t) dma32_dumptx,
+ (di_dumprx_t) dma32_dumprx,
+#else
+ NULL,
+ NULL,
+ NULL,
+#endif
+ 34
};
hnddma_t *
-dma_attach(osl_t *osh, char *name, sb_t *sbh, void *dmaregstx, void *dmaregsrx,
- uint ntxd, uint nrxd, uint rxbufsize, uint nrxpost, uint rxoffset, uint *msg_level)
+dma_attach (osl_t * osh, char *name, sb_t * sbh, void *dmaregstx,
+ void *dmaregsrx, uint ntxd, uint nrxd, uint rxbufsize,
+ uint nrxpost, uint rxoffset, uint * msg_level)
{
- dma_info_t *di;
- uint size;
+ dma_info_t *di;
+ uint size;
+
+ /* allocate private info structure */
+ if ((di = MALLOC (osh, sizeof (dma_info_t))) == NULL)
+ {
+#ifdef BCMDBG
+ printf ("dma_attach: out of memory, malloced %d bytes\n",
+ MALLOCED (osh));
+#endif
+ return (NULL);
+ }
+ bzero ((char *) di, sizeof (dma_info_t));
- /* allocate private info structure */
- if ((di = MALLOC(osh, sizeof (dma_info_t))) == NULL) {
- return (NULL);
- }
- bzero((char *)di, sizeof(dma_info_t));
+ di->msg_level = msg_level ? msg_level : &dma_msg_level;
- di->msg_level = msg_level ? msg_level : &dma_msg_level;
+ /* old chips w/o sb is no longer supported */
+ ASSERT (sbh != NULL);
- /* old chips w/o sb is no longer supported */
- ASSERT(sbh != NULL);
-
- di->dma64 = ((sb_coreflagshi(sbh, 0, 0) & SBTMH_DMA64) == SBTMH_DMA64);
+ di->dma64 = ((sb_coreflagshi (sbh, 0, 0) & SBTMH_DMA64) == SBTMH_DMA64);
#ifndef BCMDMA64
- if (di->dma64) {
- DMA_ERROR(("dma_attach: driver doesn't have the capability to support "
- "64 bits DMA\n"));
- goto fail;
- }
+ if (di->dma64)
+ {
+ DMA_ERROR (("dma_attach: driver doesn't have the capability to support "
+ "64 bits DMA\n"));
+ goto fail;
+ }
#endif
- /* check arguments */
- ASSERT(ISPOWEROF2(ntxd));
- ASSERT(ISPOWEROF2(nrxd));
- if (nrxd == 0)
- ASSERT(dmaregsrx == NULL);
- if (ntxd == 0)
- ASSERT(dmaregstx == NULL);
-
-
- /* init dma reg pointer */
- if (di->dma64) {
- ASSERT(ntxd <= D64MAXDD);
- ASSERT(nrxd <= D64MAXDD);
- di->d64txregs = (dma64regs_t *)dmaregstx;
- di->d64rxregs = (dma64regs_t *)dmaregsrx;
-
- di->dma64align = D64RINGALIGN;
- if ((ntxd < D64MAXDD / 2) && (nrxd < D64MAXDD / 2)) {
- /* for smaller dd table, HW relax the alignment requirement */
- di->dma64align = D64RINGALIGN / 2;
- }
- } else {
- ASSERT(ntxd <= D32MAXDD);
- ASSERT(nrxd <= D32MAXDD);
- di->d32txregs = (dma32regs_t *)dmaregstx;
- di->d32rxregs = (dma32regs_t *)dmaregsrx;
+ /* check arguments */
+ ASSERT (ISPOWEROF2 (ntxd));
+ ASSERT (ISPOWEROF2 (nrxd));
+ if (nrxd == 0)
+ ASSERT (dmaregsrx == NULL);
+ if (ntxd == 0)
+ ASSERT (dmaregstx == NULL);
+
+
+ /* init dma reg pointer */
+ if (di->dma64)
+ {
+ ASSERT (ntxd <= D64MAXDD);
+ ASSERT (nrxd <= D64MAXDD);
+ di->d64txregs = (dma64regs_t *) dmaregstx;
+ di->d64rxregs = (dma64regs_t *) dmaregsrx;
+
+ di->dma64align = D64RINGALIGN;
+ if ((ntxd < D64MAXDD / 2) && (nrxd < D64MAXDD / 2))
+ {
+ /* for smaller dd table, HW relax the alignment requirement */
+ di->dma64align = D64RINGALIGN / 2;
}
-
- DMA_TRACE(("%s: dma_attach: %s osh %p ntxd %d nrxd %d rxbufsize %d nrxpost %d "
- "rxoffset %d dmaregstx %p dmaregsrx %p\n",
- name, (di->dma64 ? "DMA64" : "DMA32"), osh, ntxd, nrxd, rxbufsize,
- nrxpost, rxoffset, dmaregstx, dmaregsrx));
-
- /* make a private copy of our callers name */
- strncpy(di->name, name, MAXNAMEL);
- di->name[MAXNAMEL-1] = '\0';
-
- di->osh = osh;
- di->sbh = sbh;
-
- /* save tunables */
- di->ntxd = ntxd;
- di->nrxd = nrxd;
-
- /* the actual dma size doesn't include the extra headroom */
- if (rxbufsize > BCMEXTRAHDROOM)
- di->rxbufsize = rxbufsize - BCMEXTRAHDROOM;
- else
- di->rxbufsize = rxbufsize;
-
- di->nrxpost = nrxpost;
- di->rxoffset = rxoffset;
-
- /*
- * figure out the DMA physical address offset for dd and data
- * for old chips w/o sb, use zero
- * for new chips w sb,
- * PCI/PCIE: they map silicon backplace address to zero based memory, need offset
- * Other bus: use zero
- * SB_BUS BIGENDIAN kludge: use sdram swapped region for data buffer, not descriptor
- */
- di->ddoffsetlow = 0;
- di->dataoffsetlow = 0;
- /* for pci bus, add offset */
- if (sbh->bustype == PCI_BUS) {
- if ((sbh->buscoretype == SB_PCIE) && di->dma64) {
- /* pcie with DMA64 */
- di->ddoffsetlow = 0;
- di->ddoffsethigh = SB_PCIE_DMA_H32;
- } else {
- /* pci(DMA32/DMA64) or pcie with DMA32 */
- di->ddoffsetlow = SB_PCI_DMA;
- di->ddoffsethigh = 0;
- }
- di->dataoffsetlow = di->ddoffsetlow;
- di->dataoffsethigh = di->ddoffsethigh;
+ }
+ else
+ {
+ ASSERT (ntxd <= D32MAXDD);
+ ASSERT (nrxd <= D32MAXDD);
+ di->d32txregs = (dma32regs_t *) dmaregstx;
+ di->d32rxregs = (dma32regs_t *) dmaregsrx;
+ }
+
+ DMA_TRACE (("%s: dma_attach: %s osh %p ntxd %d nrxd %d rxbufsize %d nrxpost %d " "rxoffset %d dmaregstx %p dmaregsrx %p\n", name, (di->dma64 ? "DMA64" : "DMA32"), osh, ntxd, nrxd, rxbufsize, nrxpost, rxoffset, dmaregstx, dmaregsrx));
+
+ /* make a private copy of our callers name */
+ strncpy (di->name, name, MAXNAMEL);
+ di->name[MAXNAMEL - 1] = '\0';
+
+ di->osh = osh;
+ di->sbh = sbh;
+
+ /* save tunables */
+ di->ntxd = ntxd;
+ di->nrxd = nrxd;
+
+ /* the actual dma size doesn't include the extra headroom */
+ if (rxbufsize > BCMEXTRAHDROOM)
+ di->rxbufsize = rxbufsize - BCMEXTRAHDROOM;
+ else
+ di->rxbufsize = rxbufsize;
+
+ di->nrxpost = nrxpost;
+ di->rxoffset = rxoffset;
+
+ /*
+ * figure out the DMA physical address offset for dd and data
+ * for old chips w/o sb, use zero
+ * for new chips w sb,
+ * PCI/PCIE: they map silicon backplace address to zero based memory, need offset
+ * Other bus: use zero
+ * SB_BUS BIGENDIAN kludge: use sdram swapped region for data buffer, not descriptor
+ */
+ di->ddoffsetlow = 0;
+ di->dataoffsetlow = 0;
+ /* for pci bus, add offset */
+ if (sbh->bustype == PCI_BUS)
+ {
+ if ((sbh->buscoretype == SB_PCIE) && di->dma64)
+ {
+ /* pcie with DMA64 */
+ di->ddoffsetlow = 0;
+ di->ddoffsethigh = SB_PCIE_DMA_H32;
}
+ else
+ {
+ /* pci(DMA32/DMA64) or pcie with DMA32 */
+ di->ddoffsetlow = SB_PCI_DMA;
+ di->ddoffsethigh = 0;
+ }
+ di->dataoffsetlow = di->ddoffsetlow;
+ di->dataoffsethigh = di->ddoffsethigh;
+ }
#if defined(__mips__) && defined(IL_BIGENDIAN)
- di->dataoffsetlow = di->dataoffsetlow + SB_SDRAM_SWAPPED;
+ di->dataoffsetlow = di->dataoffsetlow + SB_SDRAM_SWAPPED;
#endif
- di->addrext = _dma_isaddrext(di);
-
- /* allocate tx packet pointer vector */
- if (ntxd) {
- size = ntxd * sizeof(void *);
- if ((di->txp = MALLOC(osh, size)) == NULL) {
- DMA_ERROR(("%s: dma_attach: out of tx memory, malloced %d bytes\n",
- di->name, MALLOCED(osh)));
- goto fail;
- }
- bzero((char *)di->txp, size);
+ di->addrext = _dma_isaddrext (di);
+
+ /* allocate tx packet pointer vector */
+ if (ntxd)
+ {
+ size = ntxd * sizeof (void *);
+ if ((di->txp = MALLOC (osh, size)) == NULL)
+ {
+ DMA_ERROR (("%s: dma_attach: out of tx memory, malloced %d bytes\n",
+ di->name, MALLOCED (osh)));
+ goto fail;
}
-
- /* allocate rx packet pointer vector */
- if (nrxd) {
- size = nrxd * sizeof(void *);
- if ((di->rxp = MALLOC(osh, size)) == NULL) {
- DMA_ERROR(("%s: dma_attach: out of rx memory, malloced %d bytes\n",
- di->name, MALLOCED(osh)));
- goto fail;
- }
- bzero((char *)di->rxp, size);
+ bzero ((char *) di->txp, size);
+ }
+
+ /* allocate rx packet pointer vector */
+ if (nrxd)
+ {
+ size = nrxd * sizeof (void *);
+ if ((di->rxp = MALLOC (osh, size)) == NULL)
+ {
+ DMA_ERROR (("%s: dma_attach: out of rx memory, malloced %d bytes\n",
+ di->name, MALLOCED (osh)));
+ goto fail;
}
-
- /* allocate transmit descriptor ring, only need ntxd descriptors but it must be aligned */
- if (ntxd) {
- if (!_dma_alloc(di, DMA_TX))
- goto fail;
- }
-
- /* allocate receive descriptor ring, only need nrxd descriptors but it must be aligned */
- if (nrxd) {
- if (!_dma_alloc(di, DMA_RX))
- goto fail;
- }
-
- if ((di->ddoffsetlow == SB_PCI_DMA) && (di->txdpa > SB_PCI_DMA_SZ) && !di->addrext) {
- DMA_ERROR(("%s: dma_attach: txdpa 0x%lx: addrext not supported\n",
- di->name, di->txdpa));
- goto fail;
- }
- if ((di->ddoffsetlow == SB_PCI_DMA) && (di->rxdpa > SB_PCI_DMA_SZ) && !di->addrext) {
- DMA_ERROR(("%s: dma_attach: rxdpa 0x%lx: addrext not supported\n",
- di->name, di->rxdpa));
- goto fail;
- }
-
- DMA_TRACE(("ddoffsetlow 0x%x ddoffsethigh 0x%x dataoffsetlow 0x%x dataoffsethigh "
- "0x%x addrext %d\n", di->ddoffsetlow, di->ddoffsethigh, di->dataoffsetlow,
- di->dataoffsethigh, di->addrext));
-
- /* allocate tx packet pointer vector and DMA mapping vectors */
- if (ntxd) {
-
- size = ntxd * sizeof(osldma_t **);
- if ((di->txp_dmah = (osldma_t **)MALLOC(osh, size)) == NULL)
- goto fail;
- bzero((char*)di->txp_dmah, size);
- }else
- di->txp_dmah = NULL;
-
- /* allocate rx packet pointer vector and DMA mapping vectors */
- if (nrxd) {
-
- size = nrxd * sizeof(osldma_t **);
- if ((di->rxp_dmah = (osldma_t **)MALLOC(osh, size)) == NULL)
- goto fail;
- bzero((char*)di->rxp_dmah, size);
-
- } else
- di->rxp_dmah = NULL;
-
- /* initialize opsvec of function pointers */
- di->hnddma.di_fn = DMA64_ENAB(di) ? dma64proc : dma32proc;
-
- return ((hnddma_t *)di);
+ bzero ((char *) di->rxp, size);
+ }
+
+ /* allocate transmit descriptor ring, only need ntxd descriptors but it must be aligned */
+ if (ntxd)
+ {
+ if (!_dma_alloc (di, DMA_TX))
+ goto fail;
+ }
+
+ /* allocate receive descriptor ring, only need nrxd descriptors but it must be aligned */
+ if (nrxd)
+ {
+ if (!_dma_alloc (di, DMA_RX))
+ goto fail;
+ }
+
+ if ((di->ddoffsetlow == SB_PCI_DMA) && (di->txdpa > SB_PCI_DMA_SZ)
+ && !di->addrext)
+ {
+ DMA_ERROR (("%s: dma_attach: txdpa 0x%lx: addrext not supported\n",
+ di->name, di->txdpa));
+ goto fail;
+ }
+ if ((di->ddoffsetlow == SB_PCI_DMA) && (di->rxdpa > SB_PCI_DMA_SZ)
+ && !di->addrext)
+ {
+ DMA_ERROR (("%s: dma_attach: rxdpa 0x%lx: addrext not supported\n",
+ di->name, di->rxdpa));
+ goto fail;
+ }
+
+ DMA_TRACE (("ddoffsetlow 0x%x ddoffsethigh 0x%x dataoffsetlow 0x%x dataoffsethigh " "0x%x addrext %d\n", di->ddoffsetlow, di->ddoffsethigh, di->dataoffsetlow, di->dataoffsethigh, di->addrext));
+
+ /* allocate tx packet pointer vector and DMA mapping vectors */
+ if (ntxd)
+ {
+
+ size = ntxd * sizeof (osldma_t **);
+ if ((di->txp_dmah = (osldma_t **) MALLOC (osh, size)) == NULL)
+ goto fail;
+ bzero ((char *) di->txp_dmah, size);
+ }
+ else
+ di->txp_dmah = NULL;
+
+ /* allocate rx packet pointer vector and DMA mapping vectors */
+ if (nrxd)
+ {
+
+ size = nrxd * sizeof (osldma_t **);
+ if ((di->rxp_dmah = (osldma_t **) MALLOC (osh, size)) == NULL)
+ goto fail;
+ bzero ((char *) di->rxp_dmah, size);
+
+ }
+ else
+ di->rxp_dmah = NULL;
+
+ /* initialize opsvec of function pointers */
+ di->hnddma.di_fn = DMA64_ENAB (di) ? dma64proc : dma32proc;
+
+ return ((hnddma_t *) di);
fail:
- _dma_detach(di);
- return (NULL);
+ _dma_detach (di);
+ return (NULL);
}
/* init the tx or rx descriptor */
static INLINE void
-dma32_dd_upd(dma_info_t *di, dma32dd_t *ddring, ulong pa, uint outidx, uint32 *flags,
- uint32 bufcount)
-{
- /* dma32 uses 32 bits control to fit both flags and bufcounter */
- *flags = *flags | (bufcount & CTRL_BC_MASK);
-
- if ((di->dataoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH)) {
- W_SM(&ddring[outidx].addr, BUS_SWAP32(pa + di->dataoffsetlow));
- W_SM(&ddring[outidx].ctrl, BUS_SWAP32(*flags));
- } else {
- /* address extension */
- uint32 ae;
- ASSERT(di->addrext);
- ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
- pa &= ~PCI32ADDR_HIGH;
-
- *flags |= (ae << CTRL_AE_SHIFT);
- W_SM(&ddring[outidx].addr, BUS_SWAP32(pa + di->dataoffsetlow));
- W_SM(&ddring[outidx].ctrl, BUS_SWAP32(*flags));
- }
+dma32_dd_upd (dma_info_t * di, dma32dd_t * ddring, ulong pa, uint outidx,
+ uint32 * flags, uint32 bufcount)
+{
+ /* dma32 uses 32 bits control to fit both flags and bufcounter */
+ *flags = *flags | (bufcount & CTRL_BC_MASK);
+
+ if ((di->dataoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH))
+ {
+ W_SM (&ddring[outidx].addr, BUS_SWAP32 (pa + di->dataoffsetlow));
+ W_SM (&ddring[outidx].ctrl, BUS_SWAP32 (*flags));
+ }
+ else
+ {
+ /* address extension */
+ uint32 ae;
+ ASSERT (di->addrext);
+ ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
+ pa &= ~PCI32ADDR_HIGH;
+
+ *flags |= (ae << CTRL_AE_SHIFT);
+ W_SM (&ddring[outidx].addr, BUS_SWAP32 (pa + di->dataoffsetlow));
+ W_SM (&ddring[outidx].ctrl, BUS_SWAP32 (*flags));
+ }
}
static INLINE void
-dma64_dd_upd(dma_info_t *di, dma64dd_t *ddring, ulong pa, uint outidx, uint32 *flags,
- uint32 bufcount)
-{
- uint32 ctrl2 = bufcount & D64_CTRL2_BC_MASK;
-
- /* PCI bus with big(>1G) physical address, use address extension */
- if ((di->dataoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH)) {
- W_SM(&ddring[outidx].addrlow, BUS_SWAP32(pa + di->dataoffsetlow));
- W_SM(&ddring[outidx].addrhigh, BUS_SWAP32(0 + di->dataoffsethigh));
- W_SM(&ddring[outidx].ctrl1, BUS_SWAP32(*flags));
- W_SM(&ddring[outidx].ctrl2, BUS_SWAP32(ctrl2));
- } else {
- /* address extension */
- uint32 ae;
- ASSERT(di->addrext);
-
- ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
- pa &= ~PCI32ADDR_HIGH;
-
- ctrl2 |= (ae << D64_CTRL2_AE_SHIFT) & D64_CTRL2_AE;
- W_SM(&ddring[outidx].addrlow, BUS_SWAP32(pa + di->dataoffsetlow));
- W_SM(&ddring[outidx].addrhigh, BUS_SWAP32(0 + di->dataoffsethigh));
- W_SM(&ddring[outidx].ctrl1, BUS_SWAP32(*flags));
- W_SM(&ddring[outidx].ctrl2, BUS_SWAP32(ctrl2));
- }
+dma64_dd_upd (dma_info_t * di, dma64dd_t * ddring, ulong pa, uint outidx,
+ uint32 * flags, uint32 bufcount)
+{
+ uint32 ctrl2 = bufcount & D64_CTRL2_BC_MASK;
+
+ /* PCI bus with big(>1G) physical address, use address extension */
+ if ((di->dataoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH))
+ {
+ W_SM (&ddring[outidx].addrlow, BUS_SWAP32 (pa + di->dataoffsetlow));
+ W_SM (&ddring[outidx].addrhigh, BUS_SWAP32 (0 + di->dataoffsethigh));
+ W_SM (&ddring[outidx].ctrl1, BUS_SWAP32 (*flags));
+ W_SM (&ddring[outidx].ctrl2, BUS_SWAP32 (ctrl2));
+ }
+ else
+ {
+ /* address extension */
+ uint32 ae;
+ ASSERT (di->addrext);
+
+ ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
+ pa &= ~PCI32ADDR_HIGH;
+
+ ctrl2 |= (ae << D64_CTRL2_AE_SHIFT) & D64_CTRL2_AE;
+ W_SM (&ddring[outidx].addrlow, BUS_SWAP32 (pa + di->dataoffsetlow));
+ W_SM (&ddring[outidx].addrhigh, BUS_SWAP32 (0 + di->dataoffsethigh));
+ W_SM (&ddring[outidx].ctrl1, BUS_SWAP32 (*flags));
+ W_SM (&ddring[outidx].ctrl2, BUS_SWAP32 (ctrl2));
+ }
}
static bool
-_dma32_addrext(osl_t *osh, dma32regs_t *dma32regs)
+_dma32_addrext (osl_t * osh, dma32regs_t * dma32regs)
{
- uint32 w;
+ uint32 w;
- OR_REG(osh, &dma32regs->control, XC_AE);
- w = R_REG(osh, &dma32regs->control);
- AND_REG(osh, &dma32regs->control, ~XC_AE);
- return ((w & XC_AE) == XC_AE);
+ OR_REG (osh, &dma32regs->control, XC_AE);
+ w = R_REG (osh, &dma32regs->control);
+ AND_REG (osh, &dma32regs->control, ~XC_AE);
+ return ((w & XC_AE) == XC_AE);
}
static bool
-_dma_alloc(dma_info_t *di, uint direction)
+_dma_alloc (dma_info_t * di, uint direction)
{
- if (DMA64_ENAB(di)) {
- return dma64_alloc(di, direction);
- } else {
- return dma32_alloc(di, direction);
- }
+ if (DMA64_ENAB (di))
+ {
+ return dma64_alloc (di, direction);
+ }
+ else
+ {
+ return dma32_alloc (di, direction);
+ }
}
/* !! may be called with core in reset */
static void
-_dma_detach(dma_info_t *di)
-{
- if (di == NULL)
- return;
-
- DMA_TRACE(("%s: dma_detach\n", di->name));
-
- /* shouldn't be here if descriptors are unreclaimed */
- ASSERT(di->txin == di->txout);
- ASSERT(di->rxin == di->rxout);
-
- /* free dma descriptor rings */
- if (DMA64_ENAB(di)) {
- if (di->txd64)
- DMA_FREE_CONSISTENT(di->osh, ((int8*)(uintptr)di->txd64 - di->txdalign),
- di->txdalloc, (di->txdpa - di->txdalign), &di->tx_dmah);
- if (di->rxd64)
- DMA_FREE_CONSISTENT(di->osh, ((int8*)(uintptr)di->rxd64 - di->rxdalign),
- di->rxdalloc, (di->rxdpa - di->rxdalign), &di->rx_dmah);
- } else {
- if (di->txd32)
- DMA_FREE_CONSISTENT(di->osh, ((int8*)(uintptr)di->txd32 - di->txdalign),
- di->txdalloc, (di->txdpa - di->txdalign), &di->tx_dmah);
- if (di->rxd32)
- DMA_FREE_CONSISTENT(di->osh, ((int8*)(uintptr)di->rxd32 - di->rxdalign),
- di->rxdalloc, (di->rxdpa - di->rxdalign), &di->rx_dmah);
- }
-
- /* free packet pointer vectors */
- if (di->txp)
- MFREE(di->osh, (void *)di->txp, (di->ntxd * sizeof(void *)));
- if (di->rxp)
- MFREE(di->osh, (void *)di->rxp, (di->nrxd * sizeof(void *)));
-
- /* free tx packet DMA handles */
- if (di->txp_dmah)
- MFREE(di->osh, (void *)di->txp_dmah, di->ntxd * sizeof(osldma_t **));
-
- /* free rx packet DMA handles */
- if (di->rxp_dmah)
- MFREE(di->osh, (void *)di->rxp_dmah, di->nrxd * sizeof(osldma_t **));
-
- /* free our private info structure */
- MFREE(di->osh, (void *)di, sizeof(dma_info_t));
+_dma_detach (dma_info_t * di)
+{
+ if (di == NULL)
+ return;
+
+ DMA_TRACE (("%s: dma_detach\n", di->name));
+
+ /* shouldn't be here if descriptors are unreclaimed */
+ ASSERT (di->txin == di->txout);
+ ASSERT (di->rxin == di->rxout);
+
+ /* free dma descriptor rings */
+ if (DMA64_ENAB (di))
+ {
+ if (di->txd64)
+ DMA_FREE_CONSISTENT (di->osh,
+ ((int8 *) (uintptr) di->txd64 - di->txdalign),
+ di->txdalloc, (di->txdpa - di->txdalign),
+ &di->tx_dmah);
+ if (di->rxd64)
+ DMA_FREE_CONSISTENT (di->osh,
+ ((int8 *) (uintptr) di->rxd64 - di->rxdalign),
+ di->rxdalloc, (di->rxdpa - di->rxdalign),
+ &di->rx_dmah);
+ }
+ else
+ {
+ if (di->txd32)
+ DMA_FREE_CONSISTENT (di->osh,
+ ((int8 *) (uintptr) di->txd32 - di->txdalign),
+ di->txdalloc, (di->txdpa - di->txdalign),
+ &di->tx_dmah);
+ if (di->rxd32)
+ DMA_FREE_CONSISTENT (di->osh,
+ ((int8 *) (uintptr) di->rxd32 - di->rxdalign),
+ di->rxdalloc, (di->rxdpa - di->rxdalign),
+ &di->rx_dmah);
+ }
+
+ /* free packet pointer vectors */
+ if (di->txp)
+ MFREE (di->osh, (void *) di->txp, (di->ntxd * sizeof (void *)));
+ if (di->rxp)
+ MFREE (di->osh, (void *) di->rxp, (di->nrxd * sizeof (void *)));
+
+ /* free tx packet DMA handles */
+ if (di->txp_dmah)
+ MFREE (di->osh, (void *) di->txp_dmah, di->ntxd * sizeof (osldma_t **));
+
+ /* free rx packet DMA handles */
+ if (di->rxp_dmah)
+ MFREE (di->osh, (void *) di->rxp_dmah, di->nrxd * sizeof (osldma_t **));
+
+ /* free our private info structure */
+ MFREE (di->osh, (void *) di, sizeof (dma_info_t));
}
/* return TRUE if this dma engine supports DmaExtendedAddrChanges, otherwise FALSE */
static bool
-_dma_isaddrext(dma_info_t *di)
-{
- if (DMA64_ENAB(di)) {
- /* DMA64 supports full 32 bits or 64 bits. AE is always valid */
-
- /* not all tx or rx channel are available */
- if (di->d64txregs != NULL) {
- if (!_dma64_addrext(di->osh, di->d64txregs)) {
- DMA_ERROR(("%s: _dma_isaddrext: DMA64 tx doesn't have AE set\n",
- di->name));
- ASSERT(0);
- }
- return TRUE;
- } else if (di->d64rxregs != NULL) {
- if (!_dma64_addrext(di->osh, di->d64rxregs)) {
- DMA_ERROR(("%s: _dma_isaddrext: DMA64 rx doesn't have AE set\n",
- di->name));
- ASSERT(0);
- }
- return TRUE;
- }
- return FALSE;
- } else if (di->d32txregs)
- return (_dma32_addrext(di->osh, di->d32txregs));
- else if (di->d32rxregs)
- return (_dma32_addrext(di->osh, di->d32rxregs));
- return FALSE;
+_dma_isaddrext (dma_info_t * di)
+{
+ if (DMA64_ENAB (di))
+ {
+ /* DMA64 supports full 32 bits or 64 bits. AE is always valid */
+
+ /* not all tx or rx channel are available */
+ if (di->d64txregs != NULL)
+ {
+ if (!_dma64_addrext (di->osh, di->d64txregs))
+ {
+ DMA_ERROR (("%s: _dma_isaddrext: DMA64 tx doesn't have AE set\n", di->name));
+ ASSERT (0);
+ }
+ return TRUE;
+ }
+ else if (di->d64rxregs != NULL)
+ {
+ if (!_dma64_addrext (di->osh, di->d64rxregs))
+ {
+ DMA_ERROR (("%s: _dma_isaddrext: DMA64 rx doesn't have AE set\n", di->name));
+ ASSERT (0);
+ }
+ return TRUE;
+ }
+ return FALSE;
+ }
+ else if (di->d32txregs)
+ return (_dma32_addrext (di->osh, di->d32txregs));
+ else if (di->d32rxregs)
+ return (_dma32_addrext (di->osh, di->d32rxregs));
+ return FALSE;
}
/* initialize descriptor table base address */
static void
-_dma_ddtable_init(dma_info_t *di, uint direction, ulong pa)
-{
- if (DMA64_ENAB(di)) {
-
- if ((di->ddoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH)) {
- if (direction == DMA_TX) {
- W_REG(di->osh, &di->d64txregs->addrlow, (pa + di->ddoffsetlow));
- W_REG(di->osh, &di->d64txregs->addrhigh, di->ddoffsethigh);
- } else {
- W_REG(di->osh, &di->d64rxregs->addrlow, (pa + di->ddoffsetlow));
- W_REG(di->osh, &di->d64rxregs->addrhigh, di->ddoffsethigh);
- }
- } else {
- /* DMA64 32bits address extension */
- uint32 ae;
- ASSERT(di->addrext);
-
- /* shift the high bit(s) from pa to ae */
- ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
- pa &= ~PCI32ADDR_HIGH;
-
- if (direction == DMA_TX) {
- W_REG(di->osh, &di->d64txregs->addrlow, (pa + di->ddoffsetlow));
- W_REG(di->osh, &di->d64txregs->addrhigh, di->ddoffsethigh);
- SET_REG(di->osh, &di->d64txregs->control, D64_XC_AE,
- (ae << D64_XC_AE_SHIFT));
- } else {
- W_REG(di->osh, &di->d64rxregs->addrlow, (pa + di->ddoffsetlow));
- W_REG(di->osh, &di->d64rxregs->addrhigh, di->ddoffsethigh);
- SET_REG(di->osh, &di->d64rxregs->control, D64_RC_AE,
- (ae << D64_RC_AE_SHIFT));
- }
- }
-
- } else {
- if ((di->ddoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH)) {
- if (direction == DMA_TX)
- W_REG(di->osh, &di->d32txregs->addr, (pa + di->ddoffsetlow));
- else
- W_REG(di->osh, &di->d32rxregs->addr, (pa + di->ddoffsetlow));
- } else {
- /* dma32 address extension */
- uint32 ae;
- ASSERT(di->addrext);
-
- /* shift the high bit(s) from pa to ae */
- ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
- pa &= ~PCI32ADDR_HIGH;
-
- if (direction == DMA_TX) {
- W_REG(di->osh, &di->d32txregs->addr, (pa + di->ddoffsetlow));
- SET_REG(di->osh, &di->d32txregs->control, XC_AE, ae <<XC_AE_SHIFT);
- } else {
- W_REG(di->osh, &di->d32rxregs->addr, (pa + di->ddoffsetlow));
- SET_REG(di->osh, &di->d32rxregs->control, RC_AE, ae <<RC_AE_SHIFT);
- }
- }
+_dma_ddtable_init (dma_info_t * di, uint direction, ulong pa)
+{
+ if (DMA64_ENAB (di))
+ {
+
+ if ((di->ddoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH))
+ {
+ if (direction == DMA_TX)
+ {
+ W_REG (di->osh, &di->d64txregs->addrlow,
+ (pa + di->ddoffsetlow));
+ W_REG (di->osh, &di->d64txregs->addrhigh, di->ddoffsethigh);
+ }
+ else
+ {
+ W_REG (di->osh, &di->d64rxregs->addrlow,
+ (pa + di->ddoffsetlow));
+ W_REG (di->osh, &di->d64rxregs->addrhigh, di->ddoffsethigh);
+ }
+ }
+ else
+ {
+ /* DMA64 32bits address extension */
+ uint32 ae;
+ ASSERT (di->addrext);
+
+ /* shift the high bit(s) from pa to ae */
+ ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
+ pa &= ~PCI32ADDR_HIGH;
+
+ if (direction == DMA_TX)
+ {
+ W_REG (di->osh, &di->d64txregs->addrlow,
+ (pa + di->ddoffsetlow));
+ W_REG (di->osh, &di->d64txregs->addrhigh, di->ddoffsethigh);
+ SET_REG (di->osh, &di->d64txregs->control, D64_XC_AE,
+ (ae << D64_XC_AE_SHIFT));
+ }
+ else
+ {
+ W_REG (di->osh, &di->d64rxregs->addrlow,
+ (pa + di->ddoffsetlow));
+ W_REG (di->osh, &di->d64rxregs->addrhigh, di->ddoffsethigh);
+ SET_REG (di->osh, &di->d64rxregs->control, D64_RC_AE,
+ (ae << D64_RC_AE_SHIFT));
+ }
+ }
+
+ }
+ else
+ {
+ if ((di->ddoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH))
+ {
+ if (direction == DMA_TX)
+ W_REG (di->osh, &di->d32txregs->addr, (pa + di->ddoffsetlow));
+ else
+ W_REG (di->osh, &di->d32rxregs->addr, (pa + di->ddoffsetlow));
}
+ else
+ {
+ /* dma32 address extension */
+ uint32 ae;
+ ASSERT (di->addrext);
+
+ /* shift the high bit(s) from pa to ae */
+ ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
+ pa &= ~PCI32ADDR_HIGH;
+
+ if (direction == DMA_TX)
+ {
+ W_REG (di->osh, &di->d32txregs->addr, (pa + di->ddoffsetlow));
+ SET_REG (di->osh, &di->d32txregs->control, XC_AE,
+ ae << XC_AE_SHIFT);
+ }
+ else
+ {
+ W_REG (di->osh, &di->d32rxregs->addr, (pa + di->ddoffsetlow));
+ SET_REG (di->osh, &di->d32rxregs->control, RC_AE,
+ ae << RC_AE_SHIFT);
+ }
+ }
+ }
}
static void
-_dma_fifoloopbackenable(dma_info_t *di)
+_dma_fifoloopbackenable (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_fifoloopbackenable\n", di->name));
- if (DMA64_ENAB(di))
- OR_REG(di->osh, &di->d64txregs->control, D64_XC_LE);
- else
- OR_REG(di->osh, &di->d32txregs->control, XC_LE);
+ DMA_TRACE (("%s: dma_fifoloopbackenable\n", di->name));
+ if (DMA64_ENAB (di))
+ OR_REG (di->osh, &di->d64txregs->control, D64_XC_LE);
+ else
+ OR_REG (di->osh, &di->d32txregs->control, XC_LE);
}
static void
-_dma_rxinit(dma_info_t *di)
+_dma_rxinit (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_rxinit\n", di->name));
+ DMA_TRACE (("%s: dma_rxinit\n", di->name));
- if (di->nrxd == 0)
- return;
+ if (di->nrxd == 0)
+ return;
- di->rxin = di->rxout = 0;
+ di->rxin = di->rxout = 0;
- /* clear rx descriptor ring */
- if (DMA64_ENAB(di)) {
- BZERO_SM((void *)(uintptr)di->rxd64, (di->nrxd * sizeof(dma64dd_t)));
- _dma_rxenable(di);
- _dma_ddtable_init(di, DMA_RX, di->rxdpa);
- } else {
- BZERO_SM((void *)(uintptr)di->rxd32, (di->nrxd * sizeof(dma32dd_t)));
- _dma_rxenable(di);
- _dma_ddtable_init(di, DMA_RX, di->rxdpa);
- }
+ /* clear rx descriptor ring */
+ if (DMA64_ENAB (di))
+ BZERO_SM ((void *) (uintptr) di->rxd64, (di->nrxd * sizeof (dma64dd_t)));
+ else
+ BZERO_SM ((void *) (uintptr) di->rxd32, (di->nrxd * sizeof (dma32dd_t)));
+
+ _dma_rxenable (di);
+ _dma_ddtable_init (di, DMA_RX, di->rxdpa);
}
static void
-_dma_rxenable(dma_info_t *di)
+_dma_rxenable (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_rxenable\n", di->name));
-
- if (DMA64_ENAB(di))
- W_REG(di->osh, &di->d64rxregs->control,
- ((di->rxoffset << D64_RC_RO_SHIFT) | D64_RC_RE));
- else
- W_REG(di->osh, &di->d32rxregs->control, ((di->rxoffset << RC_RO_SHIFT) | RC_RE));
+ DMA_TRACE (("%s: dma_rxenable\n", di->name));
+
+ if (DMA64_ENAB (di))
+ W_REG (di->osh, &di->d64rxregs->control,
+ ((di->rxoffset << D64_RC_RO_SHIFT) | D64_RC_RE));
+ else
+ W_REG (di->osh, &di->d32rxregs->control,
+ ((di->rxoffset << RC_RO_SHIFT) | RC_RE));
}
/* !! rx entry routine, returns a pointer to the next frame received,
* or NULL if there are no more
*/
static void *
-_dma_rx(dma_info_t *di)
-{
- void *p;
- uint len;
- int skiplen = 0;
-
- while ((p = _dma_getnextrxp(di, FALSE))) {
- /* skip giant packets which span multiple rx descriptors */
- if (skiplen > 0) {
- skiplen -= di->rxbufsize;
- if (skiplen < 0)
- skiplen = 0;
- PKTFREE(di->osh, p, FALSE);
- continue;
- }
-
- len = ltoh16(*(uint16*)(PKTDATA(di->osh, p)));
- DMA_TRACE(("%s: dma_rx len %d\n", di->name, len));
-
- /* bad frame length check */
- if (len > (di->rxbufsize - di->rxoffset)) {
- DMA_ERROR(("%s: dma_rx: bad frame length (%d)\n", di->name, len));
- if (len > 0)
- skiplen = len - (di->rxbufsize - di->rxoffset);
- PKTFREE(di->osh, p, FALSE);
- di->hnddma.rxgiants++;
- continue;
- }
-
- /* set actual length */
- PKTSETLEN(di->osh, p, (di->rxoffset + len));
-
- break;
+_dma_rx (dma_info_t * di)
+{
+ void *p;
+ uint len;
+ int skiplen = 0;
+
+ while ((p = _dma_getnextrxp (di, FALSE)))
+ {
+ /* skip giant packets which span multiple rx descriptors */
+ if (skiplen > 0)
+ {
+ skiplen -= di->rxbufsize;
+ if (skiplen < 0)
+ skiplen = 0;
+ PKTFREE (di->osh, p, FALSE);
+ continue;
+ }
+
+ len = ltoh16 (*(uint16 *) (PKTDATA (di->osh, p)));
+ DMA_TRACE (("%s: dma_rx len %d\n", di->name, len));
+
+ /* bad frame length check */
+ if (len > (di->rxbufsize - di->rxoffset))
+ {
+ DMA_ERROR (("%s: dma_rx: bad frame length (%d)\n", di->name, len));
+ if (len > 0)
+ skiplen = len - (di->rxbufsize - di->rxoffset);
+ PKTFREE (di->osh, p, FALSE);
+ di->hnddma.rxgiants++;
+ continue;
}
- return (p);
+ /* set actual length */
+ PKTSETLEN (di->osh, p, (di->rxoffset + len));
+
+ break;
+ }
+
+ return (p);
}
/* post receive buffers */
static void
-_dma_rxfill(dma_info_t *di)
-{
- void *p;
- uint rxin, rxout;
- uint32 flags = 0;
- uint n;
- uint i;
- uint32 pa;
- uint extra_offset = 0;
-
- /*
- * Determine how many receive buffers we're lacking
- * from the full complement, allocate, initialize,
- * and post them, then update the chip rx lastdscr.
- */
-
- rxin = di->rxin;
- rxout = di->rxout;
-
- n = di->nrxpost - NRXDACTIVE(rxin, rxout);
-
- DMA_TRACE(("%s: dma_rxfill: post %d\n", di->name, n));
-
- if (di->rxbufsize > BCMEXTRAHDROOM)
- extra_offset = BCMEXTRAHDROOM;
-
- for (i = 0; i < n; i++) {
- /* the di->rxbufsize doesn't include the extra headroom, we need to add it to the
- size to be allocated
- */
- if ((p = PKTGET(di->osh, di->rxbufsize + extra_offset,
- FALSE)) == NULL) {
- DMA_ERROR(("%s: dma_rxfill: out of rxbufs\n", di->name));
- di->hnddma.rxnobuf++;
- break;
- }
- /* reserve an extra headroom, if applicable */
- if (extra_offset)
- PKTPULL(di->osh, p, extra_offset);
-
- /* Do a cached write instead of uncached write since DMA_MAP
- * will flush the cache.
- */
- *(uint32*)(PKTDATA(di->osh, p)) = 0;
-
- pa = (uint32) DMA_MAP(di->osh, PKTDATA(di->osh, p),
- di->rxbufsize, DMA_RX, p);
-
- ASSERT(ISALIGNED(pa, 4));
-
- /* save the free packet pointer */
- ASSERT(di->rxp[rxout] == NULL);
- di->rxp[rxout] = p;
-
- /* reset flags for each descriptor */
- flags = 0;
- if (DMA64_ENAB(di)) {
- if (rxout == (di->nrxd - 1))
- flags = D64_CTRL1_EOT;
-
- dma64_dd_upd(di, di->rxd64, pa, rxout, &flags, di->rxbufsize);
- } else {
- if (rxout == (di->nrxd - 1))
- flags = CTRL_EOT;
-
- dma32_dd_upd(di, di->rxd32, pa, rxout, &flags, di->rxbufsize);
- }
- rxout = NEXTRXD(rxout);
+_dma_rxfill (dma_info_t * di)
+{
+ void *p;
+ uint rxin, rxout;
+ uint32 flags = 0;
+ uint n;
+ uint i;
+ uint32 pa;
+ uint extra_offset = 0;
+
+ /*
+ * Determine how many receive buffers we're lacking
+ * from the full complement, allocate, initialize,
+ * and post them, then update the chip rx lastdscr.
+ */
+
+ rxin = di->rxin;
+ rxout = di->rxout;
+
+ n = di->nrxpost - NRXDACTIVE (rxin, rxout);
+
+ DMA_TRACE (("%s: dma_rxfill: post %d\n", di->name, n));
+
+ if (di->rxbufsize > BCMEXTRAHDROOM)
+ extra_offset = BCMEXTRAHDROOM;
+
+ for (i = 0; i < n; i++)
+ {
+ /* the di->rxbufsize doesn't include the extra headroom, we need to add it to the
+ size to be allocated
+ */
+ if ((p = PKTGET (di->osh, di->rxbufsize + extra_offset, FALSE)) == NULL)
+ {
+ DMA_ERROR (("%s: dma_rxfill: out of rxbufs\n", di->name));
+ di->hnddma.rxnobuf++;
+ break;
}
+ /* reserve an extra headroom, if applicable */
+ if (extra_offset)
+ PKTPULL (di->osh, p, extra_offset);
- di->rxout = rxout;
+ /* Do a cached write instead of uncached write since DMA_MAP
+ * will flush the cache.
+ */
+ *(uint32 *) (PKTDATA (di->osh, p)) = 0;
- /* update the chip lastdscr pointer */
- if (DMA64_ENAB(di)) {
- W_REG(di->osh, &di->d64rxregs->ptr, I2B(rxout, dma64dd_t));
- } else {
- W_REG(di->osh, &di->d32rxregs->ptr, I2B(rxout, dma32dd_t));
- }
-}
+ pa = (uint32) DMA_MAP (di->osh, PKTDATA (di->osh, p),
+ di->rxbufsize, DMA_RX, p, &di->rxp_dmah[rxout]);
-/* like getnexttxp but no reclaim */
-static void *
-_dma_peeknexttxp(dma_info_t *di)
-{
- uint end, i;
+ ASSERT (ISALIGNED (pa, 4));
+
+ /* save the free packet pointer */
+ ASSERT (di->rxp[rxout] == NULL);
+ di->rxp[rxout] = p;
- if (di->ntxd == 0)
- return (NULL);
+ /* reset flags for each descriptor */
+ flags = 0;
+ if (DMA64_ENAB (di))
+ {
+ if (rxout == (di->nrxd - 1))
+ flags = D64_CTRL1_EOT;
- if (DMA64_ENAB(di)) {
- end = B2I(R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_CD_MASK, dma64dd_t);
- } else {
- end = B2I(R_REG(di->osh, &di->d32txregs->status) & XS_CD_MASK, dma32dd_t);
+ dma64_dd_upd (di, di->rxd64, pa, rxout, &flags, di->rxbufsize);
}
+ else
+ {
+ if (rxout == (di->nrxd - 1))
+ flags = CTRL_EOT;
- for (i = di->txin; i != end; i = NEXTTXD(i))
- if (di->txp[i])
- return (di->txp[i]);
+ dma32_dd_upd (di, di->rxd32, pa, rxout, &flags, di->rxbufsize);
+ }
+ rxout = NEXTRXD (rxout);
+ }
+
+ di->rxout = rxout;
+
+ /* update the chip lastdscr pointer */
+ if (DMA64_ENAB (di))
+ {
+ W_REG (di->osh, &di->d64rxregs->ptr, I2B (rxout, dma64dd_t));
+ }
+ else
+ {
+ W_REG (di->osh, &di->d32rxregs->ptr, I2B (rxout, dma32dd_t));
+ }
+}
- return (NULL);
+/* like getnexttxp but no reclaim */
+static void *
+_dma_peeknexttxp (dma_info_t * di)
+{
+ uint end, i;
+
+ if (di->ntxd == 0)
+ return (NULL);
+
+ if (DMA64_ENAB (di))
+ {
+ end =
+ B2I (R_REG (di->osh, &di->d64txregs->status0) & D64_XS0_CD_MASK,
+ dma64dd_t);
+ }
+ else
+ {
+ end =
+ B2I (R_REG (di->osh, &di->d32txregs->status) & XS_CD_MASK, dma32dd_t);
+ }
+
+ for (i = di->txin; i != end; i = NEXTTXD (i))
+ if (di->txp[i])
+ return (di->txp[i]);
+
+ return (NULL);
}
static void
-_dma_rxreclaim(dma_info_t *di)
+_dma_rxreclaim (dma_info_t * di)
{
- void *p;
+ void *p;
- /* "unused local" warning suppression for OSLs that
- * define PKTFREE() without using the di->osh arg
- */
- di = di;
+ /* "unused local" warning suppression for OSLs that
+ * define PKTFREE() without using the di->osh arg
+ */
+ di = di;
- DMA_TRACE(("%s: dma_rxreclaim\n", di->name));
+ DMA_TRACE (("%s: dma_rxreclaim\n", di->name));
- while ((p = _dma_getnextrxp(di, TRUE)))
- PKTFREE(di->osh, p, FALSE);
+ while ((p = _dma_getnextrxp (di, TRUE)))
+ PKTFREE (di->osh, p, FALSE);
}
static void *
-_dma_getnextrxp(dma_info_t *di, bool forceall)
+_dma_getnextrxp (dma_info_t * di, bool forceall)
{
- if (di->nrxd == 0)
- return (NULL);
-
- if (DMA64_ENAB(di)) {
- return dma64_getnextrxp(di, forceall);
- } else {
- return dma32_getnextrxp(di, forceall);
- }
+ if (di->nrxd == 0)
+ return (NULL);
+
+ if (DMA64_ENAB (di))
+ {
+ return dma64_getnextrxp (di, forceall);
+ }
+ else
+ {
+ return dma32_getnextrxp (di, forceall);
+ }
}
static void
-_dma_txblock(dma_info_t *di)
+_dma_txblock (dma_info_t * di)
{
- di->hnddma.txavail = 0;
+ di->hnddma.txavail = 0;
}
static void
-_dma_txunblock(dma_info_t *di)
+_dma_txunblock (dma_info_t * di)
{
- di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
+ di->hnddma.txavail = di->ntxd - NTXDACTIVE (di->txin, di->txout) - 1;
}
static uint
-_dma_txactive(dma_info_t *di)
+_dma_txactive (dma_info_t * di)
{
- return (NTXDACTIVE(di->txin, di->txout));
+ return (NTXDACTIVE (di->txin, di->txout));
}
static void
-_dma_counterreset(dma_info_t *di)
+_dma_counterreset (dma_info_t * di)
{
- /* reset all software counter */
- di->hnddma.rxgiants = 0;
- di->hnddma.rxnobuf = 0;
- di->hnddma.txnobuf = 0;
+ /* reset all software counter */
+ di->hnddma.rxgiants = 0;
+ di->hnddma.rxnobuf = 0;
+ di->hnddma.txnobuf = 0;
}
/* get the address of the var in order to change later */
static uintptr
-_dma_getvar(dma_info_t *di, const char *name)
+_dma_getvar (dma_info_t * di, const char *name)
{
- if (!strcmp(name, "&txavail"))
- return ((uintptr) &(di->hnddma.txavail));
- else {
- ASSERT(0);
- }
- return (0);
+ if (!strcmp (name, "&txavail"))
+ return ((uintptr) & (di->hnddma.txavail));
+ else
+ {
+ ASSERT (0);
+ }
+ return (0);
}
void
-dma_txpioloopback(osl_t *osh, dma32regs_t *regs)
+dma_txpioloopback (osl_t * osh, dma32regs_t * regs)
{
- OR_REG(osh, &regs->control, XC_LE);
+ OR_REG (osh, &regs->control, XC_LE);
}
+#ifdef BCMDBG
+static void
+dma32_dumpring (dma_info_t * di, struct bcmstrbuf *b, dma32dd_t * ring,
+ uint start, uint end, uint max_num)
+{
+ uint i;
+
+ for (i = start; i != end; i = XXD ((i + 1), max_num))
+ {
+ /* in the format of high->low 8 bytes */
+ bcm_bprintf (b, "ring index %d: 0x%x %x\n", i, ring[i].addr,
+ ring[i].ctrl);
+ }
+}
+
+static void
+dma32_dumptx (dma_info_t * di, struct bcmstrbuf *b, bool dumpring)
+{
+ if (di->ntxd == 0)
+ return;
+
+ bcm_bprintf (b, "DMA32: txd32 %p txdpa 0x%lx txp %p txin %d txout %d "
+ "txavail %d\n", di->txd32, di->txdpa, di->txp, di->txin,
+ di->txout, di->hnddma.txavail);
+
+ bcm_bprintf (b, "xmtcontrol 0x%x xmtaddr 0x%x xmtptr 0x%x xmtstatus 0x%x\n",
+ R_REG (di->osh, &di->d32txregs->control),
+ R_REG (di->osh, &di->d32txregs->addr),
+ R_REG (di->osh, &di->d32txregs->ptr),
+ R_REG (di->osh, &di->d32txregs->status));
+
+ if (dumpring && di->txd32)
+ dma32_dumpring (di, b, di->txd32, di->txin, di->txout, di->ntxd);
+}
+
+static void
+dma32_dumprx (dma_info_t * di, struct bcmstrbuf *b, bool dumpring)
+{
+ if (di->nrxd == 0)
+ return;
+
+ bcm_bprintf (b, "DMA32: rxd32 %p rxdpa 0x%lx rxp %p rxin %d rxout %d\n",
+ di->rxd32, di->rxdpa, di->rxp, di->rxin, di->rxout);
+
+ bcm_bprintf (b, "rcvcontrol 0x%x rcvaddr 0x%x rcvptr 0x%x rcvstatus 0x%x\n",
+ R_REG (di->osh, &di->d32rxregs->control),
+ R_REG (di->osh, &di->d32rxregs->addr),
+ R_REG (di->osh, &di->d32rxregs->ptr),
+ R_REG (di->osh, &di->d32rxregs->status));
+ if (di->rxd32 && dumpring)
+ dma32_dumpring (di, b, di->rxd32, di->rxin, di->rxout, di->nrxd);
+}
+
+static void
+dma32_dump (dma_info_t * di, struct bcmstrbuf *b, bool dumpring)
+{
+ dma32_dumptx (di, b, dumpring);
+ dma32_dumprx (di, b, dumpring);
+}
+
+static void
+dma64_dumpring (dma_info_t * di, struct bcmstrbuf *b, dma64dd_t * ring,
+ uint start, uint end, uint max_num)
+{
+ uint i;
+
+ for (i = start; i != end; i = XXD ((i + 1), max_num))
+ {
+ /* in the format of high->low 16 bytes */
+ bcm_bprintf (b, "ring index %d: 0x%x %x %x %x\n",
+ i, ring[i].addrhigh, ring[i].addrlow, ring[i].ctrl2,
+ ring[i].ctrl1);
+ }
+}
+
+static void
+dma64_dumptx (dma_info_t * di, struct bcmstrbuf *b, bool dumpring)
+{
+ if (di->ntxd == 0)
+ return;
+
+ bcm_bprintf (b, "DMA64: txd64 %p txdpa 0x%lx txp %p txin %d txout %d "
+ "txavail %d\n", di->txd64, di->txdpa, di->txp, di->txin,
+ di->txout, di->hnddma.txavail);
+
+ bcm_bprintf (b, "xmtcontrol 0x%x xmtaddrlow 0x%x xmtaddrhigh 0x%x "
+ "xmtptr 0x%x xmtstatus0 0x%x xmtstatus1 0x%x\n",
+ R_REG (di->osh, &di->d64txregs->control),
+ R_REG (di->osh, &di->d64txregs->addrlow),
+ R_REG (di->osh, &di->d64txregs->addrhigh),
+ R_REG (di->osh, &di->d64txregs->ptr),
+ R_REG (di->osh, &di->d64txregs->status0),
+ R_REG (di->osh, &di->d64txregs->status1));
+
+ if (dumpring && di->txd64)
+ {
+ dma64_dumpring (di, b, di->txd64, di->txin, di->txout, di->ntxd);
+ }
+}
+
+static void
+dma64_dumprx (dma_info_t * di, struct bcmstrbuf *b, bool dumpring)
+{
+ if (di->nrxd == 0)
+ return;
+
+ bcm_bprintf (b, "DMA64: rxd64 %p rxdpa 0x%lx rxp %p rxin %d rxout %d\n",
+ di->rxd64, di->rxdpa, di->rxp, di->rxin, di->rxout);
+
+ bcm_bprintf (b, "rcvcontrol 0x%x rcvaddrlow 0x%x rcvaddrhigh 0x%x rcvptr "
+ "0x%x rcvstatus0 0x%x rcvstatus1 0x%x\n",
+ R_REG (di->osh, &di->d64rxregs->control),
+ R_REG (di->osh, &di->d64rxregs->addrlow),
+ R_REG (di->osh, &di->d64rxregs->addrhigh),
+ R_REG (di->osh, &di->d64rxregs->ptr),
+ R_REG (di->osh, &di->d64rxregs->status0),
+ R_REG (di->osh, &di->d64rxregs->status1));
+ if (di->rxd64 && dumpring)
+ {
+ dma64_dumpring (di, b, di->rxd64, di->rxin, di->rxout, di->nrxd);
+ }
+}
+
+static void
+dma64_dump (dma_info_t * di, struct bcmstrbuf *b, bool dumpring)
+{
+ dma64_dumptx (di, b, dumpring);
+ dma64_dumprx (di, b, dumpring);
+}
+
+#endif /* BCMDBG */
/* 32 bits DMA functions */
static void
-dma32_txinit(dma_info_t *di)
+dma32_txinit (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_txinit\n", di->name));
+ DMA_TRACE (("%s: dma_txinit\n", di->name));
- if (di->ntxd == 0)
- return;
+ if (di->ntxd == 0)
+ return;
- di->txin = di->txout = 0;
- di->hnddma.txavail = di->ntxd - 1;
+ di->txin = di->txout = 0;
+ di->hnddma.txavail = di->ntxd - 1;
- /* clear tx descriptor ring */
- BZERO_SM((void *)(uintptr)di->txd32, (di->ntxd * sizeof(dma32dd_t)));
- W_REG(di->osh, &di->d32txregs->control, XC_XE);
- _dma_ddtable_init(di, DMA_TX, di->txdpa);
+ /* clear tx descriptor ring */
+ BZERO_SM ((void *) (uintptr) di->txd32, (di->ntxd * sizeof (dma32dd_t)));
+ W_REG (di->osh, &di->d32txregs->control, XC_XE);
+ _dma_ddtable_init (di, DMA_TX, di->txdpa);
}
static bool
-dma32_txenabled(dma_info_t *di)
+dma32_txenabled (dma_info_t * di)
{
- uint32 xc;
+ uint32 xc;
- /* If the chip is dead, it is not enabled :-) */
- xc = R_REG(di->osh, &di->d32txregs->control);
- return ((xc != 0xffffffff) && (xc & XC_XE));
+ /* If the chip is dead, it is not enabled :-) */
+ xc = R_REG (di->osh, &di->d32txregs->control);
+ return ((xc != 0xffffffff) && (xc & XC_XE));
}
static void
-dma32_txsuspend(dma_info_t *di)
+dma32_txsuspend (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_txsuspend\n", di->name));
+ DMA_TRACE (("%s: dma_txsuspend\n", di->name));
- if (di->ntxd == 0)
- return;
+ if (di->ntxd == 0)
+ return;
- OR_REG(di->osh, &di->d32txregs->control, XC_SE);
+ OR_REG (di->osh, &di->d32txregs->control, XC_SE);
}
static void
-dma32_txresume(dma_info_t *di)
+dma32_txresume (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_txresume\n", di->name));
+ DMA_TRACE (("%s: dma_txresume\n", di->name));
- if (di->ntxd == 0)
- return;
+ if (di->ntxd == 0)
+ return;
- AND_REG(di->osh, &di->d32txregs->control, ~XC_SE);
+ AND_REG (di->osh, &di->d32txregs->control, ~XC_SE);
}
static bool
-dma32_txsuspended(dma_info_t *di)
+dma32_txsuspended (dma_info_t * di)
{
- return (di->ntxd == 0) || ((R_REG(di->osh, &di->d32txregs->control) & XC_SE) == XC_SE);
+ return (di->ntxd == 0)
+ || ((R_REG (di->osh, &di->d32txregs->control) & XC_SE) == XC_SE);
}
static void
-dma32_txreclaim(dma_info_t *di, bool forceall)
+dma32_txreclaim (dma_info_t * di, bool forceall)
{
- void *p;
+ void *p;
- DMA_TRACE(("%s: dma_txreclaim %s\n", di->name, forceall ? "all" : ""));
+ DMA_TRACE (("%s: dma_txreclaim %s\n", di->name, forceall ? "all" : ""));
- while ((p = dma32_getnexttxp(di, forceall)))
- PKTFREE(di->osh, p, TRUE);
+ while ((p = dma32_getnexttxp (di, forceall)))
+ PKTFREE (di->osh, p, TRUE);
}
static bool
-dma32_txstopped(dma_info_t *di)
+dma32_txstopped (dma_info_t * di)
{
- return ((R_REG(di->osh, &di->d32txregs->status) & XS_XS_MASK) == XS_XS_STOPPED);
+ return ((R_REG (di->osh, &di->d32txregs->status) & XS_XS_MASK) ==
+ XS_XS_STOPPED);
}
static bool
-dma32_rxstopped(dma_info_t *di)
+dma32_rxstopped (dma_info_t * di)
{
- return ((R_REG(di->osh, &di->d32rxregs->status) & RS_RS_MASK) == RS_RS_STOPPED);
+ return ((R_REG (di->osh, &di->d32rxregs->status) & RS_RS_MASK) ==
+ RS_RS_STOPPED);
}
static bool
-dma32_alloc(dma_info_t *di, uint direction)
-{
- uint size;
- uint ddlen;
- void *va;
-
- ddlen = sizeof(dma32dd_t);
-
- size = (direction == DMA_TX) ? (di->ntxd * ddlen) : (di->nrxd * ddlen);
-
- if (!ISALIGNED(DMA_CONSISTENT_ALIGN, D32RINGALIGN))
- size += D32RINGALIGN;
-
-
- if (direction == DMA_TX) {
- if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->txdpa, &di->tx_dmah)) == NULL) {
- DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(ntxd) failed\n",
- di->name));
- return FALSE;
- }
-
- di->txd32 = (dma32dd_t *) ROUNDUP((uintptr)va, D32RINGALIGN);
- di->txdalign = (uint)((int8*)(uintptr)di->txd32 - (int8*)va);
- di->txdpa += di->txdalign;
- di->txdalloc = size;
- ASSERT(ISALIGNED((uintptr)di->txd32, D32RINGALIGN));
- } else {
- if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->rxdpa, &di->rx_dmah)) == NULL) {
- DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(nrxd) failed\n",
- di->name));
- return FALSE;
- }
- di->rxd32 = (dma32dd_t *) ROUNDUP((uintptr)va, D32RINGALIGN);
- di->rxdalign = (uint)((int8*)(uintptr)di->rxd32 - (int8*)va);
- di->rxdpa += di->rxdalign;
- di->rxdalloc = size;
- ASSERT(ISALIGNED((uintptr)di->rxd32, D32RINGALIGN));
+dma32_alloc (dma_info_t * di, uint direction)
+{
+ uint size;
+ uint ddlen;
+ void *va;
+
+ ddlen = sizeof (dma32dd_t);
+
+ size = (direction == DMA_TX) ? (di->ntxd * ddlen) : (di->nrxd * ddlen);
+
+ if (!ISALIGNED (DMA_CONSISTENT_ALIGN, D32RINGALIGN))
+ size += D32RINGALIGN;
+
+
+ if (direction == DMA_TX)
+ {
+ if ((va =
+ DMA_ALLOC_CONSISTENT (di->osh, size, &di->txdpa,
+ &di->tx_dmah)) == NULL)
+ {
+ DMA_ERROR (("%s: dma_attach: DMA_ALLOC_CONSISTENT(ntxd) failed\n",
+ di->name));
+ return FALSE;
}
- return TRUE;
+ di->txd32 = (dma32dd_t *) ROUNDUP ((uintptr) va, D32RINGALIGN);
+ di->txdalign = (uint) ((int8 *) (uintptr) di->txd32 - (int8 *) va);
+ di->txdpa += di->txdalign;
+ di->txdalloc = size;
+ ASSERT (ISALIGNED ((uintptr) di->txd32, D32RINGALIGN));
+ }
+ else
+ {
+ if ((va =
+ DMA_ALLOC_CONSISTENT (di->osh, size, &di->rxdpa,
+ &di->rx_dmah)) == NULL)
+ {
+ DMA_ERROR (("%s: dma_attach: DMA_ALLOC_CONSISTENT(nrxd) failed\n",
+ di->name));
+ return FALSE;
+ }
+ di->rxd32 = (dma32dd_t *) ROUNDUP ((uintptr) va, D32RINGALIGN);
+ di->rxdalign = (uint) ((int8 *) (uintptr) di->rxd32 - (int8 *) va);
+ di->rxdpa += di->rxdalign;
+ di->rxdalloc = size;
+ ASSERT (ISALIGNED ((uintptr) di->rxd32, D32RINGALIGN));
+ }
+
+ return TRUE;
}
static bool
-dma32_txreset(dma_info_t *di)
+dma32_txreset (dma_info_t * di)
{
- uint32 status;
+ uint32 status;
- if (di->ntxd == 0)
- return TRUE;
+ if (di->ntxd == 0)
+ return TRUE;
- /* suspend tx DMA first */
- W_REG(di->osh, &di->d32txregs->control, XC_SE);
- SPINWAIT(((status = (R_REG(di->osh, &di->d32txregs->status) & XS_XS_MASK))
- != XS_XS_DISABLED) &&
- (status != XS_XS_IDLE) &&
- (status != XS_XS_STOPPED),
- (10000));
+ /* suspend tx DMA first */
+ W_REG (di->osh, &di->d32txregs->control, XC_SE);
+ SPINWAIT (((status = (R_REG (di->osh, &di->d32txregs->status) & XS_XS_MASK))
+ != XS_XS_DISABLED) &&
+ (status != XS_XS_IDLE) && (status != XS_XS_STOPPED), (10000));
- W_REG(di->osh, &di->d32txregs->control, 0);
- SPINWAIT(((status = (R_REG(di->osh,
- &di->d32txregs->status) & XS_XS_MASK)) != XS_XS_DISABLED),
- 10000);
+ W_REG (di->osh, &di->d32txregs->control, 0);
+ SPINWAIT (((status = (R_REG (di->osh,
+ &di->d32txregs->status) & XS_XS_MASK)) !=
+ XS_XS_DISABLED), 10000);
- /* wait for the last transaction to complete */
- OSL_DELAY(300);
+ /* wait for the last transaction to complete */
+ OSL_DELAY (300);
- return (status == XS_XS_DISABLED);
+ return (status == XS_XS_DISABLED);
}
static bool
-dma32_rxidle(dma_info_t *di)
+dma32_rxidle (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_rxidle\n", di->name));
+ DMA_TRACE (("%s: dma_rxidle\n", di->name));
- if (di->nrxd == 0)
- return TRUE;
+ if (di->nrxd == 0)
+ return TRUE;
- return ((R_REG(di->osh, &di->d32rxregs->status) & RS_CD_MASK) ==
- R_REG(di->osh, &di->d32rxregs->ptr));
+ return ((R_REG (di->osh, &di->d32rxregs->status) & RS_CD_MASK) ==
+ R_REG (di->osh, &di->d32rxregs->ptr));
}
static bool
-dma32_rxreset(dma_info_t *di)
+dma32_rxreset (dma_info_t * di)
{
- uint32 status;
+ uint32 status;
- if (di->nrxd == 0)
- return TRUE;
+ if (di->nrxd == 0)
+ return TRUE;
- W_REG(di->osh, &di->d32rxregs->control, 0);
- SPINWAIT(((status = (R_REG(di->osh,
- &di->d32rxregs->status) & RS_RS_MASK)) != RS_RS_DISABLED),
- 10000);
+ W_REG (di->osh, &di->d32rxregs->control, 0);
+ SPINWAIT (((status = (R_REG (di->osh,
+ &di->d32rxregs->status) & RS_RS_MASK)) !=
+ RS_RS_DISABLED), 10000);
- return (status == RS_RS_DISABLED);
+ return (status == RS_RS_DISABLED);
}
static bool
-dma32_rxenabled(dma_info_t *di)
+dma32_rxenabled (dma_info_t * di)
{
- uint32 rc;
+ uint32 rc;
- rc = R_REG(di->osh, &di->d32rxregs->control);
- return ((rc != 0xffffffff) && (rc & RC_RE));
+ rc = R_REG (di->osh, &di->d32rxregs->control);
+ return ((rc != 0xffffffff) && (rc & RC_RE));
}
static bool
-dma32_txsuspendedidle(dma_info_t *di)
+dma32_txsuspendedidle (dma_info_t * di)
{
- if (di->ntxd == 0)
- return TRUE;
+ if (di->ntxd == 0)
+ return TRUE;
- if (!(R_REG(di->osh, &di->d32txregs->control) & XC_SE))
- return 0;
+ if (!(R_REG (di->osh, &di->d32txregs->control) & XC_SE))
+ return 0;
- if ((R_REG(di->osh, &di->d32txregs->status) & XS_XS_MASK) != XS_XS_IDLE)
- return 0;
+ if ((R_REG (di->osh, &di->d32txregs->status) & XS_XS_MASK) != XS_XS_IDLE)
+ return 0;
- OSL_DELAY(2);
- return ((R_REG(di->osh, &di->d32txregs->status) & XS_XS_MASK) == XS_XS_IDLE);
+ OSL_DELAY (2);
+ return ((R_REG (di->osh, &di->d32txregs->status) & XS_XS_MASK) ==
+ XS_XS_IDLE);
}
/* !! tx entry routine
@@ -1171,77 +1518,81 @@ dma32_txsuspendedidle(dma_info_t *di)
* dma buffers can cross 4 Kbyte page boundaries.
*/
static int
-dma32_txfast(dma_info_t *di, void *p0, bool commit)
-{
- void *p, *next;
- uchar *data;
- uint len;
- uint txout;
- uint32 flags = 0;
- uint32 pa;
-
- DMA_TRACE(("%s: dma_txfast\n", di->name));
-
- txout = di->txout;
-
- /*
- * Walk the chain of packet buffers
- * allocating and initializing transmit descriptor entries.
- */
- for (p = p0; p; p = next) {
- data = PKTDATA(di->osh, p);
- len = PKTLEN(di->osh, p);
- next = PKTNEXT(di->osh, p);
-
- /* return nonzero if out of tx descriptors */
- if (NEXTTXD(txout) == di->txin)
- goto outoftxd;
-
- if (len == 0)
- continue;
-
- /* get physical address of buffer start */
- pa = (uint32) DMA_MAP(di->osh, data, len, DMA_TX, p);
-
- flags = 0;
- if (p == p0)
- flags |= CTRL_SOF;
- if (next == NULL)
- flags |= (CTRL_IOC | CTRL_EOF);
- if (txout == (di->ntxd - 1))
- flags |= CTRL_EOT;
-
- dma32_dd_upd(di, di->txd32, pa, txout, &flags, len);
- ASSERT(di->txp[txout] == NULL);
-
- txout = NEXTTXD(txout);
- }
+dma32_txfast (dma_info_t * di, void *p0, bool commit)
+{
+ void *p, *next;
+ uchar *data;
+ uint len;
+ uint txout;
+ uint32 flags = 0;
+ uint32 pa;
+
+ DMA_TRACE (("%s: dma_txfast\n", di->name));
+
+ txout = di->txout;
+
+ /*
+ * Walk the chain of packet buffers
+ * allocating and initializing transmit descriptor entries.
+ */
+ for (p = p0; p; p = next)
+ {
+ data = PKTDATA (di->osh, p);
+ len = PKTLEN (di->osh, p);
+ next = PKTNEXT (di->osh, p);
+
+ /* return nonzero if out of tx descriptors */
+ if (NEXTTXD (txout) == di->txin)
+ goto outoftxd;
+
+ if (len == 0)
+ continue;
+
+ /* get physical address of buffer start */
+ pa =
+ (uint32) DMA_MAP (di->osh, data, len, DMA_TX, p,
+ &di->txp_dmah[txout]);
+
+ flags = 0;
+ if (p == p0)
+ flags |= CTRL_SOF;
+ if (next == NULL)
+ flags |= (CTRL_IOC | CTRL_EOF);
+ if (txout == (di->ntxd - 1))
+ flags |= CTRL_EOT;
- /* if last txd eof not set, fix it */
- if (!(flags & CTRL_EOF))
- W_SM(&di->txd32[PREVTXD(txout)].ctrl, BUS_SWAP32(flags | CTRL_IOC | CTRL_EOF));
+ dma32_dd_upd (di, di->txd32, pa, txout, &flags, len);
+ ASSERT (di->txp[txout] == NULL);
- /* save the packet */
- di->txp[PREVTXD(txout)] = p0;
+ txout = NEXTTXD (txout);
+ }
- /* bump the tx descriptor index */
- di->txout = txout;
+ /* if last txd eof not set, fix it */
+ if (!(flags & CTRL_EOF))
+ W_SM (&di->txd32[PREVTXD (txout)].ctrl,
+ BUS_SWAP32 (flags | CTRL_IOC | CTRL_EOF));
- /* kick the chip */
- if (commit)
- W_REG(di->osh, &di->d32txregs->ptr, I2B(txout, dma32dd_t));
+ /* save the packet */
+ di->txp[PREVTXD (txout)] = p0;
- /* tx flow control */
- di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
+ /* bump the tx descriptor index */
+ di->txout = txout;
- return (0);
+ /* kick the chip */
+ if (commit)
+ W_REG (di->osh, &di->d32txregs->ptr, I2B (txout, dma32dd_t));
+
+ /* tx flow control */
+ di->hnddma.txavail = di->ntxd - NTXDACTIVE (di->txin, di->txout) - 1;
+
+ return (0);
outoftxd:
- DMA_ERROR(("%s: dma_txfast: out of txds\n", di->name));
- PKTFREE(di->osh, p0, TRUE);
- di->hnddma.txavail = 0;
- di->hnddma.txnobuf++;
- return (-1);
+ DMA_ERROR (("%s: dma_txfast: out of txds\n", di->name));
+ PKTFREE (di->osh, p0, TRUE);
+ di->hnddma.txavail = 0;
+ di->hnddma.txnobuf++;
+ return (-1);
}
/*
@@ -1251,431 +1602,456 @@ outoftxd:
* regardless of the value of the hardware "curr" pointer.
*/
static void *
-dma32_getnexttxp(dma_info_t *di, bool forceall)
+dma32_getnexttxp (dma_info_t * di, bool forceall)
{
- uint start, end, i;
- void *txp;
+ uint start, end, i;
+ void *txp;
- DMA_TRACE(("%s: dma_getnexttxp %s\n", di->name, forceall ? "all" : ""));
+ DMA_TRACE (("%s: dma_getnexttxp %s\n", di->name, forceall ? "all" : ""));
- if (di->ntxd == 0)
- return (NULL);
+ if (di->ntxd == 0)
+ return (NULL);
- txp = NULL;
+ txp = NULL;
- start = di->txin;
- if (forceall)
- end = di->txout;
- else
- end = B2I(R_REG(di->osh, &di->d32txregs->status) & XS_CD_MASK, dma32dd_t);
+ start = di->txin;
+ if (forceall)
+ end = di->txout;
+ else
+ end =
+ B2I (R_REG (di->osh, &di->d32txregs->status) & XS_CD_MASK, dma32dd_t);
- if ((start == 0) && (end > di->txout))
- goto bogus;
+ if ((start == 0) && (end > di->txout))
+ goto bogus;
- for (i = start; i != end && !txp; i = NEXTTXD(i)) {
- DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->txd32[i].addr)) - di->dataoffsetlow),
- (BUS_SWAP32(R_SM(&di->txd32[i].ctrl)) & CTRL_BC_MASK),
- DMA_TX, di->txp[i]);
+ for (i = start; i != end && !txp; i = NEXTTXD (i))
+ {
+ DMA_UNMAP (di->osh,
+ (BUS_SWAP32 (R_SM (&di->txd32[i].addr)) - di->dataoffsetlow),
+ (BUS_SWAP32 (R_SM (&di->txd32[i].ctrl)) & CTRL_BC_MASK),
+ DMA_TX, di->txp[i], &di->txp_dmah[i]);
- W_SM(&di->txd32[i].addr, 0xdeadbeef);
- txp = di->txp[i];
- di->txp[i] = NULL;
- }
+ W_SM (&di->txd32[i].addr, 0xdeadbeef);
+ txp = di->txp[i];
+ di->txp[i] = NULL;
+ }
- di->txin = i;
+ di->txin = i;
- /* tx flow control */
- di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
+ /* tx flow control */
+ di->hnddma.txavail = di->ntxd - NTXDACTIVE (di->txin, di->txout) - 1;
- return (txp);
+ return (txp);
bogus:
/*
DMA_ERROR(("dma_getnexttxp: bogus curr: start %d end %d txout %d force %d\n",
start, end, di->txout, forceall));
*/
- return (NULL);
+ return (NULL);
}
static void *
-dma32_getnextrxp(dma_info_t *di, bool forceall)
+dma32_getnextrxp (dma_info_t * di, bool forceall)
{
- uint i;
- void *rxp;
+ uint i;
+ void *rxp;
- /* if forcing, dma engine must be disabled */
- ASSERT(!forceall || !dma32_rxenabled(di));
+ /* if forcing, dma engine must be disabled */
+ ASSERT (!forceall || !dma32_rxenabled (di));
- i = di->rxin;
+ i = di->rxin;
- /* return if no packets posted */
- if (i == di->rxout)
- return (NULL);
+ /* return if no packets posted */
+ if (i == di->rxout)
+ return (NULL);
- /* ignore curr if forceall */
- if (!forceall && (i == B2I(R_REG(di->osh, &di->d32rxregs->status) & RS_CD_MASK, dma32dd_t)))
- return (NULL);
+ /* ignore curr if forceall */
+ if (!forceall
+ && (i ==
+ B2I (R_REG (di->osh, &di->d32rxregs->status) & RS_CD_MASK,
+ dma32dd_t)))
+ return (NULL);
- /* get the packet pointer that corresponds to the rx descriptor */
- rxp = di->rxp[i];
- ASSERT(rxp);
- di->rxp[i] = NULL;
+ /* get the packet pointer that corresponds to the rx descriptor */
+ rxp = di->rxp[i];
+ ASSERT (rxp);
+ di->rxp[i] = NULL;
- /* clear this packet from the descriptor ring */
- DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->rxd32[i].addr)) - di->dataoffsetlow),
- di->rxbufsize, DMA_RX, rxp);
+ /* clear this packet from the descriptor ring */
+ DMA_UNMAP (di->osh,
+ (BUS_SWAP32 (R_SM (&di->rxd32[i].addr)) - di->dataoffsetlow),
+ di->rxbufsize, DMA_RX, rxp, &di->rxp_dmah[i]);
- W_SM(&di->rxd32[i].addr, 0xdeadbeef);
+ W_SM (&di->rxd32[i].addr, 0xdeadbeef);
- di->rxin = NEXTRXD(i);
+ di->rxin = NEXTRXD (i);
- return (rxp);
+ return (rxp);
}
/*
* Rotate all active tx dma ring entries "forward" by (ActiveDescriptor - txin).
*/
static void
-dma32_txrotate(dma_info_t *di)
+dma32_txrotate (dma_info_t * di)
{
- uint ad;
- uint nactive;
- uint rot;
- uint old, new;
- uint32 w;
- uint first, last;
-
- ASSERT(dma32_txsuspendedidle(di));
-
- nactive = _dma_txactive(di);
- ad = B2I(((R_REG(di->osh, &di->d32txregs->status) & XS_AD_MASK) >> XS_AD_SHIFT), dma32dd_t);
- rot = TXD(ad - di->txin);
-
- ASSERT(rot < di->ntxd);
-
- /* full-ring case is a lot harder - don't worry about this */
- if (rot >= (di->ntxd - nactive)) {
- DMA_ERROR(("%s: dma_txrotate: ring full - punt\n", di->name));
- return;
- }
-
- first = di->txin;
- last = PREVTXD(di->txout);
-
- /* move entries starting at last and moving backwards to first */
- for (old = last; old != PREVTXD(first); old = PREVTXD(old)) {
- new = TXD(old + rot);
-
- /*
- * Move the tx dma descriptor.
- * EOT is set only in the last entry in the ring.
- */
- w = BUS_SWAP32(R_SM(&di->txd32[old].ctrl)) & ~CTRL_EOT;
- if (new == (di->ntxd - 1))
- w |= CTRL_EOT;
- W_SM(&di->txd32[new].ctrl, BUS_SWAP32(w));
- W_SM(&di->txd32[new].addr, R_SM(&di->txd32[old].addr));
-
- /* zap the old tx dma descriptor address field */
- W_SM(&di->txd32[old].addr, BUS_SWAP32(0xdeadbeef));
-
- /* move the corresponding txp[] entry */
- ASSERT(di->txp[new] == NULL);
- di->txp[new] = di->txp[old];
- di->txp[old] = NULL;
- }
-
- /* update txin and txout */
- di->txin = ad;
- di->txout = TXD(di->txout + rot);
- di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
-
- /* kick the chip */
- W_REG(di->osh, &di->d32txregs->ptr, I2B(di->txout, dma32dd_t));
+ uint ad;
+ uint nactive;
+ uint rot;
+ uint old, new;
+ uint32 w;
+ uint first, last;
+
+ ASSERT (dma32_txsuspendedidle (di));
+
+ nactive = _dma_txactive (di);
+ ad =
+ B2I (((R_REG (di->osh, &di->d32txregs->status) & XS_AD_MASK) >>
+ XS_AD_SHIFT), dma32dd_t);
+ rot = TXD (ad - di->txin);
+
+ ASSERT (rot < di->ntxd);
+
+ /* full-ring case is a lot harder - don't worry about this */
+ if (rot >= (di->ntxd - nactive))
+ {
+ DMA_ERROR (("%s: dma_txrotate: ring full - punt\n", di->name));
+ return;
+ }
+
+ first = di->txin;
+ last = PREVTXD (di->txout);
+
+ /* move entries starting at last and moving backwards to first */
+ for (old = last; old != PREVTXD (first); old = PREVTXD (old))
+ {
+ new = TXD (old + rot);
+
+ /*
+ * Move the tx dma descriptor.
+ * EOT is set only in the last entry in the ring.
+ */
+ w = BUS_SWAP32 (R_SM (&di->txd32[old].ctrl)) & ~CTRL_EOT;
+ if (new == (di->ntxd - 1))
+ w |= CTRL_EOT;
+ W_SM (&di->txd32[new].ctrl, BUS_SWAP32 (w));
+ W_SM (&di->txd32[new].addr, R_SM (&di->txd32[old].addr));
+
+ /* zap the old tx dma descriptor address field */
+ W_SM (&di->txd32[old].addr, BUS_SWAP32 (0xdeadbeef));
+
+ /* move the corresponding txp[] entry */
+ ASSERT (di->txp[new] == NULL);
+ di->txp[new] = di->txp[old];
+ di->txp[old] = NULL;
+ }
+
+ /* update txin and txout */
+ di->txin = ad;
+ di->txout = TXD (di->txout + rot);
+ di->hnddma.txavail = di->ntxd - NTXDACTIVE (di->txin, di->txout) - 1;
+
+ /* kick the chip */
+ W_REG (di->osh, &di->d32txregs->ptr, I2B (di->txout, dma32dd_t));
}
/* 64 bits DMA functions */
#ifdef BCMDMA64
static void
-dma64_txinit(dma_info_t *di)
+dma64_txinit (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_txinit\n", di->name));
+ DMA_TRACE (("%s: dma_txinit\n", di->name));
- if (di->ntxd == 0)
- return;
+ if (di->ntxd == 0)
+ return;
- di->txin = di->txout = 0;
- di->hnddma.txavail = di->ntxd - 1;
+ di->txin = di->txout = 0;
+ di->hnddma.txavail = di->ntxd - 1;
- /* clear tx descriptor ring */
- BZERO_SM((void *)(uintptr)di->txd64, (di->ntxd * sizeof(dma64dd_t)));
- W_REG(di->osh, &di->d64txregs->control, D64_XC_XE);
- _dma_ddtable_init(di, DMA_TX, di->txdpa);
+ /* clear tx descriptor ring */
+ BZERO_SM ((void *) (uintptr) di->txd64, (di->ntxd * sizeof (dma64dd_t)));
+ W_REG (di->osh, &di->d64txregs->control, D64_XC_XE);
+ _dma_ddtable_init (di, DMA_TX, di->txdpa);
}
static bool
-dma64_txenabled(dma_info_t *di)
+dma64_txenabled (dma_info_t * di)
{
- uint32 xc;
+ uint32 xc;
- /* If the chip is dead, it is not enabled :-) */
- xc = R_REG(di->osh, &di->d64txregs->control);
- return ((xc != 0xffffffff) && (xc & D64_XC_XE));
+ /* If the chip is dead, it is not enabled :-) */
+ xc = R_REG (di->osh, &di->d64txregs->control);
+ return ((xc != 0xffffffff) && (xc & D64_XC_XE));
}
static void
-dma64_txsuspend(dma_info_t *di)
+dma64_txsuspend (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_txsuspend\n", di->name));
+ DMA_TRACE (("%s: dma_txsuspend\n", di->name));
- if (di->ntxd == 0)
- return;
+ if (di->ntxd == 0)
+ return;
- OR_REG(di->osh, &di->d64txregs->control, D64_XC_SE);
+ OR_REG (di->osh, &di->d64txregs->control, D64_XC_SE);
}
static void
-dma64_txresume(dma_info_t *di)
+dma64_txresume (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_txresume\n", di->name));
+ DMA_TRACE (("%s: dma_txresume\n", di->name));
- if (di->ntxd == 0)
- return;
+ if (di->ntxd == 0)
+ return;
- AND_REG(di->osh, &di->d64txregs->control, ~D64_XC_SE);
+ AND_REG (di->osh, &di->d64txregs->control, ~D64_XC_SE);
}
static bool
-dma64_txsuspended(dma_info_t *di)
+dma64_txsuspended (dma_info_t * di)
{
- return (di->ntxd == 0) || ((R_REG(di->osh, &di->d64txregs->control) & D64_XC_SE)
- == D64_XC_SE);
+ return (di->ntxd == 0)
+ || ((R_REG (di->osh, &di->d64txregs->control) & D64_XC_SE) == D64_XC_SE);
}
static void
-dma64_txreclaim(dma_info_t *di, bool forceall)
+dma64_txreclaim (dma_info_t * di, bool forceall)
{
- void *p;
+ void *p;
- DMA_TRACE(("%s: dma_txreclaim %s\n", di->name, forceall ? "all" : ""));
+ DMA_TRACE (("%s: dma_txreclaim %s\n", di->name, forceall ? "all" : ""));
- while ((p = dma64_getnexttxp(di, forceall)))
- PKTFREE(di->osh, p, TRUE);
+ while ((p = dma64_getnexttxp (di, forceall)))
+ PKTFREE (di->osh, p, TRUE);
}
static bool
-dma64_txstopped(dma_info_t *di)
+dma64_txstopped (dma_info_t * di)
{
- return ((R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK) == D64_XS0_XS_STOPPED);
+ return ((R_REG (di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK) ==
+ D64_XS0_XS_STOPPED);
}
static bool
-dma64_rxstopped(dma_info_t *di)
+dma64_rxstopped (dma_info_t * di)
{
- return ((R_REG(di->osh, &di->d64rxregs->status0) & D64_RS0_RS_MASK) == D64_RS0_RS_STOPPED);
+ return ((R_REG (di->osh, &di->d64rxregs->status0) & D64_RS0_RS_MASK) ==
+ D64_RS0_RS_STOPPED);
}
static bool
-dma64_alloc(dma_info_t *di, uint direction)
-{
- uint size;
- uint ddlen;
- uint32 alignbytes;
- void *va;
-
- ddlen = sizeof(dma64dd_t);
-
- size = (direction == DMA_TX) ? (di->ntxd * ddlen) : (di->nrxd * ddlen);
-
- alignbytes = di->dma64align;
-
- if (!ISALIGNED(DMA_CONSISTENT_ALIGN, alignbytes))
- size += alignbytes;
-
- if (direction == DMA_TX) {
- if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->txdpa, &di->tx_dmah)) == NULL) {
- DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(ntxd) failed\n",
- di->name));
- return FALSE;
- }
-
- di->txd64 = (dma64dd_t *) ROUNDUP((uintptr)va, alignbytes);
- di->txdalign = (uint)((int8*)(uintptr)di->txd64 - (int8*)va);
- di->txdpa += di->txdalign;
- di->txdalloc = size;
- ASSERT(ISALIGNED((uintptr)di->txd64, alignbytes));
- } else {
- if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->rxdpa, &di->rx_dmah)) == NULL) {
- DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(nrxd) failed\n",
- di->name));
- return FALSE;
- }
- di->rxd64 = (dma64dd_t *) ROUNDUP((uintptr)va, alignbytes);
- di->rxdalign = (uint)((int8*)(uintptr)di->rxd64 - (int8*)va);
- di->rxdpa += di->rxdalign;
- di->rxdalloc = size;
- ASSERT(ISALIGNED((uintptr)di->rxd64, alignbytes));
+dma64_alloc (dma_info_t * di, uint direction)
+{
+ uint size;
+ uint ddlen;
+ uint32 alignbytes;
+ void *va;
+
+ ddlen = sizeof (dma64dd_t);
+
+ size = (direction == DMA_TX) ? (di->ntxd * ddlen) : (di->nrxd * ddlen);
+
+ alignbytes = di->dma64align;
+
+ if (!ISALIGNED (DMA_CONSISTENT_ALIGN, alignbytes))
+ size += alignbytes;
+
+ if (direction == DMA_TX)
+ {
+ if ((va =
+ DMA_ALLOC_CONSISTENT (di->osh, size, &di->txdpa,
+ &di->tx_dmah)) == NULL)
+ {
+ DMA_ERROR (("%s: dma_attach: DMA_ALLOC_CONSISTENT(ntxd) failed\n",
+ di->name));
+ return FALSE;
}
- return TRUE;
+ di->txd64 = (dma64dd_t *) ROUNDUP ((uintptr) va, alignbytes);
+ di->txdalign = (uint) ((int8 *) (uintptr) di->txd64 - (int8 *) va);
+ di->txdpa += di->txdalign;
+ di->txdalloc = size;
+ ASSERT (ISALIGNED ((uintptr) di->txd64, alignbytes));
+ }
+ else
+ {
+ if ((va =
+ DMA_ALLOC_CONSISTENT (di->osh, size, &di->rxdpa,
+ &di->rx_dmah)) == NULL)
+ {
+ DMA_ERROR (("%s: dma_attach: DMA_ALLOC_CONSISTENT(nrxd) failed\n",
+ di->name));
+ return FALSE;
+ }
+ di->rxd64 = (dma64dd_t *) ROUNDUP ((uintptr) va, alignbytes);
+ di->rxdalign = (uint) ((int8 *) (uintptr) di->rxd64 - (int8 *) va);
+ di->rxdpa += di->rxdalign;
+ di->rxdalloc = size;
+ ASSERT (ISALIGNED ((uintptr) di->rxd64, alignbytes));
+ }
+
+ return TRUE;
}
static bool
-dma64_txreset(dma_info_t *di)
+dma64_txreset (dma_info_t * di)
{
- uint32 status;
+ uint32 status;
- if (di->ntxd == 0)
- return TRUE;
+ if (di->ntxd == 0)
+ return TRUE;
- /* suspend tx DMA first */
- W_REG(di->osh, &di->d64txregs->control, D64_XC_SE);
- SPINWAIT(((status = (R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK)) !=
- D64_XS0_XS_DISABLED) &&
- (status != D64_XS0_XS_IDLE) &&
- (status != D64_XS0_XS_STOPPED),
- 10000);
+ /* suspend tx DMA first */
+ W_REG (di->osh, &di->d64txregs->control, D64_XC_SE);
+ SPINWAIT (((status =
+ (R_REG (di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK)) !=
+ D64_XS0_XS_DISABLED) && (status != D64_XS0_XS_IDLE)
+ && (status != D64_XS0_XS_STOPPED), 10000);
- W_REG(di->osh, &di->d64txregs->control, 0);
- SPINWAIT(((status = (R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK)) !=
- D64_XS0_XS_DISABLED),
- 10000);
+ W_REG (di->osh, &di->d64txregs->control, 0);
+ SPINWAIT (((status =
+ (R_REG (di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK)) !=
+ D64_XS0_XS_DISABLED), 10000);
- /* wait for the last transaction to complete */
- OSL_DELAY(300);
+ /* wait for the last transaction to complete */
+ OSL_DELAY (300);
- return (status == D64_XS0_XS_DISABLED);
+ return (status == D64_XS0_XS_DISABLED);
}
static bool
-dma64_rxidle(dma_info_t *di)
+dma64_rxidle (dma_info_t * di)
{
- DMA_TRACE(("%s: dma_rxidle\n", di->name));
+ DMA_TRACE (("%s: dma_rxidle\n", di->name));
- if (di->nrxd == 0)
- return TRUE;
+ if (di->nrxd == 0)
+ return TRUE;
- return ((R_REG(di->osh, &di->d64rxregs->status0) & D64_RS0_CD_MASK) ==
- R_REG(di->osh, &di->d64rxregs->ptr));
+ return ((R_REG (di->osh, &di->d64rxregs->status0) & D64_RS0_CD_MASK) ==
+ R_REG (di->osh, &di->d64rxregs->ptr));
}
static bool
-dma64_rxreset(dma_info_t *di)
+dma64_rxreset (dma_info_t * di)
{
- uint32 status;
+ uint32 status;
- if (di->nrxd == 0)
- return TRUE;
+ if (di->nrxd == 0)
+ return TRUE;
- W_REG(di->osh, &di->d64rxregs->control, 0);
- SPINWAIT(((status = (R_REG(di->osh, &di->d64rxregs->status0) & D64_RS0_RS_MASK)) !=
- D64_RS0_RS_DISABLED),
- 10000);
+ W_REG (di->osh, &di->d64rxregs->control, 0);
+ SPINWAIT (((status =
+ (R_REG (di->osh, &di->d64rxregs->status0) & D64_RS0_RS_MASK)) !=
+ D64_RS0_RS_DISABLED), 10000);
- return (status == D64_RS0_RS_DISABLED);
+ return (status == D64_RS0_RS_DISABLED);
}
static bool
-dma64_rxenabled(dma_info_t *di)
+dma64_rxenabled (dma_info_t * di)
{
- uint32 rc;
+ uint32 rc;
- rc = R_REG(di->osh, &di->d64rxregs->control);
- return ((rc != 0xffffffff) && (rc & D64_RC_RE));
+ rc = R_REG (di->osh, &di->d64rxregs->control);
+ return ((rc != 0xffffffff) && (rc & D64_RC_RE));
}
static bool
-dma64_txsuspendedidle(dma_info_t *di)
+dma64_txsuspendedidle (dma_info_t * di)
{
- if (di->ntxd == 0)
- return TRUE;
+ if (di->ntxd == 0)
+ return TRUE;
- if (!(R_REG(di->osh, &di->d64txregs->control) & D64_XC_SE))
- return 0;
+ if (!(R_REG (di->osh, &di->d64txregs->control) & D64_XC_SE))
+ return 0;
- if ((R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK) == D64_XS0_XS_IDLE)
- return 1;
+ if ((R_REG (di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK) ==
+ D64_XS0_XS_IDLE)
+ return 1;
- return 0;
+ return 0;
}
/* !! tx entry routine */
static int
-dma64_txfast(dma_info_t *di, void *p0, bool commit)
-{
- void *p, *next;
- uchar *data;
- uint len;
- uint txout;
- uint32 flags = 0;
- uint32 pa;
-
- DMA_TRACE(("%s: dma_txfast\n", di->name));
-
- txout = di->txout;
-
- /*
- * Walk the chain of packet buffers
- * allocating and initializing transmit descriptor entries.
- */
- for (p = p0; p; p = next) {
- data = PKTDATA(di->osh, p);
- len = PKTLEN(di->osh, p);
- next = PKTNEXT(di->osh, p);
-
- /* return nonzero if out of tx descriptors */
- if (NEXTTXD(txout) == di->txin)
- goto outoftxd;
-
- if (len == 0)
- continue;
-
- /* get physical address of buffer start */
- pa = (uint32) DMA_MAP(di->osh, data, len, DMA_TX, p);
-
- flags = 0;
- if (p == p0)
- flags |= D64_CTRL1_SOF;
- if (next == NULL)
- flags |= (D64_CTRL1_IOC | D64_CTRL1_EOF);
- if (txout == (di->ntxd - 1))
- flags |= D64_CTRL1_EOT;
-
- dma64_dd_upd(di, di->txd64, pa, txout, &flags, len);
- ASSERT(di->txp[txout] == NULL);
-
- txout = NEXTTXD(txout);
- }
+dma64_txfast (dma_info_t * di, void *p0, bool commit)
+{
+ void *p, *next;
+ uchar *data;
+ uint len;
+ uint txout;
+ uint32 flags = 0;
+ uint32 pa;
- /* if last txd eof not set, fix it */
- if (!(flags & D64_CTRL1_EOF))
- W_SM(&di->txd64[PREVTXD(txout)].ctrl1,
- BUS_SWAP32(flags | D64_CTRL1_IOC | D64_CTRL1_EOF));
+ DMA_TRACE (("%s: dma_txfast\n", di->name));
- /* save the packet */
- di->txp[PREVTXD(txout)] = p0;
+ txout = di->txout;
- /* bump the tx descriptor index */
- di->txout = txout;
+ /*
+ * Walk the chain of packet buffers
+ * allocating and initializing transmit descriptor entries.
+ */
+ for (p = p0; p; p = next)
+ {
+ data = PKTDATA (di->osh, p);
+ len = PKTLEN (di->osh, p);
+ next = PKTNEXT (di->osh, p);
- /* kick the chip */
- if (commit)
- W_REG(di->osh, &di->d64txregs->ptr, I2B(txout, dma64dd_t));
+ /* return nonzero if out of tx descriptors */
+ if (NEXTTXD (txout) == di->txin)
+ goto outoftxd;
- /* tx flow control */
- di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
+ if (len == 0)
+ continue;
- return (0);
+ /* get physical address of buffer start */
+ pa =
+ (uint32) DMA_MAP (di->osh, data, len, DMA_TX, p,
+ &di->txp_dmah[txout]);
+
+ flags = 0;
+ if (p == p0)
+ flags |= D64_CTRL1_SOF;
+ if (next == NULL)
+ flags |= (D64_CTRL1_IOC | D64_CTRL1_EOF);
+ if (txout == (di->ntxd - 1))
+ flags |= D64_CTRL1_EOT;
+
+ dma64_dd_upd (di, di->txd64, pa, txout, &flags, len);
+ ASSERT (di->txp[txout] == NULL);
+
+ txout = NEXTTXD (txout);
+ }
+
+ /* if last txd eof not set, fix it */
+ if (!(flags & D64_CTRL1_EOF))
+ W_SM (&di->txd64[PREVTXD (txout)].ctrl1,
+ BUS_SWAP32 (flags | D64_CTRL1_IOC | D64_CTRL1_EOF));
+
+ /* save the packet */
+ di->txp[PREVTXD (txout)] = p0;
+
+ /* bump the tx descriptor index */
+ di->txout = txout;
+
+ /* kick the chip */
+ if (commit)
+ W_REG (di->osh, &di->d64txregs->ptr, I2B (txout, dma64dd_t));
+
+ /* tx flow control */
+ di->hnddma.txavail = di->ntxd - NTXDACTIVE (di->txin, di->txout) - 1;
+
+ return (0);
outoftxd:
- DMA_ERROR(("%s: dma_txfast: out of txds\n", di->name));
- PKTFREE(di->osh, p0, TRUE);
- di->hnddma.txavail = 0;
- di->hnddma.txnobuf++;
- return (-1);
+ DMA_ERROR (("%s: dma_txfast: out of txds\n", di->name));
+ PKTFREE (di->osh, p0, TRUE);
+ di->hnddma.txavail = 0;
+ di->hnddma.txnobuf++;
+ return (-1);
}
/*
@@ -1685,209 +2061,221 @@ outoftxd:
* regardless of the value of the hardware "curr" pointer.
*/
static void *
-dma64_getnexttxp(dma_info_t *di, bool forceall)
+dma64_getnexttxp (dma_info_t * di, bool forceall)
{
- uint start, end, i;
- void *txp;
+ uint start, end, i;
+ void *txp;
- DMA_TRACE(("%s: dma_getnexttxp %s\n", di->name, forceall ? "all" : ""));
+ DMA_TRACE (("%s: dma_getnexttxp %s\n", di->name, forceall ? "all" : ""));
- if (di->ntxd == 0)
- return (NULL);
+ if (di->ntxd == 0)
+ return (NULL);
- txp = NULL;
+ txp = NULL;
- start = di->txin;
- if (forceall)
- end = di->txout;
- else
- end = B2I(R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_CD_MASK, dma64dd_t);
+ start = di->txin;
+ if (forceall)
+ end = di->txout;
+ else
+ end =
+ B2I (R_REG (di->osh, &di->d64txregs->status0) & D64_XS0_CD_MASK,
+ dma64dd_t);
- if ((start == 0) && (end > di->txout))
- goto bogus;
+ if ((start == 0) && (end > di->txout))
+ goto bogus;
- for (i = start; i != end && !txp; i = NEXTTXD(i)) {
- DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->txd64[i].addrlow)) - di->dataoffsetlow),
- (BUS_SWAP32(R_SM(&di->txd64[i].ctrl2)) & D64_CTRL2_BC_MASK),
- DMA_TX, di->txp[i]);
+ for (i = start; i != end && !txp; i = NEXTTXD (i))
+ {
+ DMA_UNMAP (di->osh,
+ (BUS_SWAP32 (R_SM (&di->txd64[i].addrlow)) -
+ di->dataoffsetlow),
+ (BUS_SWAP32 (R_SM (&di->txd64[i].ctrl2)) &
+ D64_CTRL2_BC_MASK), DMA_TX, di->txp[i], &di->txp_dmah[i]);
- W_SM(&di->txd64[i].addrlow, 0xdeadbeef);
- W_SM(&di->txd64[i].addrhigh, 0xdeadbeef);
+ W_SM (&di->txd64[i].addrlow, 0xdeadbeef);
+ W_SM (&di->txd64[i].addrhigh, 0xdeadbeef);
- txp = di->txp[i];
- di->txp[i] = NULL;
- }
+ txp = di->txp[i];
+ di->txp[i] = NULL;
+ }
- di->txin = i;
+ di->txin = i;
- /* tx flow control */
- di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
+ /* tx flow control */
+ di->hnddma.txavail = di->ntxd - NTXDACTIVE (di->txin, di->txout) - 1;
- return (txp);
+ return (txp);
bogus:
/*
DMA_ERROR(("dma_getnexttxp: bogus curr: start %d end %d txout %d force %d\n",
start, end, di->txout, forceall));
*/
- return (NULL);
+ return (NULL);
}
static void *
-dma64_getnextrxp(dma_info_t *di, bool forceall)
+dma64_getnextrxp (dma_info_t * di, bool forceall)
{
- uint i;
- void *rxp;
+ uint i;
+ void *rxp;
- /* if forcing, dma engine must be disabled */
- ASSERT(!forceall || !dma64_rxenabled(di));
+ /* if forcing, dma engine must be disabled */
+ ASSERT (!forceall || !dma64_rxenabled (di));
- i = di->rxin;
+ i = di->rxin;
- /* return if no packets posted */
- if (i == di->rxout)
- return (NULL);
+ /* return if no packets posted */
+ if (i == di->rxout)
+ return (NULL);
- /* ignore curr if forceall */
- if (!forceall &&
- (i == B2I(R_REG(di->osh, &di->d64rxregs->status0) & D64_RS0_CD_MASK, dma64dd_t)))
- return (NULL);
+ /* ignore curr if forceall */
+ if (!forceall &&
+ (i ==
+ B2I (R_REG (di->osh, &di->d64rxregs->status0) & D64_RS0_CD_MASK,
+ dma64dd_t)))
+ return (NULL);
- /* get the packet pointer that corresponds to the rx descriptor */
- rxp = di->rxp[i];
- ASSERT(rxp);
- di->rxp[i] = NULL;
+ /* get the packet pointer that corresponds to the rx descriptor */
+ rxp = di->rxp[i];
+ ASSERT (rxp);
+ di->rxp[i] = NULL;
- /* clear this packet from the descriptor ring */
- DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->rxd64[i].addrlow)) - di->dataoffsetlow),
- di->rxbufsize, DMA_RX, rxp);
+ /* clear this packet from the descriptor ring */
+ DMA_UNMAP (di->osh,
+ (BUS_SWAP32 (R_SM (&di->rxd64[i].addrlow)) - di->dataoffsetlow),
+ di->rxbufsize, DMA_RX, rxp, &di->rxp_dmah[i]);
- W_SM(&di->rxd64[i].addrlow, 0xdeadbeef);
- W_SM(&di->rxd64[i].addrhigh, 0xdeadbeef);
+ W_SM (&di->rxd64[i].addrlow, 0xdeadbeef);
+ W_SM (&di->rxd64[i].addrhigh, 0xdeadbeef);
- di->rxin = NEXTRXD(i);
+ di->rxin = NEXTRXD (i);
- return (rxp);
+ return (rxp);
}
static bool
-_dma64_addrext(osl_t *osh, dma64regs_t *dma64regs)
+_dma64_addrext (osl_t * osh, dma64regs_t * dma64regs)
{
- uint32 w;
- OR_REG(osh, &dma64regs->control, D64_XC_AE);
- w = R_REG(osh, &dma64regs->control);
- AND_REG(osh, &dma64regs->control, ~D64_XC_AE);
- return ((w & D64_XC_AE) == D64_XC_AE);
+ uint32 w;
+ OR_REG (osh, &dma64regs->control, D64_XC_AE);
+ w = R_REG (osh, &dma64regs->control);
+ AND_REG (osh, &dma64regs->control, ~D64_XC_AE);
+ return ((w & D64_XC_AE) == D64_XC_AE);
}
/*
* Rotate all active tx dma ring entries "forward" by (ActiveDescriptor - txin).
*/
static void
-dma64_txrotate(dma_info_t *di)
+dma64_txrotate (dma_info_t * di)
{
- uint ad;
- uint nactive;
- uint rot;
- uint old, new;
- uint32 w;
- uint first, last;
-
- ASSERT(dma64_txsuspendedidle(di));
-
- nactive = _dma_txactive(di);
- ad = B2I((R_REG(di->osh, &di->d64txregs->status1) & D64_XS1_AD_MASK), dma64dd_t);
- rot = TXD(ad - di->txin);
-
- ASSERT(rot < di->ntxd);
-
- /* full-ring case is a lot harder - don't worry about this */
- if (rot >= (di->ntxd - nactive)) {
- DMA_ERROR(("%s: dma_txrotate: ring full - punt\n", di->name));
- return;
- }
-
- first = di->txin;
- last = PREVTXD(di->txout);
-
- /* move entries starting at last and moving backwards to first */
- for (old = last; old != PREVTXD(first); old = PREVTXD(old)) {
- new = TXD(old + rot);
-
- /*
- * Move the tx dma descriptor.
- * EOT is set only in the last entry in the ring.
- */
- w = BUS_SWAP32(R_SM(&di->txd64[old].ctrl1)) & ~D64_CTRL1_EOT;
- if (new == (di->ntxd - 1))
- w |= D64_CTRL1_EOT;
- W_SM(&di->txd64[new].ctrl1, BUS_SWAP32(w));
-
- w = BUS_SWAP32(R_SM(&di->txd64[old].ctrl2));
- W_SM(&di->txd64[new].ctrl2, BUS_SWAP32(w));
-
- W_SM(&di->txd64[new].addrlow, R_SM(&di->txd64[old].addrlow));
- W_SM(&di->txd64[new].addrhigh, R_SM(&di->txd64[old].addrhigh));
-
- /* zap the old tx dma descriptor address field */
- W_SM(&di->txd64[old].addrlow, BUS_SWAP32(0xdeadbeef));
- W_SM(&di->txd64[old].addrhigh, BUS_SWAP32(0xdeadbeef));
-
- /* move the corresponding txp[] entry */
- ASSERT(di->txp[new] == NULL);
- di->txp[new] = di->txp[old];
- di->txp[old] = NULL;
- }
-
- /* update txin and txout */
- di->txin = ad;
- di->txout = TXD(di->txout + rot);
- di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
-
- /* kick the chip */
- W_REG(di->osh, &di->d64txregs->ptr, I2B(di->txout, dma64dd_t));
+ uint ad;
+ uint nactive;
+ uint rot;
+ uint old, new;
+ uint32 w;
+ uint first, last;
+
+ ASSERT (dma64_txsuspendedidle (di));
+
+ nactive = _dma_txactive (di);
+ ad =
+ B2I ((R_REG (di->osh, &di->d64txregs->status1) & D64_XS1_AD_MASK),
+ dma64dd_t);
+ rot = TXD (ad - di->txin);
+
+ ASSERT (rot < di->ntxd);
+
+ /* full-ring case is a lot harder - don't worry about this */
+ if (rot >= (di->ntxd - nactive))
+ {
+ DMA_ERROR (("%s: dma_txrotate: ring full - punt\n", di->name));
+ return;
+ }
+
+ first = di->txin;
+ last = PREVTXD (di->txout);
+
+ /* move entries starting at last and moving backwards to first */
+ for (old = last; old != PREVTXD (first); old = PREVTXD (old))
+ {
+ new = TXD (old + rot);
+
+ /*
+ * Move the tx dma descriptor.
+ * EOT is set only in the last entry in the ring.
+ */
+ w = BUS_SWAP32 (R_SM (&di->txd64[old].ctrl1)) & ~D64_CTRL1_EOT;
+ if (new == (di->ntxd - 1))
+ w |= D64_CTRL1_EOT;
+ W_SM (&di->txd64[new].ctrl1, BUS_SWAP32 (w));
+
+ w = BUS_SWAP32 (R_SM (&di->txd64[old].ctrl2));
+ W_SM (&di->txd64[new].ctrl2, BUS_SWAP32 (w));
+
+ W_SM (&di->txd64[new].addrlow, R_SM (&di->txd64[old].addrlow));
+ W_SM (&di->txd64[new].addrhigh, R_SM (&di->txd64[old].addrhigh));
+
+ /* zap the old tx dma descriptor address field */
+ W_SM (&di->txd64[old].addrlow, BUS_SWAP32 (0xdeadbeef));
+ W_SM (&di->txd64[old].addrhigh, BUS_SWAP32 (0xdeadbeef));
+
+ /* move the corresponding txp[] entry */
+ ASSERT (di->txp[new] == NULL);
+ di->txp[new] = di->txp[old];
+ di->txp[old] = NULL;
+ }
+
+ /* update txin and txout */
+ di->txin = ad;
+ di->txout = TXD (di->txout + rot);
+ di->hnddma.txavail = di->ntxd - NTXDACTIVE (di->txin, di->txout) - 1;
+
+ /* kick the chip */
+ W_REG (di->osh, &di->d64txregs->ptr, I2B (di->txout, dma64dd_t));
}
-#endif /* BCMDMA64 */
+#endif /* BCMDMA64 */
uint
-dma_addrwidth(sb_t *sbh, void *dmaregs)
-{
- dma32regs_t *dma32regs;
- osl_t *osh;
-
- osh = sb_osh(sbh);
-
- if (DMA64_CAP) {
- /* DMA engine is 64-bit capable */
- if (((sb_coreflagshi(sbh, 0, 0) & SBTMH_DMA64) == SBTMH_DMA64)) {
- /* backplane are 64 bits capable */
-#if 0
- if (sb_backplane64(sbh))
- /* If bus is System Backplane or PCIE then we can access 64-bits */
- if ((BUSTYPE(sbh->bustype) == SB_BUS) ||
- ((BUSTYPE(sbh->bustype) == PCI_BUS) &&
- sbh->buscoretype == SB_PCIE))
- return (DMADDRWIDTH_64);
-#endif
-
- /* DMA64 is always 32 bits capable, AE is always TRUE */
+dma_addrwidth (sb_t * sbh, void *dmaregs)
+{
+ dma32regs_t *dma32regs;
+ osl_t *osh;
+
+ osh = sb_osh (sbh);
+
+ if (DMA64_CAP)
+ {
+ /* DMA engine is 64-bit capable */
+ if (((sb_coreflagshi (sbh, 0, 0) & SBTMH_DMA64) == SBTMH_DMA64))
+ {
+ /* backplane are 64 bits capable */
+ if (sb_backplane64 (sbh))
+ /* If bus is System Backplane or PCIE then we can access 64-bits */
+ if ((BUSTYPE (sbh->bustype) == SB_BUS) ||
+ ((BUSTYPE (sbh->bustype) == PCI_BUS) &&
+ sbh->buscoretype == SB_PCIE))
+ return (DMADDRWIDTH_64);
+
+ /* DMA64 is always 32 bits capable, AE is always TRUE */
#ifdef BCMDMA64
- ASSERT(_dma64_addrext(osh, (dma64regs_t *)dmaregs));
+ ASSERT (_dma64_addrext (osh, (dma64regs_t *) dmaregs));
#endif
- return (DMADDRWIDTH_32);
- }
+ return (DMADDRWIDTH_32);
}
+ }
- /* Start checking for 32-bit / 30-bit addressing */
- dma32regs = (dma32regs_t *)dmaregs;
+ /* Start checking for 32-bit / 30-bit addressing */
+ dma32regs = (dma32regs_t *) dmaregs;
- /* For System Backplane, PCIE bus or addrext feature, 32-bits ok */
- if ((BUSTYPE(sbh->bustype) == SB_BUS) ||
- ((BUSTYPE(sbh->bustype) == PCI_BUS) && sbh->buscoretype == SB_PCIE) ||
- (_dma32_addrext(osh, dma32regs)))
- return (DMADDRWIDTH_32);
+ /* For System Backplane, PCIE bus or addrext feature, 32-bits ok */
+ if ((BUSTYPE (sbh->bustype) == SB_BUS) ||
+ ((BUSTYPE (sbh->bustype) == PCI_BUS) && sbh->buscoretype == SB_PCIE) ||
+ (_dma32_addrext (osh, dma32regs)))
+ return (DMADDRWIDTH_32);
- /* Fallthru */
- return (DMADDRWIDTH_30);
+ /* Fallthru */
+ return (DMADDRWIDTH_30);
}
diff --git a/package/broadcom-wl/src/driver/hnddma.h b/package/broadcom-wl/src/driver/hnddma.h
index de74c06..8d1b5ac 100644
--- a/package/broadcom-wl/src/driver/hnddma.h
+++ b/package/broadcom-wl/src/driver/hnddma.h
@@ -2,14 +2,14 @@
* Generic Broadcom Home Networking Division (HND) DMA engine SW interface
* This supports the following chips: BCM42xx, 44xx, 47xx .
*
- * Copyright 2006, Broadcom Corporation
+ * Copyright 2007, Broadcom Corporation
* All Rights Reserved.
*
* THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
* KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
* SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
- * $Id: hnddma.h,v 1.1.1.13 2006/04/08 06:13:39 honor Exp $
+ * $Id$
*/
#ifndef _hnddma_h_
@@ -39,7 +39,7 @@ typedef void* (*di_rx_t)(hnddma_t *dmah);
typedef void (*di_rxfill_t)(hnddma_t *dmah);
typedef void (*di_txreclaim_t)(hnddma_t *dmah, bool forceall);
typedef void (*di_rxreclaim_t)(hnddma_t *dmah);
-typedef uintptr (*di_getvar_t)(hnddma_t *dmah, char *name);
+typedef uintptr (*di_getvar_t)(hnddma_t *dmah, const char *name);
typedef void* (*di_getnexttxp_t)(hnddma_t *dmah, bool forceall);
typedef void* (*di_getnextrxp_t)(hnddma_t *dmah, bool forceall);
typedef void* (*di_peeknexttxp_t)(hnddma_t *dmah);
@@ -141,8 +141,12 @@ extern hnddma_t * dma_attach(osl_t *osh, char *name, sb_t *sbh, void *dmaregstx,
#define dma_txactive(di) ((di)->di_fn.txactive(di))
#define dma_txrotate(di) ((di)->di_fn.txrotate(di))
#define dma_counterreset(di) ((di)->di_fn.counterreset(di))
+#ifdef BCMDBG
+#define dma_dump(di, buf, dumpring) ((di)->di_fn.dump(di, buf, dumpring))
+#define dma_dumptx(di, buf, dumpring) ((di)->di_fn.dumptx(di, buf, dumpring))
+#define dma_dumprx(di, buf, dumpring) ((di)->di_fn.dumprx(di, buf, dumpring))
+#endif
-#define DMA_DUMP_SIZE 2048
/* return addresswidth allowed
* This needs to be done after SB attach but before dma attach.
* SB attach provides ability to probe backplane and dma core capabilities
diff --git a/package/broadcom-wl/src/driver/linux_osl.c b/package/broadcom-wl/src/driver/linux_osl.c
index 24fd77d..cc55eb6 100644
--- a/package/broadcom-wl/src/driver/linux_osl.c
+++ b/package/broadcom-wl/src/driver/linux_osl.c
@@ -1,7 +1,7 @@
/*
* Linux OS Independent Layer
*
- * Copyright 2006, Broadcom Corporation
+ * Copyright 2007, Broadcom Corporation
* All Rights Reserved.
*
* THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
@@ -9,266 +9,882 @@
* SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
*
- * $Id: linux_osl.c,v 1.1.1.14 2006/04/08 06:13:39 honor Exp $
+ * $Id$
*/
#define LINUX_OSL
#include <typedefs.h>
#include <bcmendian.h>
-#include <linux/module.h>
#include <linuxver.h>
#include <bcmdefs.h>
#include <osl.h>
#include "linux_osl.h"
-#include <bcmutils.h>
+#include "bcmutils.h"
#include <linux/delay.h>
#ifdef mips
#include <asm/paccess.h>
#endif /* mips */
#include <pcicfg.h>
-#define PCI_CFG_RETRY 10
+#define PCI_CFG_RETRY 10
#define OS_HANDLE_MAGIC 0x1234abcd /* Magic # to recognise osh */
-#define BCM_MEM_FILENAME_LEN 24 /* Mem. filename length */
-
-typedef struct bcm_mem_link {
- struct bcm_mem_link *prev;
- struct bcm_mem_link *next;
- uint size;
- int line;
- char file[BCM_MEM_FILENAME_LEN];
+#define BCM_MEM_FILENAME_LEN 24 /* Mem. filename length */
+
+typedef struct bcm_mem_link
+{
+ struct bcm_mem_link *prev;
+ struct bcm_mem_link *next;
+ uint size;
+ int line;
+ char file[BCM_MEM_FILENAME_LEN];
} bcm_mem_link_t;
-static int16 linuxbcmerrormap[] = \
-{ 0, /* 0 */
- -EINVAL, /* BCME_ERROR */
- -EINVAL, /* BCME_BADARG */
- -EINVAL, /* BCME_BADOPTION */
- -EINVAL, /* BCME_NOTUP */
- -EINVAL, /* BCME_NOTDOWN */
- -EINVAL, /* BCME_NOTAP */
- -EINVAL, /* BCME_NOTSTA */
- -EINVAL, /* BCME_BADKEYIDX */
- -EINVAL, /* BCME_RADIOOFF */
- -EINVAL, /* BCME_NOTBANDLOCKED */
- -EINVAL, /* BCME_NOCLK */
- -EINVAL, /* BCME_BADRATESET */
- -EINVAL, /* BCME_BADBAND */
- -E2BIG, /* BCME_BUFTOOSHORT */
- -E2BIG, /* BCME_BUFTOOLONG */
- -EBUSY, /* BCME_BUSY */
- -EINVAL, /* BCME_NOTASSOCIATED */
- -EINVAL, /* BCME_BADSSIDLEN */
- -EINVAL, /* BCME_OUTOFRANGECHAN */
- -EINVAL, /* BCME_BADCHAN */
- -EFAULT, /* BCME_BADADDR */
- -ENOMEM, /* BCME_NORESOURCE */
- -EOPNOTSUPP, /* BCME_UNSUPPORTED */
- -EMSGSIZE, /* BCME_BADLENGTH */
- -EINVAL, /* BCME_NOTREADY */
- -EPERM, /* BCME_NOTPERMITTED */
- -ENOMEM, /* BCME_NOMEM */
- -EINVAL, /* BCME_ASSOCIATED */
- -ERANGE, /* BCME_RANGE */
- -EINVAL, /* BCME_NOTFOUND */
- -EINVAL, /* BCME_WME_NOT_ENABLED */
- -EINVAL, /* BCME_TSPEC_NOTFOUND */
- -EINVAL, /* BCME_ACM_NOTSUPPORTED */
- -EINVAL, /* BCME_NOT_WME_ASSOCIATION */
- -EIO, /* BCME_SDIO_ERROR */
- -ENODEV /* BCME_DONGLE_DOWN */
+#if 0
+struct osl_info
+{
+ osl_pubinfo_t pub;
+ uint magic;
+ void *pdev;
+ uint malloced;
+ uint failed;
+ uint bustype;
+ bcm_mem_link_t *dbgmem_list;
+#ifdef BCMDBG_PKT /* pkt logging for debugging */
+ pktlist_info_t pktlist;
+#endif /* BCMDBG_PKT */
+};
+#endif
+
+static int16 linuxbcmerrormap[] = { 0, /* 0 */
+ -EINVAL, /* BCME_ERROR */
+ -EINVAL, /* BCME_BADARG */
+ -EINVAL, /* BCME_BADOPTION */
+ -EINVAL, /* BCME_NOTUP */
+ -EINVAL, /* BCME_NOTDOWN */
+ -EINVAL, /* BCME_NOTAP */
+ -EINVAL, /* BCME_NOTSTA */
+ -EINVAL, /* BCME_BADKEYIDX */
+ -EINVAL, /* BCME_RADIOOFF */
+ -EINVAL, /* BCME_NOTBANDLOCKED */
+ -EINVAL, /* BCME_NOCLK */
+ -EINVAL, /* BCME_BADRATESET */
+ -EINVAL, /* BCME_BADBAND */
+ -E2BIG, /* BCME_BUFTOOSHORT */
+ -E2BIG, /* BCME_BUFTOOLONG */
+ -EBUSY, /* BCME_BUSY */
+ -EINVAL, /* BCME_NOTASSOCIATED */
+ -EINVAL, /* BCME_BADSSIDLEN */
+ -EINVAL, /* BCME_OUTOFRANGECHAN */
+ -EINVAL, /* BCME_BADCHAN */
+ -EFAULT, /* BCME_BADADDR */
+ -ENOMEM, /* BCME_NORESOURCE */
+ -EOPNOTSUPP, /* BCME_UNSUPPORTED */
+ -EMSGSIZE, /* BCME_BADLENGTH */
+ -EINVAL, /* BCME_NOTREADY */
+ -EPERM, /* BCME_NOTPERMITTED */
+ -ENOMEM, /* BCME_NOMEM */
+ -EINVAL, /* BCME_ASSOCIATED */
+ -ERANGE, /* BCME_RANGE */
+ -EINVAL, /* BCME_NOTFOUND */
+ -EINVAL, /* BCME_WME_NOT_ENABLED */
+ -EINVAL, /* BCME_TSPEC_NOTFOUND */
+ -EINVAL, /* BCME_ACM_NOTSUPPORTED */
+ -EINVAL, /* BCME_NOT_WME_ASSOCIATION */
+ -EIO, /* BCME_SDIO_ERROR */
+ -ENODEV, /* BCME_DONGLE_DOWN */
+ -EINVAL /* BCME_VERSION */
+/* When an new error code is added to bcmutils.h, add os
+ * spcecific error translation here as well
+ */
+/* check if BCME_LAST changed since the last time this function was updated */
+#if BCME_LAST != -37
+#error "You need to add a OS error translation in the linuxbcmerrormap \
+ for new error code defined in bcmuitls.h"
+#endif /* BCME_LAST != -37 */
};
/* translate bcmerrors into linux errors */
int
-osl_error(int bcmerror)
+osl_error (int bcmerror)
{
- int abs_bcmerror;
- int array_size = ARRAYSIZE(linuxbcmerrormap);
+ if (bcmerror > 0)
+ bcmerror = 0;
+ else if (bcmerror < BCME_LAST)
+ bcmerror = BCME_ERROR;
- abs_bcmerror = ABS(bcmerror);
+ /* Array bounds covered by ASSERT in osl_attach */
+ return linuxbcmerrormap[-bcmerror];
+}
- if (bcmerror > 0)
- abs_bcmerror = 0;
+osl_t *
+osl_attach (void *pdev, uint bustype, bool pkttag)
+{
+ osl_t *osh;
+
+ osh = kmalloc (sizeof (osl_t), GFP_ATOMIC);
+ ASSERT (osh);
+
+ bzero (osh, sizeof (osl_t));
+
+ /* Check that error map has the right number of entries in it */
+ ASSERT (ABS (BCME_LAST) == (ARRAYSIZE (linuxbcmerrormap) - 1));
+
+ osh->magic = OS_HANDLE_MAGIC;
+ osh->malloced = 0;
+ osh->failed = 0;
+ osh->dbgmem_list = NULL;
+ osh->pdev = pdev;
+ osh->pub.pkttag = pkttag;
+ osh->bustype = bustype;
+
+ switch (bustype)
+ {
+ case PCI_BUS:
+ case SB_BUS:
+ case PCMCIA_BUS:
+ osh->pub.mmbus = TRUE;
+ break;
+ case JTAG_BUS:
+ case SDIO_BUS:
+ break;
+ default:
+ ASSERT (FALSE);
+ break;
+ }
+
+#ifdef BCMDBG
+ if (pkttag)
+ {
+ struct sk_buff *skb;
+ ASSERT (OSL_PKTTAG_SZ <= sizeof (skb->cb));
+ }
+#endif
+ return osh;
+}
- else if (abs_bcmerror >= array_size)
- abs_bcmerror = BCME_ERROR;
+void
+osl_detach (osl_t * osh)
+{
+ if (osh == NULL)
+ return;
- return linuxbcmerrormap[abs_bcmerror];
+ ASSERT (osh->magic == OS_HANDLE_MAGIC);
+ kfree (osh);
}
-osl_t *
-osl_attach(void *pdev, bool pkttag)
+/* Return a new packet. zero out pkttag */
+void *
+osl_pktget (osl_t * osh, uint len)
+{
+ struct sk_buff *skb;
+
+ if ((skb = dev_alloc_skb (len)))
+ {
+ skb_put (skb, len);
+ skb->priority = 0;
+
+#ifdef BCMDBG_PKT
+ pktlist_add (&(osh->pktlist), (void *) skb);
+#endif /* BCMDBG_PKT */
+
+ osh->pub.pktalloced++;
+ }
+
+ return ((void *) skb);
+}
+
+/* Free the driver packet. Free the tag if present */
+void
+osl_pktfree (osl_t * osh, void *p, bool send)
+{
+ struct sk_buff *skb, *nskb;
+
+ skb = (struct sk_buff *) p;
+
+ if (send && osh->pub.tx_fn)
+ osh->pub.tx_fn (osh->pub.tx_ctx, p, 0);
+
+ /* perversion: we use skb->next to chain multi-skb packets */
+ while (skb)
+ {
+ nskb = skb->next;
+ skb->next = NULL;
+
+#ifdef BCMDBG_PKT
+ pktlist_remove (&(osh->pktlist), (void *) skb);
+#endif /* BCMDBG_PKT */
+
+ if (skb->destructor)
+ {
+ /* cannot kfree_skb() on hard IRQ (net/core/skbuff.c) if destructor exists
+ */
+ dev_kfree_skb_any (skb);
+ }
+ else
+ {
+ /* can free immediately (even in_irq()) if destructor does not exist */
+ dev_kfree_skb (skb);
+ }
+
+ osh->pub.pktalloced--;
+
+ skb = nskb;
+ }
+}
+
+uint32
+osl_pci_read_config (osl_t * osh, uint offset, uint size)
{
- osl_t *osh;
+ uint val;
+ uint retry = PCI_CFG_RETRY;
- osh = kmalloc(sizeof(osl_t), GFP_ATOMIC);
- ASSERT(osh);
+ ASSERT ((osh && (osh->magic == OS_HANDLE_MAGIC)));
- bzero(osh, sizeof(osl_t));
+ /* only 4byte access supported */
+ ASSERT (size == 4);
- /*
- * check the cases where
- * 1.Error code Added to bcmerror table, but forgot to add it to the OS
- * dependent error code
- * 2. Error code is added to the bcmerror table, but forgot to add the
- * corresponding errorstring(dummy call to bcmerrorstr)
- */
- bcmerrorstr(0);
- ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(linuxbcmerrormap) - 1));
+ do
+ {
+ pci_read_config_dword (osh->pdev, offset, &val);
+ if (val != 0xffffffff)
+ break;
+ }
+ while (retry--);
- osh->magic = OS_HANDLE_MAGIC;
- osh->malloced = 0;
- osh->failed = 0;
- osh->dbgmem_list = NULL;
- osh->pdev = pdev;
- osh->pub.pkttag = pkttag;
+#ifdef BCMDBG
+ if (retry < PCI_CFG_RETRY)
+ printk ("PCI CONFIG READ access to %d required %d retries\n", offset,
+ (PCI_CFG_RETRY - retry));
+#endif /* BCMDBG */
- return osh;
+ return (val);
}
void
-osl_detach(osl_t *osh)
+osl_pci_write_config (osl_t * osh, uint offset, uint size, uint val)
{
- if (osh == NULL)
- return;
+ uint retry = PCI_CFG_RETRY;
+
+ ASSERT ((osh && (osh->magic == OS_HANDLE_MAGIC)));
+
+ /* only 4byte access supported */
+ ASSERT (size == 4);
+
+ do
+ {
+ pci_write_config_dword (osh->pdev, offset, val);
+ if (offset != PCI_BAR0_WIN)
+ break;
+ if (osl_pci_read_config (osh, offset, size) == val)
+ break;
+ }
+ while (retry--);
+
+#ifdef BCMDBG
+ if (retry < PCI_CFG_RETRY)
+ printk ("PCI CONFIG WRITE access to %d required %d retries\n", offset,
+ (PCI_CFG_RETRY - retry));
+#endif /* BCMDBG */
+}
- ASSERT(osh->magic == OS_HANDLE_MAGIC);
- kfree(osh);
+/* return bus # for the pci device pointed by osh->pdev */
+uint
+osl_pci_bus (osl_t * osh)
+{
+ ASSERT (osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
+
+ return ((struct pci_dev *) osh->pdev)->bus->number;
}
-/* Return a new packet. zero out pkttag */
-void*
-osl_pktget(osl_t *osh, uint len, bool send)
+/* return slot # for the pci device pointed by osh->pdev */
+uint
+osl_pci_slot (osl_t * osh)
{
- struct sk_buff *skb;
+ ASSERT (osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
- if ((skb = dev_alloc_skb(len))) {
- skb_put(skb, len);
- skb->priority = 0;
+ return PCI_SLOT (((struct pci_dev *) osh->pdev)->devfn);
+}
-#ifdef BCMDBG_PKT
- pktlist_add(&(osh->pktlist), (void *) skb);
-#endif /* BCMDBG_PKT */
+static void
+osl_pcmcia_attr (osl_t * osh, uint offset, char *buf, int size, bool write)
+{
+}
- osh->pub.pktalloced++;
- }
+void
+osl_pcmcia_read_attr (osl_t * osh, uint offset, void *buf, int size)
+{
+ osl_pcmcia_attr (osh, offset, (char *) buf, size, FALSE);
+}
+
+void
+osl_pcmcia_write_attr (osl_t * osh, uint offset, void *buf, int size)
+{
+ osl_pcmcia_attr (osh, offset, (char *) buf, size, TRUE);
+}
+
+
+#ifdef BCMDBG_MEM
+
+void *
+osl_debug_malloc (osl_t * osh, uint size, int line, char *file)
+{
+ bcm_mem_link_t *p;
+ char *basename;
+
+ ASSERT (size);
- return ((void*) skb);
+ if ((p =
+ (bcm_mem_link_t *) osl_malloc (osh,
+ sizeof (bcm_mem_link_t) + size)) ==
+ NULL)
+ return (NULL);
+
+ p->size = size;
+ p->line = line;
+
+ basename = strrchr (file, '/');
+ /* skip the '/' */
+ if (basename)
+ basename++;
+
+ if (!basename)
+ basename = file;
+
+ strncpy (p->file, basename, BCM_MEM_FILENAME_LEN);
+ p->file[BCM_MEM_FILENAME_LEN - 1] = '\0';
+
+ /* link this block */
+ p->prev = NULL;
+ p->next = osh->dbgmem_list;
+ if (p->next)
+ p->next->prev = p;
+ osh->dbgmem_list = p;
+
+ return p + 1;
}
-typedef void (*pktfree_cb_fn_t)(void *ctx, void *pkt, uint16 status);
-/* Free the driver packet. Free the tag if present */
void
-osl_pktfree(osl_t *osh, void *p, bool send)
+osl_debug_mfree (osl_t * osh, void *addr, uint size, int line, char *file)
{
- struct sk_buff *skb, *nskb;
- pktfree_cb_fn_t tx_fn = osh->pub.tx_fn;
+ bcm_mem_link_t *p =
+ (bcm_mem_link_t *) ((int8 *) addr - sizeof (bcm_mem_link_t));
+
+ ASSERT ((osh && (osh->magic == OS_HANDLE_MAGIC)));
+
+ if (p->size == 0)
+ {
+ printk
+ ("osl_debug_mfree: double free on addr %p size %d at line %d file %s\n",
+ addr, size, line, file);
+ ASSERT (p->size);
+ return;
+ }
+
+ if (p->size != size)
+ {
+ printk
+ ("osl_debug_mfree: dealloc size %d does not match alloc size %d on addr %p"
+ " at line %d file %s\n", size, p->size, addr, line, file);
+ ASSERT (p->size == size);
+ return;
+ }
+
+ /* unlink this block */
+ if (p->prev)
+ p->prev->next = p->next;
+ if (p->next)
+ p->next->prev = p->prev;
+ if (osh->dbgmem_list == p)
+ osh->dbgmem_list = p->next;
+ p->next = p->prev = NULL;
+
+ osl_mfree (osh, p, size + sizeof (bcm_mem_link_t));
+}
- skb = (struct sk_buff*) p;
-
- if (send && tx_fn)
- tx_fn(osh->pub.tx_ctx, p, 0);
+int
+osl_debug_memdump (osl_t * osh, struct bcmstrbuf *b)
+{
+ bcm_mem_link_t *p;
- /* perversion: we use skb->next to chain multi-skb packets */
- while (skb) {
- nskb = skb->next;
- skb->next = NULL;
+ ASSERT ((osh && (osh->magic == OS_HANDLE_MAGIC)));
-#ifdef BCMDBG_PKT
- pktlist_remove(&(osh->pktlist), (void *) skb);
-#endif /* BCMDBG_PKT */
+ bcm_bprintf (b, " Address\tSize\tFile:line\n");
+ for (p = osh->dbgmem_list; p; p = p->next)
+ bcm_bprintf (b, "0x%08x\t%5d\t%s:%d\n",
+ (uintptr) p + sizeof (bcm_mem_link_t), p->size, p->file,
+ p->line);
- if (skb->destructor) {
- /* cannot kfree_skb() on hard IRQ (net/core/skbuff.c) if destructor exists
- */
- dev_kfree_skb_any(skb);
- } else {
- /* can free immediately (even in_irq()) if destructor does not exist */
- dev_kfree_skb(skb);
- }
+ return 0;
+}
- osh->pub.pktalloced--;
+#endif /* BCMDBG_MEM */
- skb = nskb;
- }
+void *
+osl_malloc (osl_t * osh, uint size)
+{
+ void *addr;
+
+ /* only ASSERT if osh is defined */
+ if (osh)
+ ASSERT (osh->magic == OS_HANDLE_MAGIC);
+
+ if ((addr = kmalloc (size, GFP_ATOMIC)) == NULL)
+ {
+ if (osh)
+ osh->failed++;
+ return (NULL);
+ }
+ if (osh)
+ osh->malloced += size;
+
+ return (addr);
}
-void*
-osl_malloc(osl_t *osh, uint size)
+void
+osl_mfree (osl_t * osh, void *addr, uint size)
{
- void *addr;
+ if (osh)
+ {
+ ASSERT (osh->magic == OS_HANDLE_MAGIC);
+ osh->malloced -= size;
+ }
+ kfree (addr);
+}
- /* only ASSERT if osh is defined */
- if (osh)
- ASSERT(osh->magic == OS_HANDLE_MAGIC);
+uint
+osl_malloced (osl_t * osh)
+{
+ ASSERT ((osh && (osh->magic == OS_HANDLE_MAGIC)));
+ return (osh->malloced);
+}
- if ((addr = kmalloc(size, GFP_ATOMIC)) == NULL) {
- if (osh)
- osh->failed++;
- return (NULL);
- }
- if (osh)
- osh->malloced += size;
+uint
+osl_malloc_failed (osl_t * osh)
+{
+ ASSERT ((osh && (osh->magic == OS_HANDLE_MAGIC)));
+ return (osh->failed);
+}
+
+void *
+osl_dma_alloc_consistent (osl_t * osh, uint size, ulong * pap)
+{
+ ASSERT ((osh && (osh->magic == OS_HANDLE_MAGIC)));
- return (addr);
+ return (pci_alloc_consistent (osh->pdev, size, (dma_addr_t *) pap));
}
void
-osl_mfree(osl_t *osh, void *addr, uint size)
+osl_dma_free_consistent (osl_t * osh, void *va, uint size, ulong pa)
{
- if (osh) {
- ASSERT(osh->magic == OS_HANDLE_MAGIC);
- osh->malloced -= size;
- }
- kfree(addr);
+ ASSERT ((osh && (osh->magic == OS_HANDLE_MAGIC)));
+
+ pci_free_consistent (osh->pdev, size, va, (dma_addr_t) pa);
}
uint
-osl_malloced(osl_t *osh)
+osl_dma_map (osl_t * osh, void *va, uint size, int direction)
{
- ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
- return (osh->malloced);
+ int dir;
+
+ ASSERT ((osh && (osh->magic == OS_HANDLE_MAGIC)));
+ dir = (direction == DMA_TX) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE;
+ return (pci_map_single (osh->pdev, va, size, dir));
}
-uint osl_malloc_failed(osl_t *osh)
+void
+osl_dma_unmap (osl_t * osh, uint pa, uint size, int direction)
{
- ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
- return (osh->failed);
+ int dir;
+
+ ASSERT ((osh && (osh->magic == OS_HANDLE_MAGIC)));
+ dir = (direction == DMA_TX) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE;
+ pci_unmap_single (osh->pdev, (uint32) pa, size, dir);
}
-#undef osl_delay
+#if defined(BINOSL) || defined(BCMDBG_ASSERT)
void
-osl_delay(uint usec)
+osl_assert (char *exp, char *file, int line)
{
- OSL_DELAY(usec);
+ char tempbuf[255];
+
+ sprintf (tempbuf, "assertion \"%s\" failed: file \"%s\", line %d\n", exp,
+ file, line);
+ panic (tempbuf);
+}
+#endif /* BCMDBG_ASSERT || BINOSL */
+
+void
+osl_delay (uint usec)
+{
+ uint d;
+
+ while (usec > 0)
+ {
+ d = MIN (usec, 1000);
+ udelay (d);
+ usec -= d;
+ }
}
/* Clone a packet.
* The pkttag contents are NOT cloned.
*/
void *
-osl_pktdup(osl_t *osh, void *skb)
+osl_pktdup (osl_t * osh, void *skb)
+{
+ void *p;
+
+ if ((p = skb_clone ((struct sk_buff *) skb, GFP_ATOMIC)) == NULL)
+ return NULL;
+
+ /* skb_clone copies skb->cb.. we don't want that */
+ if (osh->pub.pkttag)
+ bzero ((void *) ((struct sk_buff *) p)->cb, OSL_PKTTAG_SZ);
+
+ /* Increment the packet counter */
+ osh->pub.pktalloced++;
+#ifdef BCMDBG_PKT
+ pktlist_add (&(osh->pktlist), (void *) p);
+#endif /* BCMDBG_PKT */
+ return (p);
+}
+
+uint
+osl_pktalloced (osl_t * osh)
+{
+ return (osh->pub.pktalloced);
+}
+
+#ifdef BCMDBG_PKT
+char *
+osl_pktlist_dump (osl_t * osh, char *buf)
+{
+ pktlist_dump (&(osh->pktlist), buf);
+ return buf;
+}
+
+void
+osl_pktlist_add (osl_t * osh, void *p)
+{
+ pktlist_add (&(osh->pktlist), p);
+}
+
+void
+osl_pktlist_remove (osl_t * osh, void *p)
+{
+ pktlist_remove (&(osh->pktlist), p);
+}
+#endif /* BCMDBG_PKT */
+
+/*
+ * BINOSL selects the slightly slower function-call-based binary compatible osl.
+ */
+#ifdef BINOSL
+
+int
+osl_printf (const char *format, ...)
+{
+ va_list args;
+ char buf[1024];
+ int len;
+
+ /* sprintf into a local buffer because there *is* no "vprintk()".. */
+ va_start (args, format);
+ len = vsnprintf (buf, 1024, format, args);
+ va_end (args);
+
+ if (len > sizeof (buf))
+ {
+ printk ("osl_printf: buffer overrun\n");
+ return (0);
+ }
+
+ return (printk (buf));
+}
+
+int
+osl_sprintf (char *buf, const char *format, ...)
+{
+ va_list args;
+ int rc;
+
+ va_start (args, format);
+ rc = vsprintf (buf, format, args);
+ va_end (args);
+ return (rc);
+}
+
+int
+osl_strcmp (const char *s1, const char *s2)
+{
+ return (strcmp (s1, s2));
+}
+
+int
+osl_strncmp (const char *s1, const char *s2, uint n)
+{
+ return (strncmp (s1, s2, n));
+}
+
+int
+osl_strlen (const char *s)
+{
+ return (strlen (s));
+}
+
+char *
+osl_strcpy (char *d, const char *s)
+{
+ return (strcpy (d, s));
+}
+
+char *
+osl_strncpy (char *d, const char *s, uint n)
+{
+ return (strncpy (d, s, n));
+}
+
+void
+bcopy (const void *src, void *dst, int len)
+{
+ memcpy (dst, src, len);
+}
+
+int
+bcmp (const void *b1, const void *b2, int len)
+{
+ return (memcmp (b1, b2, len));
+}
+
+void
+bzero (void *b, int len)
+{
+ memset (b, '\0', len);
+}
+
+uint32
+osl_readl (volatile uint32 * r)
+{
+ return (readl (r));
+}
+
+uint16
+osl_readw (volatile uint16 * r)
+{
+ return (readw (r));
+}
+
+uint8
+osl_readb (volatile uint8 * r)
+{
+ return (readb (r));
+}
+
+void
+osl_writel (uint32 v, volatile uint32 * r)
+{
+ writel (v, r);
+}
+
+void
+osl_writew (uint16 v, volatile uint16 * r)
+{
+ writew (v, r);
+}
+
+void
+osl_writeb (uint8 v, volatile uint8 * r)
+{
+ writeb (v, r);
+}
+
+void *
+osl_uncached (void *va)
+{
+#ifdef mips
+ return ((void *) KSEG1ADDR (va));
+#else
+ return ((void *) va);
+#endif /* mips */
+}
+
+uint
+osl_getcycles (void)
{
- void * p;
+ uint cycles;
+
+#if defined(mips)
+ cycles = read_c0_count () * 2;
+#elif defined(__i386__)
+ rdtscl (cycles);
+#else
+ cycles = 0;
+#endif /* defined(mips) */
+ return cycles;
+}
- if ((p = skb_clone((struct sk_buff*)skb, GFP_ATOMIC)) == NULL)
- return NULL;
+void *
+osl_reg_map (uint32 pa, uint size)
+{
+ return (ioremap_nocache ((unsigned long) pa, (unsigned long) size));
+}
- /* skb_clone copies skb->cb.. we don't want that */
- if (osh->pub.pkttag)
- bzero((void*)((struct sk_buff *)p)->cb, OSL_PKTTAG_SZ);
+void
+osl_reg_unmap (void *va)
+{
+ iounmap (va);
+}
- /* Increment the packet counter */
- osh->pub.pktalloced++;
- return (p);
+int
+osl_busprobe (uint32 * val, uint32 addr)
+{
+#ifdef mips
+ return get_dbe (*val, (uint32 *) addr);
+#else
+ *val = readl ((uint32 *) (uintptr) addr);
+ return 0;
+#endif /* mips */
+}
+
+bool
+osl_pktshared (void *skb)
+{
+ return (((struct sk_buff *) skb)->cloned);
+}
+
+uchar *
+osl_pktdata (osl_t * osh, void *skb)
+{
+ return (((struct sk_buff *) skb)->data);
}
uint
-osl_pktalloced(osl_t *osh)
+osl_pktlen (osl_t * osh, void *skb)
+{
+ return (((struct sk_buff *) skb)->len);
+}
+
+uint
+osl_pktheadroom (osl_t * osh, void *skb)
+{
+ return (uint) skb_headroom ((struct sk_buff *) skb);
+}
+
+uint
+osl_pkttailroom (osl_t * osh, void *skb)
+{
+ return (uint) skb_tailroom ((struct sk_buff *) skb);
+}
+
+void *
+osl_pktnext (osl_t * osh, void *skb)
+{
+ return (((struct sk_buff *) skb)->next);
+}
+
+void
+osl_pktsetnext (void *skb, void *x)
+{
+ ((struct sk_buff *) skb)->next = (struct sk_buff *) x;
+}
+
+void
+osl_pktsetlen (osl_t * osh, void *skb, uint len)
+{
+ __skb_trim ((struct sk_buff *) skb, len);
+}
+
+uchar *
+osl_pktpush (osl_t * osh, void *skb, int bytes)
+{
+ return (skb_push ((struct sk_buff *) skb, bytes));
+}
+
+uchar *
+osl_pktpull (osl_t * osh, void *skb, int bytes)
+{
+ return (skb_pull ((struct sk_buff *) skb, bytes));
+}
+
+void *
+osl_pkttag (void *skb)
{
- return (osh->pub.pktalloced);
+ return ((void *) (((struct sk_buff *) skb)->cb));
+}
+
+void *
+osl_pktlink (void *skb)
+{
+ return (((struct sk_buff *) skb)->prev);
+}
+
+void
+osl_pktsetlink (void *skb, void *x)
+{
+ ((struct sk_buff *) skb)->prev = (struct sk_buff *) x;
+}
+
+uint
+osl_pktprio (void *skb)
+{
+ return (((struct sk_buff *) skb)->priority);
+}
+
+void
+osl_pktsetprio (void *skb, uint x)
+{
+ ((struct sk_buff *) skb)->priority = x;
+}
+
+/* Convert a driver packet to native(OS) packet
+ * In the process, packettag is zeroed out before sending up
+ * IP code depends on skb->cb to be setup correctly with various options
+ * In our case, that means it should be 0
+ */
+struct sk_buff *
+osl_pkt_tonative (osl_t * osh, void *pkt)
+{
+ struct sk_buff *nskb;
+
+ if (osh->pub.pkttag)
+ bzero ((void *) ((struct sk_buff *) pkt)->cb, OSL_PKTTAG_SZ);
+
+ /* Decrement the packet counter */
+ for (nskb = (struct sk_buff *) pkt; nskb; nskb = nskb->next)
+ {
+#ifdef BCMDBG_PKT
+ pktlist_remove (&(osh->pktlist), (void *) nskb);
+#endif /* BCMDBG_PKT */
+ osh->pub.pktalloced--;
+ }
+
+ return (struct sk_buff *) pkt;
+}
+
+/* Convert a native(OS) packet to driver packet.
+ * In the process, native packet is destroyed, there is no copying
+ * Also, a packettag is zeroed out
+ */
+void *
+osl_pkt_frmnative (osl_t * osh, struct sk_buff *skb)
+{
+ struct sk_buff *nskb;
+
+ if (osh->pub.pkttag)
+ bzero ((void *) skb->cb, OSL_PKTTAG_SZ);
+
+ /* Increment the packet counter */
+ for (nskb = skb; nskb; nskb = nskb->next)
+ {
+#ifdef BCMDBG_PKT
+ pktlist_add (&(osh->pktlist), (void *) nskb);
+#endif /* BCMDBG_PKT */
+ osh->pub.pktalloced++;
+ }
+
+ return (void *) skb;
}
+#endif /* BINOSL */
diff --git a/package/broadcom-wl/src/driver/linux_osl.h b/package/broadcom-wl/src/driver/linux_osl.h
index d9c5533..f65c859 100644
--- a/package/broadcom-wl/src/driver/linux_osl.h
+++ b/package/broadcom-wl/src/driver/linux_osl.h
@@ -1,7 +1,7 @@
/*
* Linux OS Independent Layer
*
- * Copyright 2006, Broadcom Corporation
+ * Copyright 2007, Broadcom Corporation
* All Rights Reserved.
*
* THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
@@ -9,7 +9,7 @@
* SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
*
- * $Id: linux_osl.h,v 1.1.1.13 2006/04/08 06:13:39 honor Exp $
+ * $Id$
*/
#ifndef _linux_osl_h_
@@ -19,17 +19,25 @@
#include <linuxver.h>
#include <osl.h>
-#define OSL_PKTTAG_SZ 32 /* Size of PktTag */
+#define OSL_PKTTAG_SZ 32 /* Size of PktTag */
-/* osl handle type forward declaration */
-typedef struct osl_dmainfo osldma_t;
+/* microsecond delay */
+extern void osl_delay(uint usec);
/* OSL initialization */
-extern osl_t *osl_attach(void *pdev, bool pkttag);
+extern osl_t *osl_attach(void *pdev, uint bustype, bool pkttag);
extern void osl_detach(osl_t *osh);
+#define PKTFREESETCB(osh, _tx_fn, _tx_ctx) \
+ do { \
+ ((osl_pubinfo_t*)osh)->tx_fn = _tx_fn; \
+ ((osl_pubinfo_t*)osh)->tx_ctx = _tx_ctx; \
+ } while (0)
+
/* host/bus architecture-specific byte swap */
#define BUS_SWAP32(v) (v)
+
+
#define MALLOC_FAILED(osh) osl_malloc_failed((osh))
extern void *osl_malloc(osl_t *osh, uint size);
@@ -37,61 +45,110 @@ extern void osl_mfree(osl_t *osh, void *addr, uint size);
extern uint osl_malloced(osl_t *osh);
extern uint osl_malloc_failed(osl_t *osh);
-/* API for DMA addressing capability */
-#define DMA_MAP(osh, va, size, direction, p) \
- osl_dma_map((osh), (va), (size), (direction))
-#define DMA_UNMAP(osh, pa, size, direction, p) \
- osl_dma_unmap((osh), (pa), (size), (direction))
-static inline uint
-osl_dma_map(void *osh, void *va, uint size, int direction)
-{
- int dir;
- struct pci_dev *dev;
-
- dev = (osh == NULL ? NULL : ((osl_t *)osh)->pdev);
- dir = (direction == DMA_TX)? PCI_DMA_TODEVICE: PCI_DMA_FROMDEVICE;
- return (pci_map_single(dev, va, size, dir));
-}
-
-static inline void
-osl_dma_unmap(void *osh, uint pa, uint size, int direction)
-{
- int dir;
- struct pci_dev *dev;
-
- dev = (osh == NULL ? NULL : ((osl_t *)osh)->pdev);
- dir = (direction == DMA_TX)? PCI_DMA_TODEVICE: PCI_DMA_FROMDEVICE;
- pci_unmap_single(dev, (uint32)pa, size, dir);
-}
-
-#define OSL_DMADDRWIDTH(osh, addrwidth) do {} while (0)
+/* allocate/free shared (dma-able) consistent memory */
#define DMA_CONSISTENT_ALIGN PAGE_SIZE
#define DMA_ALLOC_CONSISTENT(osh, size, pap, dmah) \
osl_dma_alloc_consistent((osh), (size), (pap))
#define DMA_FREE_CONSISTENT(osh, va, size, pa, dmah) \
osl_dma_free_consistent((osh), (void*)(va), (size), (pa))
-static inline void*
-osl_dma_alloc_consistent(osl_t *osh, uint size, ulong *pap)
-{
- return (pci_alloc_consistent(osh->pdev, size, (dma_addr_t*)pap));
-}
+extern void *osl_dma_alloc_consistent(osl_t *osh, uint size, ulong *pap);
+extern void osl_dma_free_consistent(osl_t *osh, void *va, uint size, ulong pa);
-static inline void
-osl_dma_free_consistent(osl_t *osh, void *va, uint size, ulong pa)
-{
- pci_free_consistent(osh->pdev, size, va, (dma_addr_t)pa);
-}
+/* map/unmap direction */
+#define DMA_TX 1 /* TX direction for DMA */
+#define DMA_RX 2 /* RX direction for DMA */
+
+/* map/unmap shared (dma-able) memory */
+#define DMA_MAP(osh, va, size, direction, p, dmah) \
+ osl_dma_map((osh), (va), (size), (direction))
+#define DMA_UNMAP(osh, pa, size, direction, p, dmah) \
+ osl_dma_unmap((osh), (pa), (size), (direction))
+extern uint osl_dma_map(osl_t *osh, void *va, uint size, int direction);
+extern void osl_dma_unmap(osl_t *osh, uint pa, uint size, int direction);
+/* API for DMA addressing capability */
+#define OSL_DMADDRWIDTH(osh, addrwidth) do {} while (0)
/* register access macros */
#if defined(BCMJTAG)
#include <bcmjtag.h>
-#define R_REG(osh, r) bcmjtag_read(NULL, (uint32)(r), sizeof(*(r)))
-#define W_REG(osh, r, v) bcmjtag_write(NULL, (uint32)(r), (uint32)(v), sizeof(*(r)))
-#endif /* defined(BCMSDIO) */
+#define OSL_WRITE_REG(osh, r, v) (bcmjtag_write(NULL, (uintptr)(r), (v), sizeof(*(r))))
+#define OSL_READ_REG(osh, r) (bcmjtag_read(NULL, (uintptr)(r), sizeof(*(r))))
+#endif
+
+#if defined(BCMJTAG)
+#define SELECT_BUS_WRITE(osh, mmap_op, bus_op) if (((osl_pubinfo_t*)(osh))->mmbus) \
+ mmap_op else bus_op
+#define SELECT_BUS_READ(osh, mmap_op, bus_op) (((osl_pubinfo_t*)(osh))->mmbus) ? \
+ mmap_op : bus_op
+#else
+#define SELECT_BUS_WRITE(osh, mmap_op, bus_op) mmap_op
+#define SELECT_BUS_READ(osh, mmap_op, bus_op) mmap_op
+#endif
+
+/*
+ * BINOSL selects the slightly slower function-call-based binary compatible osl.
+ * Macros expand to calls to functions defined in linux_osl.c .
+ */
+#ifndef BINOSL
+
+/* string library, kernel mode */
+#ifndef printf
+#define printf(fmt, args...) printk(fmt, ## args)
+#endif /* printf */
+#include <linux/kernel.h>
+#include <linux/string.h>
+
+/* register access macros */
+#define AND_REG(osh, r, v) W_REG(osh, (r), R_REG(osh, r) & (v))
+#define OR_REG(osh, r, v) W_REG(osh, (r), R_REG(osh, r) | (v))
+
+/* bcopy, bcmp, and bzero */
+#define bcopy(src, dst, len) memcpy((dst), (src), (len))
+#define bcmp(b1, b2, len) memcmp((b1), (b2), (len))
+#define bzero(b, len) memset((b), '\0', (len))
+
+/* uncached virtual address */
+#ifdef mips
+#define OSL_UNCACHED(va) KSEG1ADDR((va))
+#include <asm/addrspace.h>
+#else
+#define OSL_UNCACHED(va) (va)
+#endif /* mips */
+
+/* get processor cycle count */
+#if defined(mips)
+#define OSL_GETCYCLES(x) ((x) = read_c0_count() * 2)
+#elif defined(__i386__)
+#define OSL_GETCYCLES(x) rdtscl((x))
+#else
+#define OSL_GETCYCLES(x) ((x) = 0)
+#endif /* defined(mips) */
+
+/* dereference an address that may cause a bus exception */
+#ifdef mips
+#if defined(MODULE) && (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 17))
+#define BUSPROBE(val, addr) panic("get_dbe() will not fixup a bus exception when compiled into"\
+ " a module")
+#else
+#define BUSPROBE(val, addr) get_dbe((val), (addr))
+#include <asm/paccess.h>
+#endif /* defined(MODULE) && (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 17)) */
+#else
+#define BUSPROBE(val, addr) ({ (val) = R_REG(NULL, (addr)); 0; })
+#endif /* mips */
+
+/* map/unmap physical to virtual I/O */
+#define REG_MAP(pa, size) ioremap_nocache((unsigned long)(pa), (unsigned long)(size))
+#define REG_UNMAP(va) iounmap((void *)(va))
+
+/* shared (dma-able) memory access macros */
+#define R_SM(r) *(r)
+#define W_SM(r, v) (*(r) = (v))
+#define BZERO_SM(r, len) memset((r), '\0', (len))
/* packet primitives */
-#define PKTGET(osh, len, send) osl_pktget((osh), (len), (send))
+#define PKTGET(osh, len, send) osl_pktget((osh), (len))
#define PKTFREE(osh, skb, send) osl_pktfree((osh), (skb), (send))
#define PKTDATA(osh, skb) (((struct sk_buff*)(skb))->data)
#define PKTLEN(osh, skb) (((struct sk_buff*)(skb))->len)
@@ -104,15 +161,25 @@ osl_dma_free_consistent(osl_t *osh, void *va, uint size, ulong pa)
#define PKTPULL(osh, skb, bytes) skb_pull((struct sk_buff*)(skb), (bytes))
#define PKTDUP(osh, skb) osl_pktdup((osh), (skb))
#define PKTTAG(skb) ((void*)(((struct sk_buff*)(skb))->cb))
-#define PKTALLOCED(osh) osl_pktalloced((osh))
+#define PKTALLOCED(osh) ((osl_pubinfo_t *)(osh))->pktalloced
+#ifdef BCMDBG_PKT /* pkt logging for debugging */
+#define PKTLIST_DUMP(osh, buf) osl_pktlist_dump(osh, buf)
+#else /* BCMDBG_PKT */
#define PKTLIST_DUMP(osh, buf)
+#endif /* BCMDBG_PKT */
+
+#ifdef BCMDBG_PKT /* pkt logging for debugging */
+extern void osl_pktlist_add(osl_t *osh, void *p);
+extern void osl_pktlist_remove(osl_t *osh, void *p);
+extern char *osl_pktlist_dump(osl_t *osh, char *buf);
+#endif /* BCMDBG_PKT */
/* Convert a native(OS) packet to driver packet.
* In the process, native packet is destroyed, there is no copying
* Also, a packettag is zeroed out
*/
static INLINE void *
-osl_pkt_frmnative(osl_pubinfo_t*osh, struct sk_buff *skb)
+osl_pkt_frmnative(osl_pubinfo_t *osh, struct sk_buff *skb)
{
struct sk_buff *nskb;
@@ -121,13 +188,15 @@ osl_pkt_frmnative(osl_pubinfo_t*osh, struct sk_buff *skb)
/* Increment the packet counter */
for (nskb = skb; nskb; nskb = nskb->next) {
+#ifdef BCMDBG_PKT
+ osl_pktlist_add((osl_t *)osh, (void *) nskb);
+#endif /* BCMDBG_PKT */
osh->pktalloced++;
}
return (void *)skb;
}
-#define PKTFRMNATIVE(osh, skb) osl_pkt_frmnative(((osl_pubinfo_t*)osh), \
- (struct sk_buff*)(skb))
+#define PKTFRMNATIVE(osh, skb) osl_pkt_frmnative(((osl_pubinfo_t *)osh), (struct sk_buff*)(skb))
/* Convert a driver packet to native(OS) packet
* In the process, packettag is zeroed out before sending up
@@ -135,7 +204,7 @@ osl_pkt_frmnative(osl_pubinfo_t*osh, struct sk_buff *skb)
* In our case, that means it should be 0
*/
static INLINE struct sk_buff *
-osl_pkt_tonative(osl_pubinfo_t*osh, void *pkt)
+osl_pkt_tonative(osl_pubinfo_t *osh, void *pkt)
{
struct sk_buff *nskb;
@@ -144,24 +213,167 @@ osl_pkt_tonative(osl_pubinfo_t*osh, void *pkt)
/* Decrement the packet counter */
for (nskb = (struct sk_buff *)pkt; nskb; nskb = nskb->next) {
+#ifdef BCMDBG_PKT
+ osl_pktlist_remove((osl_t *)osh, (void *) nskb);
+#endif /* BCMDBG_PKT */
osh->pktalloced--;
}
return (struct sk_buff *)pkt;
}
-#define PKTTONATIVE(osh, pkt) osl_pkt_tonative((osl_pubinfo_t*)(osh), (pkt))
+#define PKTTONATIVE(osh, pkt) osl_pkt_tonative((osl_pubinfo_t *)(osh), (pkt))
#define PKTLINK(skb) (((struct sk_buff*)(skb))->prev)
#define PKTSETLINK(skb, x) (((struct sk_buff*)(skb))->prev = (struct sk_buff*)(x))
#define PKTPRIO(skb) (((struct sk_buff*)(skb))->priority)
#define PKTSETPRIO(skb, x) (((struct sk_buff*)(skb))->priority = (x))
+#define PKTSUMNEEDED(skb) (((struct sk_buff*)(skb))->ip_summed == CHECKSUM_HW)
+#define PKTSETSUMGOOD(skb, x) (((struct sk_buff*)(skb))->ip_summed = \
+ ((x) ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE))
+/* PKTSETSUMNEEDED and PKTSUMGOOD are not possible because skb->ip_summed is overloaded */
#define PKTSHARED(skb) (((struct sk_buff*)(skb))->cloned)
-extern void *osl_pktget(osl_t *osh, uint len, bool send);
+extern void *osl_pktget(osl_t *osh, uint len);
+extern void osl_pktfree(osl_t *osh, void *skb, bool send);
+extern void *osl_pktdup(osl_t *osh, void *skb);
+#else /* BINOSL */
+
+/* string library */
+#ifndef LINUX_OSL
+#undef printf
+#define printf(fmt, args...) osl_printf((fmt), ## args)
+#undef sprintf
+#define sprintf(buf, fmt, args...) osl_sprintf((buf), (fmt), ## args)
+#undef strcmp
+#define strcmp(s1, s2) osl_strcmp((s1), (s2))
+#undef strncmp
+#define strncmp(s1, s2, n) osl_strncmp((s1), (s2), (n))
+#undef strlen
+#define strlen(s) osl_strlen((s))
+#undef strcpy
+#define strcpy(d, s) osl_strcpy((d), (s))
+#undef strncpy
+#define strncpy(d, s, n) osl_strncpy((d), (s), (n))
+#endif /* LINUX_OSL */
+extern int osl_printf(const char *format, ...);
+extern int osl_sprintf(char *buf, const char *format, ...);
+extern int osl_strcmp(const char *s1, const char *s2);
+extern int osl_strncmp(const char *s1, const char *s2, uint n);
+extern int osl_strlen(const char *s);
+extern char* osl_strcpy(char *d, const char *s);
+extern char* osl_strncpy(char *d, const char *s, uint n);
+
+/* register access macros */
+#if !defined(BCMJTAG)
+#define R_REG(osh, r) (\
+ sizeof(*(r)) == sizeof(uint8) ? osl_readb((volatile uint8*)(r)) : \
+ sizeof(*(r)) == sizeof(uint16) ? osl_readw((volatile uint16*)(r)) : \
+ osl_readl((volatile uint32*)(r)) \
+)
+#define W_REG(osh, r, v) do { \
+ switch (sizeof(*(r))) { \
+ case sizeof(uint8): osl_writeb((uint8)(v), (volatile uint8*)(r)); break; \
+ case sizeof(uint16): osl_writew((uint16)(v), (volatile uint16*)(r)); break; \
+ case sizeof(uint32): osl_writel((uint32)(v), (volatile uint32*)(r)); break; \
+ } \
+} while (0)
+#endif
+
+#define AND_REG(osh, r, v) W_REG(osh, (r), R_REG(osh, r) & (v))
+#define OR_REG(osh, r, v) W_REG(osh, (r), R_REG(osh, r) | (v))
+extern uint8 osl_readb(volatile uint8 *r);
+extern uint16 osl_readw(volatile uint16 *r);
+extern uint32 osl_readl(volatile uint32 *r);
+extern void osl_writeb(uint8 v, volatile uint8 *r);
+extern void osl_writew(uint16 v, volatile uint16 *r);
+extern void osl_writel(uint32 v, volatile uint32 *r);
+
+/* bcopy, bcmp, and bzero */
+extern void bcopy(const void *src, void *dst, int len);
+extern int bcmp(const void *b1, const void *b2, int len);
+extern void bzero(void *b, int len);
+
+/* uncached virtual address */
+#define OSL_UNCACHED(va) osl_uncached((va))
+extern void *osl_uncached(void *va);
+
+/* get processor cycle count */
+#define OSL_GETCYCLES(x) ((x) = osl_getcycles())
+extern uint osl_getcycles(void);
+
+/* dereference an address that may target abort */
+#define BUSPROBE(val, addr) osl_busprobe(&(val), (addr))
+extern int osl_busprobe(uint32 *val, uint32 addr);
+
+/* map/unmap physical to virtual */
+#define REG_MAP(pa, size) osl_reg_map((pa), (size))
+#define REG_UNMAP(va) osl_reg_unmap((va))
+extern void *osl_reg_map(uint32 pa, uint size);
+extern void osl_reg_unmap(void *va);
+
+/* shared (dma-able) memory access macros */
+#define R_SM(r) *(r)
+#define W_SM(r, v) (*(r) = (v))
+#define BZERO_SM(r, len) bzero((r), (len))
+
+/* packet primitives */
+#define PKTGET(osh, len, send) osl_pktget((osh), (len))
+#define PKTFREE(osh, skb, send) osl_pktfree((osh), (skb), (send))
+#define PKTDATA(osh, skb) osl_pktdata((osh), (skb))
+#define PKTLEN(osh, skb) osl_pktlen((osh), (skb))
+#define PKTHEADROOM(osh, skb) osl_pktheadroom((osh), (skb))
+#define PKTTAILROOM(osh, skb) osl_pkttailroom((osh), (skb))
+#define PKTNEXT(osh, skb) osl_pktnext((osh), (skb))
+#define PKTSETNEXT(osh, skb, x) osl_pktsetnext((skb), (x))
+#define PKTSETLEN(osh, skb, len) osl_pktsetlen((osh), (skb), (len))
+#define PKTPUSH(osh, skb, bytes) osl_pktpush((osh), (skb), (bytes))
+#define PKTPULL(osh, skb, bytes) osl_pktpull((osh), (skb), (bytes))
+#define PKTDUP(osh, skb) osl_pktdup((osh), (skb))
+#define PKTTAG(skb) osl_pkttag((skb))
+#define PKTFRMNATIVE(osh, skb) osl_pkt_frmnative((osh), (struct sk_buff*)(skb))
+#define PKTTONATIVE(osh, pkt) osl_pkt_tonative((osh), (pkt))
+#define PKTLINK(skb) osl_pktlink((skb))
+#define PKTSETLINK(skb, x) osl_pktsetlink((skb), (x))
+#define PKTPRIO(skb) osl_pktprio((skb))
+#define PKTSETPRIO(skb, x) osl_pktsetprio((skb), (x))
+#define PKTSHARED(skb) osl_pktshared((skb))
+#define PKTALLOCED(osh) osl_pktalloced((osh))
+#ifdef BCMDBG_PKT
+#define PKTLIST_DUMP(osh, buf) osl_pktlist_dump(osh, buf)
+#else /* BCMDBG_PKT */
+#define PKTLIST_DUMP(osh, buf)
+#endif /* BCMDBG_PKT */
+
+extern void *osl_pktget(osl_t *osh, uint len);
extern void osl_pktfree(osl_t *osh, void *skb, bool send);
+extern uchar *osl_pktdata(osl_t *osh, void *skb);
+extern uint osl_pktlen(osl_t *osh, void *skb);
+extern uint osl_pktheadroom(osl_t *osh, void *skb);
+extern uint osl_pkttailroom(osl_t *osh, void *skb);
+extern void *osl_pktnext(osl_t *osh, void *skb);
+extern void osl_pktsetnext(void *skb, void *x);
+extern void osl_pktsetlen(osl_t *osh, void *skb, uint len);
+extern uchar *osl_pktpush(osl_t *osh, void *skb, int bytes);
+extern uchar *osl_pktpull(osl_t *osh, void *skb, int bytes);
extern void *osl_pktdup(osl_t *osh, void *skb);
+extern void *osl_pkttag(void *skb);
+extern void *osl_pktlink(void *skb);
+extern void osl_pktsetlink(void *skb, void *x);
+extern uint osl_pktprio(void *skb);
+extern void osl_pktsetprio(void *skb, uint x);
+extern void *osl_pkt_frmnative(osl_t *osh, struct sk_buff *skb);
+extern struct sk_buff *osl_pkt_tonative(osl_t *osh, void *pkt);
+extern bool osl_pktshared(void *skb);
extern uint osl_pktalloced(osl_t *osh);
+#ifdef BCMDBG_PKT /* pkt logging for debugging */
+extern char *osl_pktlist_dump(osl_t *osh, char *buf);
+extern void osl_pktlist_add(osl_t *osh, void *p);
+extern void osl_pktlist_remove(osl_t *osh, void *p);
+#endif /* BCMDBG_PKT */
+
+#endif /* BINOSL */
+
#define OSL_ERROR(bcmerror) osl_error(bcmerror)
extern int osl_error(int bcmerror);
diff --git a/package/broadcom-wl/src/driver/patchtable.pl b/package/broadcom-wl/src/driver/patchtable.pl
deleted file mode 100644
index 6999735..0000000
--- a/package/broadcom-wl/src/driver/patchtable.pl
+++ /dev/null
@@ -1,61 +0,0 @@
-#!/usr/bin/perl
-#
-# Copyright (C) 2006 OpenWrt.org
-# Copyright (C) 2006 Felix Fietkau
-#
-# This is free software, licensed under the GNU General Public License v2.
-# See /LICENSE for more information.
-#
-use strict;
-
-my $TABLE = pack("V", 0xbadc0ded);
-my $TABLE_SIZE = 512;
-my $SLT1 = "\x01\x00\x00\x00";
-my $SLT2 = "\x02\x00\x00\x00";
-my $ACKW = "\x03\x00\x00\x00";
-my $PTABLE_END = "\xff\xff\xff\xff";
-
-my $addr = "";
-my $opcode = "";
-my $function = "";
-
-sub add_entry {
- my $key = shift;
- my $value = shift;
- my $default = shift;
-
- $TABLE .= $key;
- $TABLE .= pack("V", $value);
- $TABLE .= pack("V", $default);
-}
-
-while (<>) {
- $addr = $opcode = "";
- /^\w{8}\s*<(.*)>:$/ and $function = $1;
- /^\s*(\w+):\s*(\w{8})\s*/ and do {
- $addr = $1;
- $opcode = $2;
- };
-
- ($function eq 'wlc_update_slot_timing') and do {
- # li a2,9 -- short slot time
- ($opcode eq '24060009') and add_entry($SLT1, hex($addr), hex($opcode));
- # li v0,519 -- 510 + short slot time
- ($opcode eq '24020207') and add_entry($SLT2, hex($addr), hex($opcode));
-
- # li a2,20 -- long slot time
- ($opcode eq '24060014') and add_entry($SLT1, hex($addr), hex($opcode));
- # li v0,530 -- 510 + long slot time
- ($opcode eq '24020212') and add_entry($SLT2, hex($addr), hex($opcode));
- };
- ($function eq 'wlc_d11hdrs') and do {
- # ori s6,s6,0x1 -- ack flag (new)
- ($opcode eq '36d60001') and add_entry($ACKW, hex($addr), hex($opcode));
- # ori s3,s3,0x1 -- ack flag (old)
- ($opcode eq '36730001') and add_entry($ACKW, hex($addr), hex($opcode));
- }
-}
-
-$TABLE .= $PTABLE_END;
-$TABLE .= ("\x00" x ($TABLE_SIZE - length($TABLE)));
-print $TABLE;
diff --git a/package/broadcom-wl/src/driver/pktq.h b/package/broadcom-wl/src/driver/pktq.h
deleted file mode 100644
index 7fe2181..0000000
--- a/package/broadcom-wl/src/driver/pktq.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Misc useful os-independent macros and functions.
- *
- * Copyright 2006, Broadcom Corporation
- * All Rights Reserved.
- *
- * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
- * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
- * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
- * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
- * $Id: bcmutils.h,v 1.1.1.16 2006/04/08 06:13:39 honor Exp $
- */
-
-#ifndef _pktq_h_
-#define _pktq_h_
-#include <osl.h>
-
-/* osl multi-precedence packet queue */
-
-#define PKTQ_LEN_DEFAULT 128 /* Max 128 packets */
-#define PKTQ_MAX_PREC 16 /* Maximum precedence levels */
-
-struct pktq {
- struct pktq_prec {
- void *head; /* first packet to dequeue */
- void *tail; /* last packet to dequeue */
- uint16 len; /* number of queued packets */
- uint16 max; /* maximum number of queued packets */
- } q[PKTQ_MAX_PREC];
- uint16 num_prec; /* number of precedences in use */
- uint16 hi_prec; /* rapid dequeue hint (>= highest non-empty prec) */
- uint16 max; /* total max packets */
- uint16 len; /* total number of packets */
-};
-
-#define PKTQ_PREC_ITER(pq, prec) for (prec = (pq)->num_prec - 1; prec >= 0; prec--)
-
-/* forward definition of ether_addr structure used by some function prototypes */
-
-struct ether_addr;
-
-/* operations on a specific precedence in packet queue */
-
-#define pktq_psetmax(pq, prec, _max) ((pq)->q[prec].max = (_max))
-#define pktq_plen(pq, prec) ((pq)->q[prec].len)
-#define pktq_pavail(pq, prec) ((pq)->q[prec].max - (pq)->q[prec].len)
-#define pktq_pfull(pq, prec) ((pq)->q[prec].len >= (pq)->q[prec].max)
-#define pktq_pempty(pq, prec) ((pq)->q[prec].len == 0)
-
-#define pktq_ppeek(pq, prec) ((pq)->q[prec].head)
-#define pktq_ppeek_tail(pq, prec) ((pq)->q[prec].tail)
-
-extern void *pktq_penq(struct pktq *pq, int prec, void *p);
-extern void *pktq_penq_head(struct pktq *pq, int prec, void *p);
-extern void *pktq_pdeq(struct pktq *pq, int prec);
-extern void *pktq_pdeq_tail(struct pktq *pq, int prec);
-/* Empty the queue at particular precedence level */
-extern void pktq_pflush(osl_t *osh, struct pktq *pq, int prec, bool dir);
-/* Remove a specified packet from its queue */
-extern bool pktq_pdel(struct pktq *pq, void *p, int prec);
-
-/* operations on a set of precedences in packet queue */
-
-extern int pktq_mlen(struct pktq *pq, uint prec_bmp);
-extern void *pktq_mdeq(struct pktq *pq, uint prec_bmp, int *prec_out);
-
-/* operations on packet queue as a whole */
-
-#define pktq_len(pq) ((int)(pq)->len)
-#define pktq_max(pq) ((int)(pq)->max)
-#define pktq_avail(pq) ((int)((pq)->max - (pq)->len))
-#define pktq_full(pq) ((pq)->len >= (pq)->max)
-#define pktq_empty(pq) ((pq)->len == 0)
-
-/* operations for single precedence queues */
-#define pktenq(pq, p) pktq_penq((pq), 0, (p))
-#define pktenq_head(pq, p) pktq_penq_head((pq), 0, (p))
-#define pktdeq(pq) pktq_pdeq((pq), 0)
-#define pktdeq_tail(pq) pktq_pdeq_tail((pq), 0)
-
-extern void pktq_init(struct pktq *pq, int num_prec, int max_len);
-/* prec_out may be NULL if caller is not interested in return value */
-extern void *pktq_deq(struct pktq *pq, int *prec_out);
-extern void *pktq_deq_tail(struct pktq *pq, int *prec_out);
-extern void *pktq_peek(struct pktq *pq, int *prec_out);
-extern void *pktq_peek_tail(struct pktq *pq, int *prec_out);
-extern void pktq_flush(osl_t *osh, struct pktq *pq, bool dir); /* Empty the entire queue */
-
-/* externs */
-/* packet */
-extern uint pktcopy(osl_t *osh, void *p, uint offset, int len, uchar *buf);
-extern uint pkttotlen(osl_t *osh, void *p);
-extern void *pktlast(osl_t *osh, void *p);
-
-extern void pktsetprio(void *pkt, bool update_vtag);
-
-#endif /* _pktq_h_ */
diff --git a/package/broadcom-wl/src/driver/proto/802.11.h b/package/broadcom-wl/src/driver/proto/802.11.h
new file mode 100644
index 0000000..83f4612
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/802.11.h
@@ -0,0 +1,1387 @@
+/*
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ *
+ * Fundamental types and constants relating to 802.11
+ *
+ * $Id$
+ */
+
+#ifndef _802_11_H_
+#define _802_11_H_
+
+#ifndef _TYPEDEFS_H_
+#include <typedefs.h>
+#endif
+
+#ifndef _NET_ETHERNET_H_
+#include <proto/ethernet.h>
+#endif
+
+#include <proto/wpa.h>
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+#define DOT11_TU_TO_US 1024 /* 802.11 Time Unit is 1024 microseconds */
+
+/* Generic 802.11 frame constants */
+#define DOT11_A3_HDR_LEN 24 /* d11 header length with A3 */
+#define DOT11_A4_HDR_LEN 30 /* d11 header length with A4 */
+#define DOT11_MAC_HDR_LEN DOT11_A3_HDR_LEN /* MAC header length */
+#define DOT11_FCS_LEN 4 /* d11 FCS length */
+#define DOT11_ICV_LEN 4 /* d11 ICV length */
+#define DOT11_ICV_AES_LEN 8 /* d11 ICV/AES length */
+#define DOT11_QOS_LEN 2 /* d11 QoS length */
+#define DOT11_HTC_LEN 4 /* d11 HT Control field length */
+
+#define DOT11_KEY_INDEX_SHIFT 6 /* d11 key index shift */
+#define DOT11_IV_LEN 4 /* d11 IV length */
+#define DOT11_IV_TKIP_LEN 8 /* d11 IV TKIP length */
+#define DOT11_IV_AES_OCB_LEN 4 /* d11 IV/AES/OCB length */
+#define DOT11_IV_AES_CCM_LEN 8 /* d11 IV/AES/CCM length */
+#define DOT11_IV_MAX_LEN 8 /* maximum iv len for any encryption */
+
+/* Includes MIC */
+#define DOT11_MAX_MPDU_BODY_LEN 2304 /* max MPDU body length */
+/* A4 header + QoS + CCMP + PDU + ICV + FCS = 2352 */
+#define DOT11_MAX_MPDU_LEN (DOT11_A4_HDR_LEN + \
+ DOT11_QOS_LEN + \
+ DOT11_IV_AES_CCM_LEN + \
+ DOT11_MAX_MPDU_BODY_LEN + \
+ DOT11_ICV_LEN + \
+ DOT11_FCS_LEN) /* d11 max MPDU length */
+
+#define DOT11_MAX_SSID_LEN 32 /* d11 max ssid length */
+
+/* dot11RTSThreshold */
+#define DOT11_DEFAULT_RTS_LEN 2347 /* d11 default RTS length */
+#define DOT11_MAX_RTS_LEN 2347 /* d11 max RTS length */
+
+/* dot11FragmentationThreshold */
+#define DOT11_MIN_FRAG_LEN 256 /* d11 min fragmentation length */
+#define DOT11_MAX_FRAG_LEN 2346 /* Max frag is also limited by aMPDUMaxLength
+ * of the attached PHY
+ */
+#define DOT11_DEFAULT_FRAG_LEN 2346 /* d11 default fragmentation length */
+
+/* dot11BeaconPeriod */
+#define DOT11_MIN_BEACON_PERIOD 1 /* d11 min beacon period */
+#define DOT11_MAX_BEACON_PERIOD 0xFFFF /* d11 max beacon period */
+
+/* dot11DTIMPeriod */
+#define DOT11_MIN_DTIM_PERIOD 1 /* d11 min DTIM period */
+#define DOT11_MAX_DTIM_PERIOD 0xFF /* d11 max DTIM period */
+
+/* 802.2 LLC/SNAP header used by 802.11 per 802.1H */
+#define DOT11_LLC_SNAP_HDR_LEN 8 /* d11 LLC/SNAP header length */
+#define DOT11_OUI_LEN 3 /* d11 OUI length */
+struct dot11_llc_snap_header {
+ uint8 dsap; /* always 0xAA */
+ uint8 ssap; /* always 0xAA */
+ uint8 ctl; /* always 0x03 */
+ uint8 oui[DOT11_OUI_LEN]; /* RFC1042: 0x00 0x00 0x00
+ * Bridge-Tunnel: 0x00 0x00 0xF8
+ */
+ uint16 type; /* ethertype */
+} PACKED;
+
+/* RFC1042 header used by 802.11 per 802.1H */
+#define RFC1042_HDR_LEN (ETHER_HDR_LEN + DOT11_LLC_SNAP_HDR_LEN) /* RCF1042 header length */
+
+/* Generic 802.11 MAC header */
+/*
+ * N.B.: This struct reflects the full 4 address 802.11 MAC header.
+ * The fields are defined such that the shorter 1, 2, and 3
+ * address headers just use the first k fields.
+ */
+struct dot11_header {
+ uint16 fc; /* frame control */
+ uint16 durid; /* duration/ID */
+ struct ether_addr a1; /* address 1 */
+ struct ether_addr a2; /* address 2 */
+ struct ether_addr a3; /* address 3 */
+ uint16 seq; /* sequence control */
+ struct ether_addr a4; /* address 4 */
+} PACKED;
+
+/* Control frames */
+
+struct dot11_rts_frame {
+ uint16 fc; /* frame control */
+ uint16 durid; /* duration/ID */
+ struct ether_addr ra; /* receiver address */
+ struct ether_addr ta; /* transmitter address */
+} PACKED;
+#define DOT11_RTS_LEN 16 /* d11 RTS frame length */
+
+struct dot11_cts_frame {
+ uint16 fc; /* frame control */
+ uint16 durid; /* duration/ID */
+ struct ether_addr ra; /* receiver address */
+} PACKED;
+#define DOT11_CTS_LEN 10 /* d11 CTS frame length */
+
+struct dot11_ack_frame {
+ uint16 fc; /* frame control */
+ uint16 durid; /* duration/ID */
+ struct ether_addr ra; /* receiver address */
+} PACKED;
+#define DOT11_ACK_LEN 10 /* d11 ACK frame length */
+
+struct dot11_ps_poll_frame {
+ uint16 fc; /* frame control */
+ uint16 durid; /* AID */
+ struct ether_addr bssid; /* receiver address, STA in AP */
+ struct ether_addr ta; /* transmitter address */
+} PACKED;
+#define DOT11_PS_POLL_LEN 16 /* d11 PS poll frame length */
+
+struct dot11_cf_end_frame {
+ uint16 fc; /* frame control */
+ uint16 durid; /* duration/ID */
+ struct ether_addr ra; /* receiver address */
+ struct ether_addr bssid; /* transmitter address, STA in AP */
+} PACKED;
+#define DOT11_CS_END_LEN 16 /* d11 CF-END frame length */
+
+/* BA/BAR Control parameters */
+#define DOT11_BA_CTL_POLICY_NORMAL 0x0000 /* normal ack */
+#define DOT11_BA_CTL_POLICY_NOACK 0x0001 /* no ack */
+#define DOT11_BA_CTL_POLICY_MASK 0x0001 /* ack policy mask */
+
+#define DOT11_BA_CTL_MTID 0x0002 /* multi tid BA */
+#define DOT11_BA_CTL_COMPRESSED 0x0004 /* compressed bitmap */
+
+#define DOT11_BA_CTL_NUMMSDU_MASK 0x0FC0 /* num msdu in bitmap mask */
+#define DOT11_BA_CTL_NUMMSDU_SHIFT 6 /* num msdu in bitmap shift */
+
+#define DOT11_BA_CTL_TID_MASK 0xF000 /* tid mask */
+#define DOT11_BA_CTL_TID_SHIFT 12 /* tid shift */
+
+/* control frame header (BA/BAR) */
+struct dot11_ctl_header {
+ uint16 fc; /* frame control */
+ uint16 durid; /* duration/ID */
+ struct ether_addr ra; /* receiver address */
+ struct ether_addr ta; /* transmitter address */
+} PACKED;
+#define DOT11_CTL_HDR_LEN 16 /* control frame hdr len */
+
+/* BAR frame payload */
+struct dot11_bar {
+ uint16 bar_control; /* BAR Control */
+ uint16 seqnum; /* Starting Sequence control */
+} PACKED;
+#define DOT11_BAR_LEN 4 /* BAR frame payload length */
+
+#define DOT11_BA_BITMAP_LEN 128 /* bitmap length */
+#define DOT11_BA_CMP_BITMAP_LEN 8 /* compressed bitmap length */
+/* BA frame payload */
+struct dot11_ba {
+ uint16 ba_control; /* BA Control */
+ uint16 seqnum; /* Starting Sequence control */
+ uint8 bitmap[DOT11_BA_BITMAP_LEN]; /* Block Ack Bitmap */
+} PACKED;
+#define DOT11_BA_LEN 4 /* BA frame payload len (wo bitmap) */
+
+/* Management frame header */
+struct dot11_management_header {
+ uint16 fc; /* frame control */
+ uint16 durid; /* duration/ID */
+ struct ether_addr da; /* receiver address */
+ struct ether_addr sa; /* transmitter address */
+ struct ether_addr bssid; /* BSS ID */
+ uint16 seq; /* sequence control */
+} PACKED;
+#define DOT11_MGMT_HDR_LEN 24 /* d11 management header length */
+
+/* Management frame payloads */
+
+struct dot11_bcn_prb {
+ uint32 timestamp[2];
+ uint16 beacon_interval;
+ uint16 capability;
+} PACKED;
+#define DOT11_BCN_PRB_LEN 12 /* 802.11 beacon/probe frame fixed length */
+
+struct dot11_auth {
+ uint16 alg; /* algorithm */
+ uint16 seq; /* sequence control */
+ uint16 status; /* status code */
+} PACKED;
+#define DOT11_AUTH_FIXED_LEN 6 /* length of auth frame without challenge info
+ * elt
+ */
+
+struct dot11_assoc_req {
+ uint16 capability; /* capability information */
+ uint16 listen; /* listen interval */
+} PACKED;
+#define DOT11_ASSOC_REQ_FIXED_LEN 4 /* length of assoc frame without info elts */
+
+struct dot11_reassoc_req {
+ uint16 capability; /* capability information */
+ uint16 listen; /* listen interval */
+ struct ether_addr ap; /* Current AP address */
+} PACKED;
+#define DOT11_REASSOC_REQ_FIXED_LEN 10 /* length of assoc frame without info elts */
+
+struct dot11_assoc_resp {
+ uint16 capability; /* capability information */
+ uint16 status; /* status code */
+ uint16 aid; /* association ID */
+} PACKED;
+
+struct dot11_action_measure {
+ uint8 category;
+ uint8 action;
+ uint8 token;
+ uint8 data[1];
+} PACKED;
+#define DOT11_ACTION_MEASURE_LEN 3 /* d11 action measurement header length */
+
+struct dot11_action_ht_ch_width {
+ uint8 category;
+ uint8 action;
+ uint8 ch_width;
+} PACKED;
+
+struct dot11_action_ht_mimops {
+ uint8 category;
+ uint8 action;
+ uint8 control;
+} PACKED;
+
+#define SM_PWRSAVE_ENABLE 1
+#define SM_PWRSAVE_MODE 2
+
+struct dot11_action_ht_info_xchg {
+ uint8 category;
+ uint8 action;
+ uint8 info;
+} PACKED;
+
+#define DOT11_HT_INFO_XCHG_INFO_REQ 0x01
+#define DOT11_HT_INFO_XCHG_40MHZ_INTOLERANT 0x02
+#define DOT11_HT_INFO_XCHG_STA_CHAN_WIDTH 0x04
+
+
+/* ************* 802.11h related definitions. ************* */
+struct dot11_power_cnst {
+ uint8 id;
+ uint8 len;
+ uint8 power;
+} PACKED;
+typedef struct dot11_power_cnst dot11_power_cnst_t;
+
+struct dot11_power_cap {
+ uint8 min;
+ uint8 max;
+} PACKED;
+typedef struct dot11_power_cap dot11_power_cap_t;
+
+struct dot11_tpc_rep {
+ uint8 id;
+ uint8 len;
+ uint8 tx_pwr;
+ uint8 margin;
+} PACKED;
+typedef struct dot11_tpc_rep dot11_tpc_rep_t;
+#define DOT11_MNG_IE_TPC_REPORT_LEN 2 /* length of IE data, not including 2 byte header */
+
+struct dot11_supp_channels {
+ uint8 id;
+ uint8 len;
+ uint8 first_channel;
+ uint8 num_channels;
+} PACKED;
+typedef struct dot11_supp_channels dot11_supp_channels_t;
+
+/* Extension Channel Offset IE: 802.11n-D1.0 spec. added sideband
+ * offset for 40MHz operation. The possible 3 values are:
+ * 1 = above control channel
+ * 3 = below control channel
+ * 0 = no extension channel
+ */
+struct dot11_extch {
+ uint8 id; /* IE ID, 62, DOT11_MNG_EXT_CHANNEL_OFFSET */
+ uint8 len; /* IE length */
+ uint8 extch;
+} PACKED;
+typedef struct dot11_extch dot11_extch_ie_t;
+
+struct dot11_brcm_extch {
+ uint8 id; /* IE ID, 221, DOT11_MNG_PROPR_ID */
+ uint8 len; /* IE length */
+ uint8 oui[3]; /* Proprietary OUI, BRCM_OUI */
+ uint8 type; /* type inidicates what follows */
+ uint8 extch;
+} PACKED;
+typedef struct dot11_brcm_extch dot11_brcm_extch_ie_t;
+
+#define BRCM_EXTCH_IE_LEN 5
+#define BRCM_EXTCH_IE_TYPE 53 /* 802.11n ID not yet assigned */
+#define DOT11_EXTCH_IE_LEN 1
+#define DOT11_EXT_CH_MASK 0x03 /* extension channel mask */
+#define DOT11_EXT_CH_UPPER 0x01 /* ext. ch. on upper sb */
+#define DOT11_EXT_CH_LOWER 0x03 /* ext. ch. on lower sb */
+#define DOT11_EXT_CH_NONE 0x00 /* no extension ch. */
+
+struct dot11_action_frmhdr {
+ uint8 category;
+ uint8 action;
+ uint8 data[1];
+} PACKED;
+
+/* CSA IE data structure */
+struct dot11_channel_switch {
+ uint8 id; /* id DOT11_MNG_CHANNEL_SWITCH_ID */
+ uint8 len; /* length of IE */
+ uint8 mode; /* mode 0 or 1 */
+ uint8 channel; /* channel switch to */
+ uint8 count; /* number of beacons before switching */
+} PACKED;
+typedef struct dot11_channel_switch dot11_chan_switch_ie_t;
+
+#define DOT11_SWITCH_IE_LEN 3 /* length of IE data, not including 2 byte header */
+/* CSA mode - 802.11h-2003 $7.3.2.20 */
+#define DOT11_CSA_MODE_ADVISORY 0 /* no DOT11_CSA_MODE_NO_TX restriction imposed */
+#define DOT11_CSA_MODE_NO_TX 1 /* no transmission upon receiving CSA frame. */
+
+struct dot11_action_switch_channel {
+ uint8 category;
+ uint8 action;
+ dot11_chan_switch_ie_t chan_switch_ie; /* for switch IE */
+ dot11_brcm_extch_ie_t extch_ie; /* extension channel offset */
+} PACKED;
+
+/* 11n Extended Channel Switch IE data structure */
+struct dot11_ext_csa {
+ uint8 id; /* id DOT11_MNG_EXT_CHANNEL_SWITCH_ID */
+ uint8 len; /* length of IE */
+ uint8 mode; /* mode 0 or 1 */
+ uint8 reg; /* regulatory class */
+ uint8 channel; /* channel switch to */
+ uint8 count; /* number of beacons before switching */
+} PACKED;
+typedef struct dot11_ext_csa dot11_ext_csa_ie_t;
+#define DOT11_EXT_CSA_IE_LEN 4 /* length of extended channel switch IE body */
+
+struct dot11_action_ext_csa {
+ uint8 category;
+ uint8 action;
+ dot11_ext_csa_ie_t chan_switch_ie; /* for switch IE */
+} PACKED;
+
+/* 802.11h Measurement Request/Report IEs */
+/* Measurement Type field */
+#define DOT11_MEASURE_TYPE_BASIC 0 /* d11 measurement basic type */
+#define DOT11_MEASURE_TYPE_CCA 1 /* d11 measurement CCA type */
+#define DOT11_MEASURE_TYPE_RPI 2 /* d11 measurement PRI type */
+
+/* Measurement Request Modes */
+#define DOT11_MEASURE_MODE_ENABLE (1<<1) /* d11 measurement enable */
+#define DOT11_MEASURE_MODE_REQUEST (1<<2) /* d11 measurement request */
+#define DOT11_MEASURE_MODE_REPORT (1<<3) /* d11 measurement report */
+/* Measurement Report Modes */
+#define DOT11_MEASURE_MODE_LATE (1<<0) /* d11 measurement late */
+#define DOT11_MEASURE_MODE_INCAPABLE (1<<1) /* d11 measurement incapable */
+#define DOT11_MEASURE_MODE_REFUSED (1<<2) /* d11 measurement refuse */
+/* Basic Measurement Map bits */
+#define DOT11_MEASURE_BASIC_MAP_BSS ((uint8)(1<<0)) /* d11 measurement basic map BSS */
+#define DOT11_MEASURE_BASIC_MAP_OFDM ((uint8)(1<<1)) /* d11 measurement map OFDM */
+#define DOT11_MEASURE_BASIC_MAP_UKNOWN ((uint8)(1<<2)) /* d11 measurement map unknown */
+#define DOT11_MEASURE_BASIC_MAP_RADAR ((uint8)(1<<3)) /* d11 measurement map radar */
+#define DOT11_MEASURE_BASIC_MAP_UNMEAS ((uint8)(1<<4)) /* d11 measurement map unmeasuremnt */
+
+struct dot11_meas_req {
+ uint8 id;
+ uint8 len;
+ uint8 token;
+ uint8 mode;
+ uint8 type;
+ uint8 channel;
+ uint8 start_time[8];
+ uint16 duration;
+} PACKED;
+typedef struct dot11_meas_req dot11_meas_req_t;
+#define DOT11_MNG_IE_MREQ_LEN 14 /* d11 measurement request IE length */
+/* length of Measure Request IE data not including variable len */
+#define DOT11_MNG_IE_MREQ_FIXED_LEN 3 /* d11 measurement request IE fixed length */
+
+struct dot11_meas_rep {
+ uint8 id;
+ uint8 len;
+ uint8 token;
+ uint8 mode;
+ uint8 type;
+ union
+ {
+ struct {
+ uint8 channel;
+ uint8 start_time[8];
+ uint16 duration;
+ uint8 map;
+ } PACKED basic;
+ uint8 data[1];
+ } PACKED rep;
+} PACKED;
+typedef struct dot11_meas_rep dot11_meas_rep_t;
+
+/* length of Measure Report IE data not including variable len */
+#define DOT11_MNG_IE_MREP_FIXED_LEN 3 /* d11 measurement response IE fixed length */
+
+struct dot11_meas_rep_basic {
+ uint8 channel;
+ uint8 start_time[8];
+ uint16 duration;
+ uint8 map;
+} PACKED;
+typedef struct dot11_meas_rep_basic dot11_meas_rep_basic_t;
+#define DOT11_MEASURE_BASIC_REP_LEN 12 /* d11 measurement basic report length */
+
+struct dot11_quiet {
+ uint8 id;
+ uint8 len;
+ uint8 count; /* TBTTs until beacon interval in quiet starts */
+ uint8 period; /* Beacon intervals between periodic quiet periods ? */
+ uint16 duration; /* Length of quiet period, in TU's */
+ uint16 offset; /* TU's offset from TBTT in Count field */
+} PACKED;
+typedef struct dot11_quiet dot11_quiet_t;
+
+struct chan_map_tuple {
+ uint8 channel;
+ uint8 map;
+} PACKED;
+typedef struct chan_map_tuple chan_map_tuple_t;
+
+struct dot11_ibss_dfs {
+ uint8 id;
+ uint8 len;
+ uint8 eaddr[ETHER_ADDR_LEN];
+ uint8 interval;
+ chan_map_tuple_t map[1];
+} PACKED;
+typedef struct dot11_ibss_dfs dot11_ibss_dfs_t;
+
+/* WME Elements */
+#define WME_OUI "\x00\x50\xf2" /* WME OUI */
+#define WME_VER 1 /* WME version */
+#define WME_TYPE 2 /* WME type */
+#define WME_SUBTYPE_IE 0 /* Information Element */
+#define WME_SUBTYPE_PARAM_IE 1 /* Parameter Element */
+#define WME_SUBTYPE_TSPEC 2 /* Traffic Specification */
+
+/* WME Access Category Indices (ACIs) */
+#define AC_BE 0 /* Best Effort */
+#define AC_BK 1 /* Background */
+#define AC_VI 2 /* Video */
+#define AC_VO 3 /* Voice */
+#define AC_COUNT 4 /* number of ACs */
+
+typedef uint8 ac_bitmap_t; /* AC bitmap of (1 << AC_xx) */
+
+#define AC_BITMAP_NONE 0x0 /* No ACs */
+#define AC_BITMAP_ALL 0xf /* All ACs */
+#define AC_BITMAP_TST(ab, ac) (((ab) & (1 << (ac))) != 0)
+
+/* WME Information Element (IE) */
+struct wme_ie {
+ uint8 oui[3];
+ uint8 type;
+ uint8 subtype;
+ uint8 version;
+ uint8 qosinfo;
+} PACKED;
+typedef struct wme_ie wme_ie_t;
+#define WME_IE_LEN 7 /* WME IE length */
+
+struct edcf_acparam {
+ uint8 ACI;
+ uint8 ECW;
+ uint16 TXOP; /* stored in network order (ls octet first) */
+} PACKED;
+typedef struct edcf_acparam edcf_acparam_t;
+
+/* WME Parameter Element (PE) */
+struct wme_param_ie {
+ uint8 oui[3];
+ uint8 type;
+ uint8 subtype;
+ uint8 version;
+ uint8 qosinfo;
+ uint8 rsvd;
+ edcf_acparam_t acparam[AC_COUNT];
+} PACKED;
+typedef struct wme_param_ie wme_param_ie_t;
+#define WME_PARAM_IE_LEN 24 /* WME Parameter IE length */
+
+/* QoS Info field for IE as sent from AP */
+#define WME_QI_AP_APSD_MASK 0x80 /* U-APSD Supported mask */
+#define WME_QI_AP_APSD_SHIFT 7 /* U-APSD Supported shift */
+#define WME_QI_AP_COUNT_MASK 0x0f /* Parameter set count mask */
+#define WME_QI_AP_COUNT_SHIFT 0 /* Parameter set count shift */
+
+/* QoS Info field for IE as sent from STA */
+#define WME_QI_STA_MAXSPLEN_MASK 0x60 /* Max Service Period Length mask */
+#define WME_QI_STA_MAXSPLEN_SHIFT 5 /* Max Service Period Length shift */
+#define WME_QI_STA_APSD_ALL_MASK 0xf /* APSD all AC bits mask */
+#define WME_QI_STA_APSD_ALL_SHIFT 0 /* APSD all AC bits shift */
+#define WME_QI_STA_APSD_BE_MASK 0x8 /* APSD AC_BE mask */
+#define WME_QI_STA_APSD_BE_SHIFT 3 /* APSD AC_BE shift */
+#define WME_QI_STA_APSD_BK_MASK 0x4 /* APSD AC_BK mask */
+#define WME_QI_STA_APSD_BK_SHIFT 2 /* APSD AC_BK shift */
+#define WME_QI_STA_APSD_VI_MASK 0x2 /* APSD AC_VI mask */
+#define WME_QI_STA_APSD_VI_SHIFT 1 /* APSD AC_VI shift */
+#define WME_QI_STA_APSD_VO_MASK 0x1 /* APSD AC_VO mask */
+#define WME_QI_STA_APSD_VO_SHIFT 0 /* APSD AC_VO shift */
+
+/* ACI */
+#define EDCF_AIFSN_MIN 1 /* AIFSN minimum value */
+#define EDCF_AIFSN_MAX 15 /* AIFSN maximum value */
+#define EDCF_AIFSN_MASK 0x0f /* AIFSN mask */
+#define EDCF_ACM_MASK 0x10 /* ACM mask */
+#define EDCF_ACI_MASK 0x60 /* ACI mask */
+#define EDCF_ACI_SHIFT 5 /* ACI shift */
+
+/* ECW */
+#define EDCF_ECW_MIN 0 /* cwmin/cwmax exponent minimum value */
+#define EDCF_ECW_MAX 15 /* cwmin/cwmax exponent maximum value */
+#define EDCF_ECW2CW(exp) ((1 << (exp)) - 1)
+#define EDCF_ECWMIN_MASK 0x0f /* cwmin exponent form mask */
+#define EDCF_ECWMAX_MASK 0xf0 /* cwmax exponent form mask */
+#define EDCF_ECWMAX_SHIFT 4 /* cwmax exponent form shift */
+
+/* TXOP */
+#define EDCF_TXOP_MIN 0 /* TXOP minimum value */
+#define EDCF_TXOP_MAX 65535 /* TXOP maximum value */
+#define EDCF_TXOP2USEC(txop) ((txop) << 5)
+
+/* Default EDCF parameters that AP advertises for STA to use; WMM draft Table 12 */
+#define EDCF_AC_BE_ACI_STA 0x03 /* STA ACI value for best effort AC */
+#define EDCF_AC_BE_ECW_STA 0xA4 /* STA ECW value for best effort AC */
+#define EDCF_AC_BE_TXOP_STA 0x0000 /* STA TXOP value for best effort AC */
+#define EDCF_AC_BK_ACI_STA 0x27 /* STA ACI value for background AC */
+#define EDCF_AC_BK_ECW_STA 0xA4 /* STA ECW value for background AC */
+#define EDCF_AC_BK_TXOP_STA 0x0000 /* STA TXOP value for background AC */
+#define EDCF_AC_VI_ACI_STA 0x42 /* STA ACI value for video AC */
+#define EDCF_AC_VI_ECW_STA 0x43 /* STA ECW value for video AC */
+#define EDCF_AC_VI_TXOP_STA 0x005e /* STA TXOP value for video AC */
+#define EDCF_AC_VO_ACI_STA 0x62 /* STA ACI value for audio AC */
+#define EDCF_AC_VO_ECW_STA 0x32 /* STA ECW value for audio AC */
+#define EDCF_AC_VO_TXOP_STA 0x002f /* STA TXOP value for audio AC */
+
+/* Default EDCF parameters that AP uses; WMM draft Table 14 */
+#define EDCF_AC_BE_ACI_AP 0x03 /* AP ACI value for best effort AC */
+#define EDCF_AC_BE_ECW_AP 0x64 /* AP ECW value for best effort AC */
+#define EDCF_AC_BE_TXOP_AP 0x0000 /* AP TXOP value for best effort AC */
+#define EDCF_AC_BK_ACI_AP 0x27 /* AP ACI value for background AC */
+#define EDCF_AC_BK_ECW_AP 0xA4 /* AP ECW value for background AC */
+#define EDCF_AC_BK_TXOP_AP 0x0000 /* AP TXOP value for background AC */
+#define EDCF_AC_VI_ACI_AP 0x41 /* AP ACI value for video AC */
+#define EDCF_AC_VI_ECW_AP 0x43 /* AP ECW value for video AC */
+#define EDCF_AC_VI_TXOP_AP 0x005e /* AP TXOP value for video AC */
+#define EDCF_AC_VO_ACI_AP 0x61 /* AP ACI value for audio AC */
+#define EDCF_AC_VO_ECW_AP 0x32 /* AP ECW value for audio AC */
+#define EDCF_AC_VO_TXOP_AP 0x002f /* AP TXOP value for audio AC */
+
+struct dot11_qbss_load_ie {
+ uint8 id; /* 11, DOT11_MNG_QBSS_LOAD_ID */
+ uint8 length;
+ uint16 station_count; /* total number of STAs associated */
+ uint8 channel_utilization; /* % of time, normalized to 255, QAP sensed medium busy */
+ uint16 aac; /* available admission capacity */
+} PACKED;
+typedef struct dot11_qbss_load_ie dot11_qbss_load_ie_t;
+
+/* nom_msdu_size */
+#define FIXED_MSDU_SIZE 0x8000 /* MSDU size is fixed */
+#define MSDU_SIZE_MASK 0x7fff /* (Nominal or fixed) MSDU size */
+
+/* surplus_bandwidth */
+/* Represented as 3 bits of integer, binary point, 13 bits fraction */
+#define INTEGER_SHIFT 13 /* integer shift */
+#define FRACTION_MASK 0x1FFF /* fraction mask */
+
+/* Management Notification Frame */
+struct dot11_management_notification {
+ uint8 category; /* DOT11_ACTION_NOTIFICATION */
+ uint8 action;
+ uint8 token;
+ uint8 status;
+ uint8 data[1]; /* Elements */
+} PACKED;
+#define DOT11_MGMT_NOTIFICATION_LEN 4 /* Fixed length */
+
+/* WME Action Codes */
+#define WME_ADDTS_REQUEST 0 /* WME ADDTS request */
+#define WME_ADDTS_RESPONSE 1 /* WME ADDTS response */
+#define WME_DELTS_REQUEST 2 /* WME DELTS request */
+
+/* WME Setup Response Status Codes */
+#define WME_ADMISSION_ACCEPTED 0 /* WME admission accepted */
+#define WME_INVALID_PARAMETERS 1 /* WME invalide parameters */
+#define WME_ADMISSION_REFUSED 3 /* WME admission refused */
+
+/* Macro to take a pointer to a beacon or probe response
+ * body and return the char* pointer to the SSID info element
+ */
+#define BCN_PRB_SSID(body) ((char*)(body) + DOT11_BCN_PRB_LEN)
+
+/* Authentication frame payload constants */
+#define DOT11_OPEN_SYSTEM 0 /* d11 open authentication */
+#define DOT11_SHARED_KEY 1 /* d11 shared authentication */
+#define DOT11_CHALLENGE_LEN 128 /* d11 challenge text length */
+
+/* Frame control macros */
+#define FC_PVER_MASK 0x3 /* PVER mask */
+#define FC_PVER_SHIFT 0 /* PVER shift */
+#define FC_TYPE_MASK 0xC /* type mask */
+#define FC_TYPE_SHIFT 2 /* type shift */
+#define FC_SUBTYPE_MASK 0xF0 /* subtype mask */
+#define FC_SUBTYPE_SHIFT 4 /* subtype shift */
+#define FC_TODS 0x100 /* to DS */
+#define FC_TODS_SHIFT 8 /* to DS shift */
+#define FC_FROMDS 0x200 /* from DS */
+#define FC_FROMDS_SHIFT 9 /* from DS shift */
+#define FC_MOREFRAG 0x400 /* more frag. */
+#define FC_MOREFRAG_SHIFT 10 /* more frag. shift */
+#define FC_RETRY 0x800 /* retry */
+#define FC_RETRY_SHIFT 11 /* retry shift */
+#define FC_PM 0x1000 /* PM */
+#define FC_PM_SHIFT 12 /* PM shift */
+#define FC_MOREDATA 0x2000 /* more data */
+#define FC_MOREDATA_SHIFT 13 /* more data shift */
+#define FC_WEP 0x4000 /* WEP */
+#define FC_WEP_SHIFT 14 /* WEP shift */
+#define FC_ORDER 0x8000 /* order */
+#define FC_ORDER_SHIFT 15 /* order shift */
+
+/* sequence control macros */
+#define SEQNUM_SHIFT 4 /* seq. number shift */
+#define SEQNUM_MAX 0x1000 /* max seqnum + 1 */
+#define FRAGNUM_MASK 0xF /* frag. number mask */
+
+/* Frame Control type/subtype defs */
+
+/* FC Types */
+#define FC_TYPE_MNG 0 /* management type */
+#define FC_TYPE_CTL 1 /* control type */
+#define FC_TYPE_DATA 2 /* data type */
+
+/* Management Subtypes */
+#define FC_SUBTYPE_ASSOC_REQ 0 /* assoc. request */
+#define FC_SUBTYPE_ASSOC_RESP 1 /* assoc. response */
+#define FC_SUBTYPE_REASSOC_REQ 2 /* reassoc. request */
+#define FC_SUBTYPE_REASSOC_RESP 3 /* reassoc. response */
+#define FC_SUBTYPE_PROBE_REQ 4 /* probe request */
+#define FC_SUBTYPE_PROBE_RESP 5 /* probe response */
+#define FC_SUBTYPE_BEACON 8 /* beacon */
+#define FC_SUBTYPE_ATIM 9 /* ATIM */
+#define FC_SUBTYPE_DISASSOC 10 /* disassoc. */
+#define FC_SUBTYPE_AUTH 11 /* authentication */
+#define FC_SUBTYPE_DEAUTH 12 /* de-authentication */
+#define FC_SUBTYPE_ACTION 13 /* action */
+#define FC_SUBTYPE_ACTION_NOACK 14 /* action no-ack */
+
+/* Control Subtypes */
+#define FC_SUBTYPE_CTL_WRAPPER 7 /* Control Wrapper */
+#define FC_SUBTYPE_BLOCKACK_REQ 8 /* Block Ack Req */
+#define FC_SUBTYPE_BLOCKACK 9 /* Block Ack */
+#define FC_SUBTYPE_PS_POLL 10 /* PS poll */
+#define FC_SUBTYPE_RTS 11 /* RTS */
+#define FC_SUBTYPE_CTS 12 /* CTS */
+#define FC_SUBTYPE_ACK 13 /* ACK */
+#define FC_SUBTYPE_CF_END 14 /* CF-END */
+#define FC_SUBTYPE_CF_END_ACK 15 /* CF-END ACK */
+
+/* Data Subtypes */
+#define FC_SUBTYPE_DATA 0 /* Data */
+#define FC_SUBTYPE_DATA_CF_ACK 1 /* Data + CF-ACK */
+#define FC_SUBTYPE_DATA_CF_POLL 2 /* Data + CF-Poll */
+#define FC_SUBTYPE_DATA_CF_ACK_POLL 3 /* Data + CF-Ack + CF-Poll */
+#define FC_SUBTYPE_NULL 4 /* Null */
+#define FC_SUBTYPE_CF_ACK 5 /* CF-Ack */
+#define FC_SUBTYPE_CF_POLL 6 /* CF-Poll */
+#define FC_SUBTYPE_CF_ACK_POLL 7 /* CF-Ack + CF-Poll */
+#define FC_SUBTYPE_QOS_DATA 8 /* QoS Data */
+#define FC_SUBTYPE_QOS_DATA_CF_ACK 9 /* QoS Data + CF-Ack */
+#define FC_SUBTYPE_QOS_DATA_CF_POLL 10 /* QoS Data + CF-Poll */
+#define FC_SUBTYPE_QOS_DATA_CF_ACK_POLL 11 /* QoS Data + CF-Ack + CF-Poll */
+#define FC_SUBTYPE_QOS_NULL 12 /* QoS Null */
+#define FC_SUBTYPE_QOS_CF_POLL 14 /* QoS CF-Poll */
+#define FC_SUBTYPE_QOS_CF_ACK_POLL 15 /* QoS CF-Ack + CF-Poll */
+
+/* Data Subtype Groups */
+#define FC_SUBTYPE_ANY_QOS(s) (((s) & 8) != 0)
+#define FC_SUBTYPE_ANY_NULL(s) (((s) & 4) != 0)
+#define FC_SUBTYPE_ANY_CF_POLL(s) (((s) & 2) != 0)
+#define FC_SUBTYPE_ANY_CF_ACK(s) (((s) & 1) != 0)
+
+/* Type/Subtype Combos */
+#define FC_KIND_MASK (FC_TYPE_MASK | FC_SUBTYPE_MASK) /* FC kind mask */
+
+#define FC_KIND(t, s) (((t) << FC_TYPE_SHIFT) | ((s) << FC_SUBTYPE_SHIFT)) /* FC kind */
+
+#define FC_SUBTYPE(fc) (((fc) & FC_SUBTYPE_MASK) >> FC_SUBTYPE_SHIFT) /* Subtype from FC */
+#define FC_TYPE(fc) (((fc) & FC_TYPE_MASK) >> FC_TYPE_SHIFT) /* Type from FC */
+
+#define FC_ASSOC_REQ FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_ASSOC_REQ) /* assoc. request */
+#define FC_ASSOC_RESP FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_ASSOC_RESP) /* assoc. response */
+#define FC_REASSOC_REQ FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_REASSOC_REQ) /* reassoc. request */
+#define FC_REASSOC_RESP FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_REASSOC_RESP) /* reassoc. response */
+#define FC_PROBE_REQ FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_PROBE_REQ) /* probe request */
+#define FC_PROBE_RESP FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_PROBE_RESP) /* probe response */
+#define FC_BEACON FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_BEACON) /* beacon */
+#define FC_DISASSOC FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_DISASSOC) /* disassoc */
+#define FC_AUTH FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_AUTH) /* authentication */
+#define FC_DEAUTH FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_DEAUTH) /* deauthentication */
+#define FC_ACTION FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_ACTION) /* action */
+#define FC_ACTION_NOACK FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_ACTION_NOACK) /* action no-ack */
+
+#define FC_CTL_WRAPPER FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_CTL_WRAPPER) /* Control Wrapper */
+#define FC_BLOCKACK_REQ FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_BLOCKACK_REQ) /* Block Ack Req */
+#define FC_BLOCKACK FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_BLOCKACK) /* Block Ack */
+#define FC_PS_POLL FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_PS_POLL) /* PS poll */
+#define FC_RTS FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_RTS) /* RTS */
+#define FC_CTS FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_CTS) /* CTS */
+#define FC_ACK FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_ACK) /* ACK */
+#define FC_CF_END FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_CF_END) /* CF-END */
+#define FC_CF_END_ACK FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_CF_END_ACK) /* CF-END ACK */
+
+#define FC_DATA FC_KIND(FC_TYPE_DATA, FC_SUBTYPE_DATA) /* data */
+#define FC_NULL_DATA FC_KIND(FC_TYPE_DATA, FC_SUBTYPE_NULL) /* null data */
+#define FC_DATA_CF_ACK FC_KIND(FC_TYPE_DATA, FC_SUBTYPE_DATA_CF_ACK) /* data CF ACK */
+#define FC_QOS_DATA FC_KIND(FC_TYPE_DATA, FC_SUBTYPE_QOS_DATA) /* QoS data */
+#define FC_QOS_NULL FC_KIND(FC_TYPE_DATA, FC_SUBTYPE_QOS_NULL) /* QoS null */
+
+/* QoS Control Field */
+
+/* 802.1D Priority */
+#define QOS_PRIO_SHIFT 0 /* QoS priority shift */
+#define QOS_PRIO_MASK 0x0007 /* QoS priority mask */
+#define QOS_PRIO(qos) (((qos) & QOS_PRIO_MASK) >> QOS_PRIO_SHIFT) /* QoS priority */
+
+/* Traffic Identifier */
+#define QOS_TID_SHIFT 0 /* QoS TID shift */
+#define QOS_TID_MASK 0x000f /* QoS TID mask */
+#define QOS_TID(qos) (((qos) & QOS_TID_MASK) >> QOS_TID_SHIFT) /* QoS TID */
+
+/* End of Service Period (U-APSD) */
+#define QOS_EOSP_SHIFT 4 /* QoS End of Service Period shift */
+#define QOS_EOSP_MASK 0x0010 /* QoS End of Service Period mask */
+#define QOS_EOSP(qos) (((qos) & QOS_EOSP_MASK) >> QOS_EOSP_SHIFT) /* Qos EOSP */
+
+/* Ack Policy */
+#define QOS_ACK_NORMAL_ACK 0 /* Normal Ack */
+#define QOS_ACK_NO_ACK 1 /* No Ack (eg mcast) */
+#define QOS_ACK_NO_EXP_ACK 2 /* No Explicit Ack */
+#define QOS_ACK_BLOCK_ACK 3 /* Block Ack */
+#define QOS_ACK_SHIFT 5 /* QoS ACK shift */
+#define QOS_ACK_MASK 0x0060 /* QoS ACK mask */
+#define QOS_ACK(qos) (((qos) & QOS_ACK_MASK) >> QOS_ACK_SHIFT) /* QoS ACK */
+
+/* A-MSDU flag */
+#define QOS_AMSDU_SHIFT 7 /* AMSDU shift */
+#define QOS_AMSDU_MASK 0x0080 /* AMSDU mask */
+
+/* Management Frames */
+
+/* Management Frame Constants */
+
+/* Fixed fields */
+#define DOT11_MNG_AUTH_ALGO_LEN 2 /* d11 management auth. algo. length */
+#define DOT11_MNG_AUTH_SEQ_LEN 2 /* d11 management auth. seq. length */
+#define DOT11_MNG_BEACON_INT_LEN 2 /* d11 management beacon interval length */
+#define DOT11_MNG_CAP_LEN 2 /* d11 management cap. length */
+#define DOT11_MNG_AP_ADDR_LEN 6 /* d11 management AP address length */
+#define DOT11_MNG_LISTEN_INT_LEN 2 /* d11 management listen interval length */
+#define DOT11_MNG_REASON_LEN 2 /* d11 management reason length */
+#define DOT11_MNG_AID_LEN 2 /* d11 management AID length */
+#define DOT11_MNG_STATUS_LEN 2 /* d11 management status length */
+#define DOT11_MNG_TIMESTAMP_LEN 8 /* d11 management timestamp length */
+
+/* DUR/ID field in assoc resp is 0xc000 | AID */
+#define DOT11_AID_MASK 0x3fff /* d11 AID mask */
+
+/* Reason Codes */
+#define DOT11_RC_RESERVED 0 /* d11 RC reserved */
+#define DOT11_RC_UNSPECIFIED 1 /* Unspecified reason */
+#define DOT11_RC_AUTH_INVAL 2 /* Previous authentication no longer valid */
+#define DOT11_RC_DEAUTH_LEAVING 3 /* Deauthenticated because sending station
+ * is leaving (or has left) IBSS or ESS
+ */
+#define DOT11_RC_INACTIVITY 4 /* Disassociated due to inactivity */
+#define DOT11_RC_BUSY 5 /* Disassociated because AP is unable to handle
+ * all currently associated stations
+ */
+#define DOT11_RC_INVAL_CLASS_2 6 /* Class 2 frame received from
+ * nonauthenticated station
+ */
+#define DOT11_RC_INVAL_CLASS_3 7 /* Class 3 frame received from
+ * nonassociated station
+ */
+#define DOT11_RC_DISASSOC_LEAVING 8 /* Disassociated because sending station is
+ * leaving (or has left) BSS
+ */
+#define DOT11_RC_NOT_AUTH 9 /* Station requesting (re)association is not
+ * authenticated with responding station
+ */
+#define DOT11_RC_BAD_PC 10 /* Unacceptable power capability element */
+#define DOT11_RC_BAD_CHANNELS 11 /* Unacceptable supported channels element */
+/* 12 is unused */
+
+/* 32-39 are QSTA specific reasons added in 11e */
+#define DOT11_RC_UNSPECIFIED_QOS 32 /* unspecified QoS-related reason */
+#define DOT11_RC_INSUFFCIENT_BW 33 /* QAP lacks sufficient bandwidth */
+#define DOT11_RC_EXCESSIVE_FRAMES 34 /* excessive number of frames need ack */
+#define DOT11_RC_TX_OUTSIDE_TXOP 35 /* transmitting outside the limits of txop */
+#define DOT11_RC_LEAVING_QBSS 36 /* QSTA is leaving the QBSS (or restting) */
+#define DOT11_RC_BAD_MECHANISM 37 /* does not want to use the mechanism */
+#define DOT11_RC_SETUP_NEEDED 38 /* mechanism needs a setup */
+#define DOT11_RC_TIMEOUT 39 /* timeout */
+
+#define DOT11_RC_MAX 23 /* Reason codes > 23 are reserved */
+
+/* Status Codes */
+#define DOT11_SC_SUCCESS 0 /* Successful */
+#define DOT11_SC_FAILURE 1 /* Unspecified failure */
+#define DOT11_SC_CAP_MISMATCH 10 /* Cannot support all requested
+ * capabilities in the Capability
+ * Information field
+ */
+#define DOT11_SC_REASSOC_FAIL 11 /* Reassociation denied due to inability
+ * to confirm that association exists
+ */
+#define DOT11_SC_ASSOC_FAIL 12 /* Association denied due to reason
+ * outside the scope of this standard
+ */
+#define DOT11_SC_AUTH_MISMATCH 13 /* Responding station does not support
+ * the specified authentication
+ * algorithm
+ */
+#define DOT11_SC_AUTH_SEQ 14 /* Received an Authentication frame
+ * with authentication transaction
+ * sequence number out of expected
+ * sequence
+ */
+#define DOT11_SC_AUTH_CHALLENGE_FAIL 15 /* Authentication rejected because of
+ * challenge failure
+ */
+#define DOT11_SC_AUTH_TIMEOUT 16 /* Authentication rejected due to timeout
+ * waiting for next frame in sequence
+ */
+#define DOT11_SC_ASSOC_BUSY_FAIL 17 /* Association denied because AP is
+ * unable to handle additional
+ * associated stations
+ */
+#define DOT11_SC_ASSOC_RATE_MISMATCH 18 /* Association denied due to requesting
+ * station not supporting all of the
+ * data rates in the BSSBasicRateSet
+ * parameter
+ */
+#define DOT11_SC_ASSOC_SHORT_REQUIRED 19 /* Association denied due to requesting
+ * station not supporting the Short
+ * Preamble option
+ */
+#define DOT11_SC_ASSOC_PBCC_REQUIRED 20 /* Association denied due to requesting
+ * station not supporting the PBCC
+ * Modulation option
+ */
+#define DOT11_SC_ASSOC_AGILITY_REQUIRED 21 /* Association denied due to requesting
+ * station not supporting the Channel
+ * Agility option
+ */
+#define DOT11_SC_ASSOC_SPECTRUM_REQUIRED 22 /* Association denied because Spectrum
+ * Management capability is required.
+ */
+#define DOT11_SC_ASSOC_BAD_POWER_CAP 23 /* Association denied because the info
+ * in the Power Cap element is
+ * unacceptable.
+ */
+#define DOT11_SC_ASSOC_BAD_SUP_CHANNELS 24 /* Association denied because the info
+ * in the Supported Channel element is
+ * unacceptable
+ */
+#define DOT11_SC_ASSOC_SHORTSLOT_REQUIRED 25 /* Association denied due to requesting
+ * station not supporting the Short Slot
+ * Time option
+ */
+#define DOT11_SC_ASSOC_ERPBCC_REQUIRED 26 /* Association denied due to requesting
+ * station not supporting the ER-PBCC
+ * Modulation option
+ */
+#define DOT11_SC_ASSOC_DSSOFDM_REQUIRED 27 /* Association denied due to requesting
+ * station not supporting the DSS-OFDM
+ * option
+ */
+
+#define DOT11_SC_DECLINED 37 /* request declined */
+#define DOT11_SC_INVALID_PARAMS 38 /* One or more params have invalid values */
+
+/* Info Elts, length of INFORMATION portion of Info Elts */
+#define DOT11_MNG_DS_PARAM_LEN 1 /* d11 management DS parameter length */
+#define DOT11_MNG_IBSS_PARAM_LEN 2 /* d11 management IBSS parameter length */
+
+/* TIM Info element has 3 bytes fixed info in INFORMATION field,
+ * followed by 1 to 251 bytes of Partial Virtual Bitmap
+ */
+#define DOT11_MNG_TIM_FIXED_LEN 3 /* d11 management TIM fixed length */
+#define DOT11_MNG_TIM_DTIM_COUNT 0 /* d11 management DTIM count */
+#define DOT11_MNG_TIM_DTIM_PERIOD 1 /* d11 management DTIM period */
+#define DOT11_MNG_TIM_BITMAP_CTL 2 /* d11 management TIM BITMAP control */
+#define DOT11_MNG_TIM_PVB 3 /* d11 management TIM PVB */
+
+/* TLV defines */
+#define TLV_TAG_OFF 0 /* tag offset */
+#define TLV_LEN_OFF 1 /* length offset */
+#define TLV_HDR_LEN 2 /* header length */
+#define TLV_BODY_OFF 2 /* body offset */
+
+/* Management Frame Information Element IDs */
+#define DOT11_MNG_SSID_ID 0 /* d11 management SSID id */
+#define DOT11_MNG_RATES_ID 1 /* d11 management rates id */
+#define DOT11_MNG_FH_PARMS_ID 2 /* d11 management FH parameter id */
+#define DOT11_MNG_DS_PARMS_ID 3 /* d11 management DS parameter id */
+#define DOT11_MNG_CF_PARMS_ID 4 /* d11 management CF parameter id */
+#define DOT11_MNG_TIM_ID 5 /* d11 management TIM id */
+#define DOT11_MNG_IBSS_PARMS_ID 6 /* d11 management IBSS parameter id */
+#define DOT11_MNG_COUNTRY_ID 7 /* d11 management country id */
+#define DOT11_MNG_HOPPING_PARMS_ID 8 /* d11 management hopping parameter id */
+#define DOT11_MNG_HOPPING_TABLE_ID 9 /* d11 management hopping table id */
+#define DOT11_MNG_REQUEST_ID 10 /* d11 management request id */
+#define DOT11_MNG_QBSS_LOAD_ID 11 /* d11 management QBSS Load id */
+#define DOT11_MNG_CHALLENGE_ID 16 /* d11 management chanllenge id */
+#define DOT11_MNG_PWR_CONSTRAINT_ID 32 /* 11H PowerConstraint */
+#define DOT11_MNG_PWR_CAP_ID 33 /* 11H PowerCapability */
+#define DOT11_MNG_TPC_REQUEST_ID 34 /* 11H TPC Request */
+#define DOT11_MNG_TPC_REPORT_ID 35 /* 11H TPC Report */
+#define DOT11_MNG_SUPP_CHANNELS_ID 36 /* 11H Supported Channels */
+#define DOT11_MNG_CHANNEL_SWITCH_ID 37 /* 11H ChannelSwitch Announcement */
+#define DOT11_MNG_MEASURE_REQUEST_ID 38 /* 11H MeasurementRequest */
+#define DOT11_MNG_MEASURE_REPORT_ID 39 /* 11H MeasurementReport */
+#define DOT11_MNG_QUIET_ID 40 /* 11H Quiet */
+#define DOT11_MNG_IBSS_DFS_ID 41 /* 11H IBSS_DFS */
+#define DOT11_MNG_ERP_ID 42 /* d11 management ERP id */
+#define DOT11_MNG_TS_DELAY_ID 43 /* d11 management TS Delay id */
+#define DOT11_MNG_HT_CAP 45 /* d11 mgmt HT cap id */
+#define DOT11_MNG_NONERP_ID 47 /* d11 management NON-ERP id */
+#define DOT11_MNG_RSN_ID 48 /* d11 management RSN id */
+#define DOT11_MNG_EXT_RATES_ID 50 /* d11 management ext. rates id */
+#define DOT11_MNG_EXT_CSA_ID 60 /* d11 Extended CSA */
+#define DOT11_MNG_HT_ADD 61 /* d11 mgmt additional HT info */
+#define DOT11_MNG_EXT_CHANNEL_OFFSET 62 /* d11 mgmt ext channel offset */
+#define DOT11_MNG_EXT_CAP 127 /* d11 mgmt ext capability */
+#define DOT11_MNG_WPA_ID 221 /* d11 management WPA id */
+#define DOT11_MNG_PROPR_ID 221 /* d11 management proprietary id */
+
+/* Rate element Basic flag and rate mask */
+#define DOT11_RATE_BASIC 0x80 /* flag for a Basic Rate */
+#define DOT11_RATE_MASK 0x7F /* mask for numeric part of rate */
+
+/* ERP info element bit values */
+#define DOT11_MNG_ERP_LEN 1 /* ERP is currently 1 byte long */
+#define DOT11_MNG_NONERP_PRESENT 0x01 /* NonERP (802.11b) STAs are present
+ *in the BSS
+ */
+#define DOT11_MNG_USE_PROTECTION 0x02 /* Use protection mechanisms for
+ *ERP-OFDM frames
+ */
+#define DOT11_MNG_BARKER_PREAMBLE 0x04 /* Short Preambles: 0 == allowed,
+ * 1 == not allowed
+ */
+/* TS Delay element offset & size */
+#define DOT11_MGN_TS_DELAY_LEN 4 /* length of TS DELAY IE */
+#define TS_DELAY_FIELD_SIZE 4 /* TS DELAY field size */
+
+/* Capability Information Field */
+#define DOT11_CAP_ESS 0x0001 /* d11 cap. ESS */
+#define DOT11_CAP_IBSS 0x0002 /* d11 cap. IBSS */
+#define DOT11_CAP_POLLABLE 0x0004 /* d11 cap. pollable */
+#define DOT11_CAP_POLL_RQ 0x0008 /* d11 cap. poll request */
+#define DOT11_CAP_PRIVACY 0x0010 /* d11 cap. privacy */
+#define DOT11_CAP_SHORT 0x0020 /* d11 cap. short */
+#define DOT11_CAP_PBCC 0x0040 /* d11 cap. PBCC */
+#define DOT11_CAP_AGILITY 0x0080 /* d11 cap. agility */
+#define DOT11_CAP_SPECTRUM 0x0100 /* d11 cap. spectrum */
+#define DOT11_CAP_SHORTSLOT 0x0400 /* d11 cap. shortslot */
+#define DOT11_CAP_CCK_OFDM 0x2000 /* d11 cap. CCK/OFDM */
+
+/* Extended Capability Information Field */
+#define DOT11_EXT_CAP_HT_IE_SUPPORT 0x01 /* support for info xchg action frame */
+
+/* Action Frame Constants */
+#define DOT11_ACTION_HDR_LEN 2 /* action frame header length */
+#define DOT11_ACTION_CAT_ERR_MASK 0x80 /* d11 action category error mask */
+#define DOT11_ACTION_CAT_MASK 0x7F /* d11 action category mask */
+#define DOT11_ACTION_CAT_SPECT_MNG 0x00 /* d11 action category spectrum management */
+#define DOT11_ACTION_CAT_BLOCKACK 0x03 /* d11 action category block ack */
+#define DOT11_ACTION_CAT_HT 0x07 /* d11 action category for HT */
+#define DOT11_ACTION_NOTIFICATION 0x11 /* 17 */
+
+#define DOT11_ACTION_ID_M_REQ 0 /* d11 action measurement request */
+#define DOT11_ACTION_ID_M_REP 1 /* d11 action measurement response */
+#define DOT11_ACTION_ID_TPC_REQ 2 /* d11 action TPC request */
+#define DOT11_ACTION_ID_TPC_REP 3 /* d11 action TPC response */
+#define DOT11_ACTION_ID_CHANNEL_SWITCH 4 /* d11 action channel switch */
+#define DOT11_ACTION_ID_EXT_CSA 5 /* d11 extened CSA for 11n */
+
+/* HT action ids */
+#define DOT11_ACTION_ID_HT_CH_WIDTH 0 /* notify channel width action id */
+#define DOT11_ACTION_ID_HT_MIMO_PS 1 /* mimo ps action id */
+#define DOT11_ACTION_ID_HT_INFO_XCHG 8 /* HT Information Exchange action id */
+
+/* Block Ack action types */
+#define DOT11_BA_ACTION_ADDBA_REQ 0 /* ADDBA Req action frame type */
+#define DOT11_BA_ACTION_ADDBA_RESP 1 /* ADDBA Resp action frame type */
+#define DOT11_BA_ACTION_DELBA 2 /* DELBA action frame type */
+
+/* ADDBA action parameters */
+#define DOT11_ADDBA_PARAM_AMSDU_SUP 0x0001 /* AMSDU supported under BA */
+#define DOT11_ADDBA_PARAM_POLICY_MASK 0x0002 /* policy mask(ack vs delayed) */
+#define DOT11_ADDBA_PARAM_POLICY_SHIFT 1 /* policy shift */
+#define DOT11_ADDBA_PARAM_TID_MASK 0x003c /* tid mask */
+#define DOT11_ADDBA_PARAM_TID_SHIFT 2 /* tid shift */
+#define DOT11_ADDBA_PARAM_BSIZE_MASK 0xffc0 /* buffer size mask */
+#define DOT11_ADDBA_PARAM_BSIZE_SHIFT 6 /* buffer size shift */
+
+#define DOT11_ADDBA_POLICY_DELAYED 0 /* delayed BA policy */
+#define DOT11_ADDBA_POLICY_IMMEDIATE 1 /* immediate BA policy */
+
+struct dot11_addba_req {
+ uint8 category; /* category of action frame (3) */
+ uint8 action; /* action: addba req */
+ uint8 token; /* identifier */
+ uint16 addba_param_set; /* parameter set */
+ uint16 timeout; /* timeout in seconds */
+ uint16 start_seqnum; /* starting sequence number */
+}PACKED;
+typedef struct dot11_addba_req dot11_addba_req_t;
+#define DOT11_ADDBA_REQ_LEN 9 /* length of addba req frame */
+
+struct dot11_addba_resp {
+ uint8 category; /* category of action frame (3) */
+ uint8 action; /* action: addba resp */
+ uint8 token; /* identifier */
+ uint16 status; /* status of add request */
+ uint16 addba_param_set; /* negotiated parameter set */
+ uint16 timeout; /* negotiated timeout in seconds */
+}PACKED;
+typedef struct dot11_addba_resp dot11_addba_resp_t;
+#define DOT11_ADDBA_RESP_LEN 9 /* length of addba resp frame */
+
+/* DELBA action parameters */
+#define DOT11_DELBA_PARAM_INIT_MASK 0x0800 /* initiator mask */
+#define DOT11_DELBA_PARAM_INIT_SHIFT 11 /* initiator shift */
+#define DOT11_DELBA_PARAM_TID_MASK 0xf000 /* tid mask */
+#define DOT11_DELBA_PARAM_TID_SHIFT 12 /* tid shift */
+
+struct dot11_delba {
+ uint8 category; /* category of action frame (3) */
+ uint8 action; /* action: addba req */
+ uint16 delba_param_set; /* paarmeter set */
+ uint16 reason; /* reason for dellba */
+}PACKED;
+typedef struct dot11_delba dot11_delba_t;
+#define DOT11_DELBA_LEN 6 /* length of delba frame */
+
+/* MLME Enumerations */
+#define DOT11_BSSTYPE_INFRASTRUCTURE 0 /* d11 infrastructure */
+#define DOT11_BSSTYPE_INDEPENDENT 1 /* d11 independent */
+#define DOT11_BSSTYPE_ANY 2 /* d11 any BSS type */
+#define DOT11_SCANTYPE_ACTIVE 0 /* d11 scan active */
+#define DOT11_SCANTYPE_PASSIVE 1 /* d11 scan passive */
+
+/* 802.11 BRCM "Compromise" Pre N constants */
+#define PREN_PREAMBLE 24 /* green field preamble time */
+#define PREN_MM_EXT 8 /* extra mixed mode preamble time */
+#define PREN_PREAMBLE_EXT 4 /* extra preamble (multiply by unique_streams-1) */
+
+/* 802.11 N PHY constants */
+#define NPHY_RIFS_TIME 2 /* NPHY RIFS time */
+
+/* 802.11 A PHY constants */
+#define APHY_SLOT_TIME 9 /* APHY slot time */
+#define APHY_SIFS_TIME 16 /* APHY SIFS time */
+#define APHY_DIFS_TIME (APHY_SIFS_TIME + (2 * APHY_SLOT_TIME)) /* APHY DIFS time */
+#define APHY_PREAMBLE_TIME 16 /* APHY preamble time */
+#define APHY_SIGNAL_TIME 4 /* APHY signal time */
+#define APHY_SYMBOL_TIME 4 /* APHY symbol time */
+#define APHY_SERVICE_NBITS 16 /* APHY service nbits */
+#define APHY_TAIL_NBITS 6 /* APHY tail nbits */
+#define APHY_CWMIN 15 /* APHY cwmin */
+
+/* 802.11 B PHY constants */
+#define BPHY_SLOT_TIME 20 /* BPHY slot time */
+#define BPHY_SIFS_TIME 10 /* BPHY SIFS time */
+#define BPHY_DIFS_TIME 50 /* BPHY DIFS time */
+#define BPHY_PLCP_TIME 192 /* BPHY PLCP time */
+#define BPHY_PLCP_SHORT_TIME 96 /* BPHY PLCP short time */
+#define BPHY_CWMIN 31 /* BPHY cwmin */
+
+/* 802.11 G constants */
+#define DOT11_OFDM_SIGNAL_EXTENSION 6 /* d11 OFDM signal extension */
+
+#define PHY_CWMAX 1023 /* PHY cwmax */
+
+#define DOT11_MAXNUMFRAGS 16 /* max # fragments per MSDU */
+
+/* dot11Counters Table - 802.11 spec., Annex D */
+typedef struct d11cnt {
+ uint32 txfrag; /* dot11TransmittedFragmentCount */
+ uint32 txmulti; /* dot11MulticastTransmittedFrameCount */
+ uint32 txfail; /* dot11FailedCount */
+ uint32 txretry; /* dot11RetryCount */
+ uint32 txretrie; /* dot11MultipleRetryCount */
+ uint32 rxdup; /* dot11FrameduplicateCount */
+ uint32 txrts; /* dot11RTSSuccessCount */
+ uint32 txnocts; /* dot11RTSFailureCount */
+ uint32 txnoack; /* dot11ACKFailureCount */
+ uint32 rxfrag; /* dot11ReceivedFragmentCount */
+ uint32 rxmulti; /* dot11MulticastReceivedFrameCount */
+ uint32 rxcrc; /* dot11FCSErrorCount */
+ uint32 txfrmsnt; /* dot11TransmittedFrameCount */
+ uint32 rxundec; /* dot11WEPUndecryptableCount */
+} d11cnt_t;
+
+/* BRCM OUI */
+#define BRCM_OUI "\x00\x10\x18" /* Broadcom OUI */
+
+/* OUI for BRCM proprietary IE */
+#define BRCM_PROP_OUI "\x00\x90\x4C" /* Broadcom proprietary OUI */
+
+/* BRCM info element */
+struct brcm_ie {
+ uint8 id; /* IE ID, 221, DOT11_MNG_PROPR_ID */
+ uint8 len; /* IE length */
+ uint8 oui[3]; /* Proprietary OUI, BRCM_OUI */
+ uint8 ver; /* type/ver of this IE */
+ uint8 assoc; /* # of assoc STAs */
+ uint8 flags; /* misc flags */
+ uint8 flags1; /* misc flags */
+ uint16 amsdu_mtu_pref; /* preferred A-MSDU MTU */
+} PACKED;
+typedef struct brcm_ie brcm_ie_t;
+#define BRCM_IE_LEN 11 /* BRCM IE length */
+#define BRCM_IE_VER 2 /* BRCM IE version */
+#define BRCM_IE_LEGACY_AES_VER 1 /* BRCM IE legacy AES version */
+
+/* brcm_ie flags */
+#define BRF_ABCAP 0x1 /* afterburner capable */
+#define BRF_ABRQRD 0x2 /* afterburner requested */
+#define BRF_LZWDS 0x4 /* lazy wds enabled */
+#define BRF_BLOCKACK 0x8 /* BlockACK capable */
+#define BRF_ABCOUNTER_MASK 0xf0 /* afterburner wds "state" counter */
+#define BRF_ABCOUNTER_SHIFT 4 /* offset of afterburner wds "state" counter */
+
+/* brcm_ie flags1 */
+#define BRF1_AMSDU 0x1 /* A-MSDU capable */
+#define BRF1_DPT 0x2 /* DPT capable */
+
+#define AB_WDS_TIMEOUT_MAX 15 /* afterburner wds Max count indicating not
+ * locally capable
+ */
+#define AB_WDS_TIMEOUT_MIN 1 /* afterburner wds, use zero count as indicating
+ * "downrev"
+ */
+
+/* EWC definitions */
+#define MCSSET_LEN 16 /* 16-bits per 8-bit set to give 128-bits bitmap of MCS Index */
+#define MAX_MCS_NUM (128) /* max mcs number = 128 */
+
+struct ewc_cap_ie {
+ uint16 cap;
+ uint8 params;
+ uint8 supp_mcs[MCSSET_LEN];
+ uint16 ext_htcap;
+ uint32 txbf_cap;
+ uint8 as_cap;
+} PACKED;
+typedef struct ewc_cap_ie ewc_cap_ie_t;
+
+/* CAP IE: EWC 1.0 spec. simply stole a 802.11 IE, we use our prop. IE until this is resolved */
+/* the capability IE is primarily used to convey this nodes abilities */
+struct ewc_prop_cap_ie {
+ uint8 id; /* IE ID, 221, DOT11_MNG_PROPR_ID */
+ uint8 len; /* IE length */
+ uint8 oui[3]; /* Proprietary OUI, BRCM_PROP_OUI */
+ uint8 type; /* type inidicates what follows */
+ ewc_cap_ie_t cap_ie;
+} PACKED;
+typedef struct ewc_prop_cap_ie ewc_prop_cap_ie_t;
+#define EWC_PROP_IE_OVERHEAD 4 /* overhead bytes for prop oui ie */
+#define EWC_CAP_IE_LEN 26
+#define EWC_CAP_IE_TYPE 51
+
+#define EWC_CAP_LDPC_CODING 0x0001 /* Support for rx of LDPC coded pkts */
+#define EWC_CAP_40MHZ 0x0002 /* FALSE:20Mhz, TRUE:20/40MHZ supported */
+#define EWC_CAP_MIMO_PS_MASK 0x000C /* Mimo PS mask */
+#define EWC_CAP_MIMO_PS_SHIFT 0x0002 /* Mimo PS shift */
+#define EWC_CAP_MIMO_PS_OFF 0x0003 /* Mimo PS, no restriction */
+#define EWC_CAP_MIMO_PS_RTS 0x0001 /* Mimo PS, send RTS/CTS around MIMO frames */
+#define EWC_CAP_MIMO_PS_ON 0x0000 /* Mimo PS, MIMO disallowed */
+#define EWC_CAP_GF 0x0010 /* Greenfield preamble support */
+#define EWC_CAP_SHORT_GI_20 0x0020 /* 20MHZ short guard interval support */
+#define EWC_CAP_SHORT_GI_40 0x0040 /* 40Mhz short guard interval support */
+#define EWC_CAP_TX_STBC 0x0080 /* Tx STBC support */
+#define EWC_CAP_RX_STBC_MASK 0x0300 /* Rx STBC mask */
+#define EWC_CAP_RX_STBC_SHIFT 8 /* Rx STBC shift */
+#define EWC_CAP_DELAYED_BA 0x0400 /* delayed BA support */
+#define EWC_CAP_MAX_AMSDU 0x0800 /* Max AMSDU size in bytes , 0=3839, 1=7935 */
+#define EWC_CAP_DSSS_CCK 0x1000 /* DSSS/CCK supported by the BSS */
+#define EWC_CAP_PSMP 0x2000 /* Power Save Multi Poll support */
+#define EWC_CAP_40MHZ_INTOLERANT 0x4000 /* 40MHz Intolerant */
+#define EWC_CAP_LSIG_TXOP 0x8000 /* L-SIG TXOP protection support */
+
+#define EWC_CAP_RX_STBC_NO 0x0 /* no rx STBC support */
+#define EWC_CAP_RX_STBC_ONE_STREAM 0x1 /* rx STBC support of 1 spatial stream */
+#define EWC_CAP_RX_STBC_TWO_STREAM 0x2 /* rx STBC support of 1-2 spatial streams */
+#define EWC_CAP_RX_STBC_THREE_STREAM 0x3 /* rx STBC support of 1-3 spatial streams */
+
+#define EWC_MAX_AMSDU 7935 /* max amsdu size (bytes) per the EWC spec */
+#define EWC_MIN_AMSDU 3835 /* min amsdu size (bytes) per the EWC spec */
+
+#define EWC_PARAMS_RX_FACTOR_MASK 0x03 /* ampdu rcv factor mask */
+#define EWC_PARAMS_DENSITY_MASK 0x1C /* ampdu density mask */
+#define EWC_PARAMS_DENSITY_SHIFT 2 /* ampdu density shift */
+
+/* EWC/AMPDU specific define */
+#define AMPDU_MAX_MPDU_DENSITY 7 /* max mpdu density; in 1/8 usec units */
+#define AMPDU_MAX_RX_FACTOR 3 /* max rcv ampdu len (64kb) */
+#define AMPDU_RX_FACTOR_BASE 8*1024 /* ampdu factor base for rx len */
+#define AMPDU_DELIMITER_LEN 4 /* length of ampdu delimiter */
+
+struct ewc_add_ie {
+ uint8 ctl_ch; /* control channel number */
+ uint8 byte1; /* ext ch,rec. ch. width, RIFS support */
+ uint16 opmode; /* operation mode */
+ uint16 misc_bits; /* misc bits */
+ uint8 basic_mcs[MCSSET_LEN]; /* required MCS set */
+} PACKED;
+typedef struct ewc_add_ie ewc_add_ie_t;
+
+/* ADD IE: EWC 1.0 spec. simply stole a 802.11 IE, we use our prop. IE until this is resolved */
+/* the additional IE is primarily used to convey the current BSS configuration */
+struct ewc_prop_add_ie {
+ uint8 id; /* IE ID, 221, DOT11_MNG_PROPR_ID */
+ uint8 len; /* IE length */
+ uint8 oui[3]; /* Proprietary OUI, BRCM_PROP_OUI */
+ uint8 type; /* indicates what follows */
+ ewc_add_ie_t add_ie;
+} PACKED;
+typedef struct ewc_prop_add_ie ewc_prop_add_ie_t;
+
+#define EWC_ADD_IE_LEN 22
+#define EWC_ADD_IE_TYPE 52
+
+/* byte1 defn's */
+#define EWC_BW_ANY 0x04 /* set, STA can use 20 or 40MHz */
+#define EWC_RIFS_PERMITTED 0x08 /* RIFS allowed */
+
+/* opmode defn's */
+#define EWC_OPMODE_MASK 0x0003 /* protection mode mask */
+#define EWC_OPMODE_SHIFT 0 /* protection mode shift */
+#define EWC_OPMODE_PURE 0x0000 /* protection mode PURE */
+#define EWC_OPMODE_OPTIONAL 0x0001 /* protection mode optional */
+#define EWC_OPMODE_HT20IN40 0x0002 /* protection mode 20MHz HT in 40MHz BSS */
+#define EWC_OPMODE_MIXED 0x0003 /* protection mode Mixed Mode */
+#define EWC_OPMODE_NONGF 0x0004 /* protection mode non-GF */
+#define DOT11N_TXBURST 0x0008 /* Tx burst limit */
+#define DOT11N_OBSS_NONHT 0x0010 /* OBSS Non-HT STA present */
+
+/* misc_bites defn's */
+#define EWC_BASIC_STBC_MCS 0x007f /* basic STBC MCS */
+#define EWC_DUAL_STBC_PROT 0x0080 /* Dual STBC Protection */
+#define EWC_SECOND_BCN 0x0100 /* Secondary beacon support */
+#define EWC_LSIG_TXOP 0x0200 /* L-SIG TXOP Protection full support */
+#define EWC_PCO_ACTIVE 0x0400 /* PCO active */
+#define EWC_PCO_PHASE 0x0800 /* PCO phase */
+
+/* Tx Burst Limits */
+#define DOT11N_2G_TXBURST_LIMIT 6160 /* 2G band Tx burst limit per 802.11n Draft 1.10 (usec) */
+#define DOT11N_5G_TXBURST_LIMIT 3080 /* 5G band Tx burst limit per 802.11n Draft 1.10 (usec) */
+
+/* Macros for opmode */
+#define GET_EWC_OPMODE(add_ie) ((ltoh16_ua(&add_ie->opmode) & EWC_OPMODE_MASK) \
+ >> EWC_OPMODE_SHIFT)
+#define EWC_MIXEDMODE_PRESENT(add_ie) ((ltoh16_ua(&add_ie->opmode) & EWC_OPMODE_MASK) \
+ == EWC_OPMODE_MIXED) /* mixed mode present */
+#define EWC_HT20_PRESENT(add_ie) ((ltoh16_ua(&add_ie->opmode) & EWC_OPMODE_MASK) \
+ == EWC_OPMODE_HT20IN40) /* 20MHz HT present */
+#define EWC_OPTIONAL_PRESENT(add_ie) ((ltoh16_ua(&add_ie->opmode) & EWC_OPMODE_MASK) \
+ == EWC_OPMODE_OPTIONAL) /* Optional protection present */
+#define EWC_USE_PROTECTION(add_ie) (EWC_HT20_PRESENT((add_ie)) || \
+ EWC_MIXEDMODE_PRESENT((add_ie))) /* use protection */
+#define EWC_NONGF_PRESENT(add_ie) ((ltoh16_ua(&add_ie->opmode) & EWC_OPMODE_NONGF) \
+ == EWC_OPMODE_NONGF) /* non-GF present */
+#define DOT11N_TXBURST_PRESENT(add_ie) ((ltoh16_ua(&add_ie->opmode) & DOT11N_TXBURST) \
+ == DOT11N_TXBURST) /* Tx Burst present */
+#define DOT11N_OBSS_NONHT_PRESENT(add_ie) ((ltoh16_ua(&add_ie->opmode) & DOT11N_OBSS_NONHT) \
+ == DOT11N_OBSS_NONHT) /* OBSS Non-HT present */
+
+/* Vendor IE structure */
+struct vndr_ie {
+ uchar id;
+ uchar len;
+ uchar oui [3];
+ uchar data [1]; /* Variable size data */
+} PACKED;
+typedef struct vndr_ie vndr_ie_t;
+
+#define VNDR_IE_HDR_LEN 2 /* id + len field */
+#define VNDR_IE_MIN_LEN 3 /* size of the oui field */
+#define VNDR_IE_MAX_LEN 256 /* verdor IE max length */
+
+/* WPA definitions */
+#define WPA_VERSION 1 /* WPA version */
+#define WPA_OUI "\x00\x50\xF2" /* WPA OUI */
+
+#define WPA2_VERSION 1 /* WPA2 version */
+#define WPA2_VERSION_LEN 2 /* WAP2 version length */
+#define WPA2_OUI "\x00\x0F\xAC" /* WPA2 OUI */
+
+#define WPA_OUI_LEN 3 /* WPA OUI length */
+
+/* RSN authenticated key managment suite */
+#define RSN_AKM_NONE 0 /* None (IBSS) */
+#define RSN_AKM_UNSPECIFIED 1 /* Over 802.1x */
+#define RSN_AKM_PSK 2 /* Pre-shared Key */
+
+/* Key related defines */
+#define DOT11_MAX_DEFAULT_KEYS 4 /* number of default keys */
+#define DOT11_MAX_KEY_SIZE 32 /* max size of any key */
+#define DOT11_MAX_IV_SIZE 16 /* max size of any IV */
+#define DOT11_EXT_IV_FLAG (1<<5) /* flag to indicate IV is > 4 bytes */
+
+#define WEP1_KEY_SIZE 5 /* max size of any WEP key */
+#define WEP1_KEY_HEX_SIZE 10 /* size of WEP key in hex. */
+#define WEP128_KEY_SIZE 13 /* max size of any WEP key */
+#define WEP128_KEY_HEX_SIZE 26 /* size of WEP key in hex. */
+#define TKIP_MIC_SIZE 8 /* size of TKIP MIC */
+#define TKIP_EOM_SIZE 7 /* max size of TKIP EOM */
+#define TKIP_EOM_FLAG 0x5a /* TKIP EOM flag byte */
+#define TKIP_KEY_SIZE 32 /* size of any TKIP key */
+#define TKIP_MIC_AUTH_TX 16 /* offset to Authenticator MIC TX key */
+#define TKIP_MIC_AUTH_RX 24 /* offset to Authenticator MIC RX key */
+#define TKIP_MIC_SUP_RX TKIP_MIC_AUTH_TX /* offset to Supplicant MIC RX key */
+#define TKIP_MIC_SUP_TX TKIP_MIC_AUTH_RX /* offset to Supplicant MIC TX key */
+#define AES_KEY_SIZE 16 /* size of AES key */
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#endif /* _802_11_H_ */
diff --git a/package/broadcom-wl/src/driver/proto/802.11e.h b/package/broadcom-wl/src/driver/proto/802.11e.h
new file mode 100644
index 0000000..e1aa506
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/802.11e.h
@@ -0,0 +1,123 @@
+/*
+ * 802.11e protocol header file
+ *
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ *
+ * $Id$
+ */
+
+#ifndef _802_11e_H_
+#define _802_11e_H_
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+#ifdef BCMDBG
+extern const char *aci_names[];
+#endif /* BCMDBG */
+
+/* WME Traffic Specification (TSPEC) element */
+#define WME_TSPEC_HDR_LEN 2 /* WME TSPEC header length */
+#define WME_TSPEC_BODY_OFF 2 /* WME TSPEC body offset */
+
+#define WME_CATEGORY_CODE_OFFSET 0 /* WME Category code offset */
+#define WME_ACTION_CODE_OFFSET 1 /* WME Action code offset */
+#define WME_TOKEN_CODE_OFFSET 2 /* WME Token code offset */
+#define WME_STATUS_CODE_OFFSET 3 /* WME Status code offset */
+
+struct tsinfo {
+ uint8 octets[3];
+} PACKED;
+
+typedef struct tsinfo tsinfo_t;
+
+/* 802.11e TSPEC IE */
+typedef struct tspec {
+ uint8 oui[DOT11_OUI_LEN]; /* WME_OUI */
+ uint8 type; /* WME_TYPE */
+ uint8 subtype; /* WME_SUBTYPE_TSPEC */
+ uint8 version; /* WME_VERSION */
+ tsinfo_t tsinfo; /* TS Info bit field */
+ uint16 nom_msdu_size; /* (Nominal or fixed) MSDU Size (bytes) */
+ uint16 max_msdu_size; /* Maximum MSDU Size (bytes) */
+ uint32 min_srv_interval; /* Minimum Service Interval (us) */
+ uint32 max_srv_interval; /* Maximum Service Interval (us) */
+ uint32 inactivity_interval; /* Inactivity Interval (us) */
+ uint32 suspension_interval; /* Suspension Interval (us) */
+ uint32 srv_start_time; /* Service Start Time (us) */
+ uint32 min_data_rate; /* Minimum Data Rate (bps) */
+ uint32 mean_data_rate; /* Mean Data Rate (bps) */
+ uint32 peak_data_rate; /* Peak Data Rate (bps) */
+ uint32 max_burst_size; /* Maximum Burst Size (bytes) */
+ uint32 delay_bound; /* Delay Bound (us) */
+ uint32 min_phy_rate; /* Minimum PHY Rate (bps) */
+ uint16 surplus_bw; /* Surplus Bandwidth Allowance Factor */
+ uint16 medium_time; /* Medium Time (32 us/s periods) */
+} PACKED tspec_t;
+
+#define WME_TSPEC_LEN (sizeof(tspec_t)) /* not including 2-bytes of header */
+
+/* ts_info */
+/* 802.1D priority is duplicated - bits 13-11 AND bits 3-1 */
+#define TS_INFO_TID_SHIFT 1 /* TS info. TID shift */
+#define TS_INFO_TID_MASK (0xf << TS_INFO_TID_SHIFT) /* TS info. TID mask */
+#define TS_INFO_CONTENTION_SHIFT 7 /* TS info. contention shift */
+#define TS_INFO_CONTENTION_MASK (0x1 << TS_INFO_CONTENTION_SHIFT) /* TS info. contention mask */
+#define TS_INFO_DIRECTION_SHIFT 5 /* TS info. direction shift */
+#define TS_INFO_DIRECTION_MASK (0x3 << TS_INFO_DIRECTION_SHIFT) /* TS info. direction mask */
+#define TS_INFO_PSB_SHIFT 2 /* TS info. PSB bit Shift */
+#define TS_INFO_PSB_MASK (1 << TS_INFO_PSB_SHIFT) /* TS info. PSB mask */
+#define TS_INFO_UPLINK (0 << TS_INFO_DIRECTION_SHIFT) /* TS info. uplink */
+#define TS_INFO_DOWNLINK (1 << TS_INFO_DIRECTION_SHIFT) /* TS info. downlink */
+#define TS_INFO_BIDIRECTIONAL (3 << TS_INFO_DIRECTION_SHIFT) /* TS info. bidirectional */
+#define TS_INFO_USER_PRIO_SHIFT 3 /* TS info. user priority shift */
+/* TS info. user priority mask */
+#define TS_INFO_USER_PRIO_MASK (0x7 << TS_INFO_USER_PRIO_SHIFT)
+
+/* Macro to get/set bit(s) field in TSINFO */
+#define WLC_CAC_GET_TID(pt) ((((pt).octets[0]) & TS_INFO_TID_MASK) >> TS_INFO_TID_SHIFT)
+#define WLC_CAC_GET_DIR(pt) ((((pt).octets[0]) & \
+ TS_INFO_DIRECTION_MASK) >> TS_INFO_DIRECTION_SHIFT)
+#define WLC_CAC_GET_PSB(pt) ((((pt).octets[1]) & WLC_CAC_PSB_MASK) >> WLC_CAC_PSB_SHIFT)
+#define WLC_CAC_GET_USER_PRIO(pt) ((((pt).octets[1]) & \
+ TS_INFO_USER_PRIO_MASK) >> TS_INFO_USER_PRIO_SHIFT)
+
+#define WLC_CAC_SET_TID(pt, id) ((((pt).octets[0]) & (~TS_INFO_TID_MASK)) | \
+ ((id) << TS_INFO_TID_SHIFT))
+#define WLC_CAC_SET_USER_PRIO(pt, prio) ((((pt).octets[0]) & (~TS_INFO_USER_PRIO_MASK)) | \
+ ((prio) << TS_INFO_USER_PRIO_SHIFT))
+
+/* 802.11e QBSS Load IE */
+#define QBSS_LOAD_IE_LEN 5 /* QBSS Load IE length */
+#define QBSS_LOAD_AAC_OFF 3 /* AAC offset in IE */
+
+#define CAC_ADDTS_RESP_TIMEOUT 300 /* default ADDTS response timeout in ms */
+
+/* 802.11e ADDTS status code */
+#define DOT11E_STATUS_ADMISSION_ACCEPTED 0 /* TSPEC Admission accepted status */
+#define DOT11E_STATUS_ADDTS_INVALID_PARAM 1 /* TSPEC invalid parameter status */
+#define DOT11E_STATUS_ADDTS_REFUSED_NSBW 3 /* ADDTS refused (non-sufficient BW) */
+
+/* 802.11e DELTS status code */
+#define DOT11E_STATUS_QSTA_LEAVE_QBSS 36 /* STA leave QBSS */
+#define DOT11E_STATUS_END_TS 37 /* END TS */
+#define DOT11E_STATUS_UNKNOWN_TS 38 /* UNKNOWN TS */
+#define DOT11E_STATUS_QSTA_REQ_TIMEOUT 39 /* STA ADDTS request timeout */
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#endif /* _802_11e_CAC_H_ */
diff --git a/package/broadcom-wl/src/driver/proto/802.1d.h b/package/broadcom-wl/src/driver/proto/802.1d.h
new file mode 100644
index 0000000..421b963
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/802.1d.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ *
+ * Fundamental types and constants relating to 802.1D
+ *
+ * $Id$
+ */
+
+#ifndef _802_1_D_
+#define _802_1_D_
+
+/* 802.1D priority defines */
+#define PRIO_8021D_NONE 2 /* None = - */
+#define PRIO_8021D_BK 1 /* BK - Background */
+#define PRIO_8021D_BE 0 /* BE - Best-effort */
+#define PRIO_8021D_EE 3 /* EE - Excellent-effort */
+#define PRIO_8021D_CL 4 /* CL - Controlled Load */
+#define PRIO_8021D_VI 5 /* Vi - Video */
+#define PRIO_8021D_VO 6 /* Vo - Voice */
+#define PRIO_8021D_NC 7 /* NC - Network Control */
+#define MAXPRIO 7 /* 0-7 */
+#define NUMPRIO (MAXPRIO + 1)
+
+#define ALLPRIO -1 /* All prioirty */
+
+/* Converts prio to precedence since the numerical value of
+ * PRIO_8021D_BE and PRIO_8021D_NONE are swapped.
+ */
+#define PRIO2PREC(prio) \
+ (((prio) == PRIO_8021D_NONE || (prio) == PRIO_8021D_BE) ? ((prio^2)) : (prio))
+
+#endif /* _802_1_D__ */
diff --git a/package/broadcom-wl/src/driver/proto/802.3.h b/package/broadcom-wl/src/driver/proto/802.3.h
new file mode 100644
index 0000000..54a17c2
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/802.3.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
+ * the contents of this file may not be disclosed to third parties, copied
+ * or duplicated in any form, in whole or in part, without the prior
+ * written permission of Broadcom Corporation.
+ *
+ * Fundamental constants relating to 802.3
+ *
+ * $Id$
+ */
+
+#ifndef _802_3_h_
+#define _802_3_h_
+
+#define SNAP_HDR_LEN 6 /* 802.3 LLC/SNAP header length */
+
+#endif /* #ifndef _802_3_h_ */
diff --git a/package/broadcom-wl/src/driver/proto/bcmarp.h b/package/broadcom-wl/src/driver/proto/bcmarp.h
new file mode 100644
index 0000000..f5058b6
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/bcmarp.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
+ * the contents of this file may not be disclosed to third parties, copied
+ * or duplicated in any form, in whole or in part, without the prior
+ * written permission of Broadcom Corporation.
+ *
+ * Fundamental constants relating to ARP Protocol
+ *
+ * $Id$
+ */
+
+#ifndef _bcmarp_h_
+#define _bcmarp_h_
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+#define ARP_OPC_OFFSET 6 /* option code offset */
+#define ARP_SRC_ETH_OFFSET 8 /* src h/w address offset */
+#define ARP_SRC_IP_OFFSET 14 /* src IP address offset */
+#define ARP_TGT_ETH_OFFSET 18 /* target h/w address offset */
+#define ARP_TGT_IP_OFFSET 24 /* target IP address offset */
+
+#define ARP_OPC_REQUEST 1 /* ARP request */
+#define ARP_OPC_REPLY 2 /* ARP reply */
+
+#define ARP_DATA_LEN 28 /* ARP data length */
+
+struct bcmarp {
+ uint16 htype; /* Header type (1 = ethernet) */
+ uint16 ptype; /* Protocol type (0x800 = IP) */
+ uint8 hlen; /* Hardware address length (Eth = 6) */
+ uint8 plen; /* Protocol address length (IP = 4) */
+ uint16 oper; /* ARP_OPC_... */
+ uint8 src_eth[ETHER_ADDR_LEN]; /* Source hardware address */
+ uint8 src_ip[IPV4_ADDR_LEN]; /* Source protocol address (not aligned) */
+ uint8 dst_eth[ETHER_ADDR_LEN]; /* Destination hardware address */
+ uint8 dst_ip[IPV4_ADDR_LEN]; /* Destination protocol address */
+} PACKED;
+
+/* Ethernet header + Arp message */
+struct bcmetharp {
+ struct ether_header eh;
+ struct bcmarp arp;
+} PACKED;
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#endif /* !defined(_bcmarp_h_) */
diff --git a/package/broadcom-wl/src/driver/proto/bcmdhcp.h b/package/broadcom-wl/src/driver/proto/bcmdhcp.h
new file mode 100644
index 0000000..a2cdc58
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/bcmdhcp.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
+ * the contents of this file may not be disclosed to third parties, copied
+ * or duplicated in any form, in whole or in part, without the prior
+ * written permission of Broadcom Corporation.
+ *
+ * Fundamental constants relating to DHCP Protocol
+ *
+ * $Id$
+ */
+
+#ifndef _bcmdhcp_h_
+#define _bcmdhcp_h_
+
+/* DHCP params */
+#define DHCP_TYPE_OFFSET 0 /* DHCP type (request|reply) offset */
+#define DHCP_FLAGS_OFFSET 10 /* DHCP flags offset */
+#define DHCP_CIADDR_OFFSET 12 /* DHCP client IP address offset */
+#define DHCP_YIADDR_OFFSET 16 /* DHCP your IP address offset */
+#define DHCP_GIADDR_OFFSET 24 /* DHCP relay agent IP address offset */
+#define DHCP_CHADDR_OFFSET 28 /* DHCP client h/w address offset */
+
+#define DHCP_TYPE_REQUEST 1 /* DHCP request (discover|request) */
+#define DHCP_TYPE_REPLY 2 /* DHCP reply (offset|ack) */
+
+#define DHCP_PORT_SERVER 67 /* DHCP server UDP port */
+#define DHCP_PORT_CLIENT 68 /* DHCP client UDP port */
+
+#define DHCP_FLAG_BCAST 0x8000 /* DHCP broadcast flag */
+
+#define DHCP_FLAGS_LEN 2 /* DHCP flags field length */
+
+#endif /* #ifndef _bcmdhcp_h_ */
diff --git a/package/broadcom-wl/src/driver/proto/bcmeth.h b/package/broadcom-wl/src/driver/proto/bcmeth.h
new file mode 100644
index 0000000..23aa411
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/bcmeth.h
@@ -0,0 +1,101 @@
+/*
+ * Broadcom Ethernettype protocol definitions
+ *
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ *
+ * $Id$
+ */
+
+/*
+ * Broadcom Ethernet protocol defines
+ */
+
+#ifndef _BCMETH_H_
+#define _BCMETH_H_
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+/* ETHER_TYPE_BRCM is defined in ethernet.h */
+
+/*
+ * Following the 2byte BRCM ether_type is a 16bit BRCM subtype field
+ * in one of two formats: (only subtypes 32768-65535 are in use now)
+ *
+ * subtypes 0-32767:
+ * 8 bit subtype (0-127)
+ * 8 bit length in bytes (0-255)
+ *
+ * subtypes 32768-65535:
+ * 16 bit big-endian subtype
+ * 16 bit big-endian length in bytes (0-65535)
+ *
+ * length is the number of additional bytes beyond the 4 or 6 byte header
+ *
+ * Reserved values:
+ * 0 reserved
+ * 5-15 reserved for iLine protocol assignments
+ * 17-126 reserved, assignable
+ * 127 reserved
+ * 32768 reserved
+ * 32769-65534 reserved, assignable
+ * 65535 reserved
+ */
+
+/*
+ * While adding the subtypes and their specific processing code make sure
+ * bcmeth_bcm_hdr_t is the first data structure in the user specific data structure definition
+ */
+
+#define BCMILCP_SUBTYPE_RATE 1
+#define BCMILCP_SUBTYPE_LINK 2
+#define BCMILCP_SUBTYPE_CSA 3
+#define BCMILCP_SUBTYPE_LARQ 4
+#define BCMILCP_SUBTYPE_VENDOR 5
+#define BCMILCP_SUBTYPE_FLH 17
+
+#define BCMILCP_SUBTYPE_VENDOR_LONG 32769
+#define BCMILCP_SUBTYPE_CERT 32770
+#define BCMILCP_SUBTYPE_SES 32771
+
+
+#define BCMILCP_BCM_SUBTYPE_RESERVED 0
+#define BCMILCP_BCM_SUBTYPE_EVENT 1
+#define BCMILCP_BCM_SUBTYPE_SES 2
+/*
+ * The EAPOL type is not used anymore. Instead EAPOL messages are now embedded
+ * within BCMILCP_BCM_SUBTYPE_EVENT type messages
+ */
+/* #define BCMILCP_BCM_SUBTYPE_EAPOL 3 */
+
+#define BCMILCP_BCM_SUBTYPEHDR_MINLENGTH 8
+#define BCMILCP_BCM_SUBTYPEHDR_VERSION 0
+
+/* These fields are stored in network order */
+typedef struct bcmeth_hdr
+{
+ uint16 subtype; /* Vendor specific..32769 */
+ uint16 length;
+ uint8 version; /* Version is 0 */
+ uint8 oui[3]; /* Broadcom OUI */
+ /* user specific Data */
+ uint16 usr_subtype;
+} PACKED bcmeth_hdr_t;
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#endif /* _BCMETH_H_ */
diff --git a/package/broadcom-wl/src/driver/proto/bcmevent.h b/package/broadcom-wl/src/driver/proto/bcmevent.h
new file mode 100644
index 0000000..785ef22
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/bcmevent.h
@@ -0,0 +1,166 @@
+/*
+ * Broadcom Event protocol definitions
+ *
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ *
+ *
+ * Dependencies: proto/bcmeth.h
+ *
+ * $Id$
+ *
+ */
+
+/*
+ * Broadcom Ethernet Events protocol defines
+ *
+ */
+
+#ifndef _BCMEVENT_H_
+#define _BCMEVENT_H_
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif /* defined(__GNUC__) */
+
+#define BCM_EVENT_MSG_VERSION 1 /* wl_event_msg_t struct version */
+#define BCM_MSG_IFNAME_MAX 16 /* max length of interface name */
+
+/* flags */
+#define WLC_EVENT_MSG_LINK 0x01 /* link is up */
+#define WLC_EVENT_MSG_FLUSHTXQ 0x02 /* flush tx queue on MIC error */
+#define WLC_EVENT_MSG_GROUP 0x04 /* group MIC error */
+
+/* these fields are stored in network order */
+typedef struct
+{
+ uint16 version;
+ uint16 flags; /* see flags below */
+ uint32 event_type; /* Message (see below) */
+ uint32 status; /* Status code (see below) */
+ uint32 reason; /* Reason code (if applicable) */
+ uint32 auth_type; /* WLC_E_AUTH */
+ uint32 datalen; /* data buf */
+ struct ether_addr addr; /* Station address (if applicable) */
+ char ifname[BCM_MSG_IFNAME_MAX]; /* name of the packet incoming interface */
+} PACKED wl_event_msg_t;
+
+/* used by driver msgs */
+typedef struct bcm_event {
+ struct ether_header eth;
+ bcmeth_hdr_t bcm_hdr;
+ wl_event_msg_t event;
+ /* data portion follows */
+} PACKED bcm_event_t;
+
+#define BCM_MSG_LEN (sizeof(bcm_event_t) - sizeof(bcmeth_hdr_t) - sizeof(struct ether_header))
+
+/* Event messages */
+#define WLC_E_SET_SSID 0 /* indicates status of set SSID */
+#define WLC_E_JOIN 1 /* differentiates join IBSS from found (WLC_E_START) IBSS */
+#define WLC_E_START 2 /* STA founded an IBSS or AP started a BSS */
+#define WLC_E_AUTH 3 /* 802.11 AUTH request */
+#define WLC_E_AUTH_IND 4 /* 802.11 AUTH indication */
+#define WLC_E_DEAUTH 5 /* 802.11 DEAUTH request */
+#define WLC_E_DEAUTH_IND 6 /* 802.11 DEAUTH indication */
+#define WLC_E_ASSOC 7 /* 802.11 ASSOC request */
+#define WLC_E_ASSOC_IND 8 /* 802.11 ASSOC indication */
+#define WLC_E_REASSOC 9 /* 802.11 REASSOC request */
+#define WLC_E_REASSOC_IND 10 /* 802.11 REASSOC indication */
+#define WLC_E_DISASSOC 11 /* 802.11 DISASSOC request */
+#define WLC_E_DISASSOC_IND 12 /* 802.11 DISASSOC indication */
+#define WLC_E_QUIET_START 13 /* 802.11h Quiet period started */
+#define WLC_E_QUIET_END 14 /* 802.11h Quiet period ended */
+#define WLC_E_BEACON_RX 15 /* BEACONS received/lost indication */
+#define WLC_E_LINK 16 /* generic link indication */
+#define WLC_E_MIC_ERROR 17 /* TKIP MIC error occurred */
+#define WLC_E_NDIS_LINK 18 /* NDIS style link indication */
+#define WLC_E_ROAM 19 /* roam attempt occurred: indicate status & reason */
+#define WLC_E_TXFAIL 20 /* change in dot11FailedCount (txfail) */
+#define WLC_E_PMKID_CACHE 21 /* WPA2 pmkid cache indication */
+#define WLC_E_RETROGRADE_TSF 22 /* current AP's TSF value went backward */
+#define WLC_E_PRUNE 23 /* AP was pruned from join list for reason */
+#define WLC_E_AUTOAUTH 24 /* report AutoAuth table entry match for join attempt */
+#define WLC_E_EAPOL_MSG 25 /* Event encapsulating an EAPOL message */
+#define WLC_E_SCAN_COMPLETE 26 /* Scan results are ready or scan was aborted */
+#define WLC_E_ADDTS_IND 27 /* indicate to host addts fail/success */
+#define WLC_E_DELTS_IND 28 /* indicate to host delts fail/success */
+#define WLC_E_BCNSENT_IND 29 /* indicate to host of beacon transmit */
+#define WLC_E_BCNRX_MSG 30 /* Send the received beacon up to the host */
+#define WLC_E_BCNLOST_MSG 31 /* indicate to host loss of beacon */
+#define WLC_E_ROAM_PREP 32 /* before attempting to roam */
+#define WLC_E_PFN_NET_FOUND 33 /* PFN network found event */
+#define WLC_E_PFN_NET_LOST 34 /* PFN network lost event */
+
+#ifdef EXT_STA
+#define WLC_E_RESET_COMPLETE 35
+#define WLC_E_JOIN_START 36
+#define WLC_E_ROAM_START 37
+#define WLC_E_ASSOC_START 38
+#define WLC_E_IBSS_ASSOC 39
+#define WLC_E_RADIO 40
+#define WLC_E_LAST 41 /* highest val + 1 for range checking */
+#else /* EXT_STA */
+#define WLC_E_LAST 35 /* highest val + 1 for range checking */
+#endif /* EXT_STA */
+
+/* Event status codes */
+#define WLC_E_STATUS_SUCCESS 0 /* operation was successful */
+#define WLC_E_STATUS_FAIL 1 /* operation failed */
+#define WLC_E_STATUS_TIMEOUT 2 /* operation timed out */
+#define WLC_E_STATUS_NO_NETWORKS 3 /* failed due to no matching network found */
+#define WLC_E_STATUS_ABORT 4 /* operation was aborted */
+#define WLC_E_STATUS_NO_ACK 5 /* protocol failure: packet not ack'd */
+#define WLC_E_STATUS_UNSOLICITED 6 /* AUTH or ASSOC packet was unsolicited */
+#define WLC_E_STATUS_ATTEMPT 7 /* attempt to assoc to an auto auth configuration */
+#define WLC_E_STATUS_PARTIAL 8 /* scan results are incomplete */
+#define WLC_E_STATUS_NEWSCAN 9 /* scan aborted by another scan */
+#define WLC_E_STATUS_NEWASSOC 10 /* scan aborted due to assoc in progress */
+#define WLC_E_STATUS_11HQUIET 11 /* 802.11h quiet period started */
+#define WLC_E_STATUS_SUPPRESS 12 /* user disabled scanning (WLC_SET_SCANSUPPRESS) */
+#define WLC_E_STATUS_NOCHANS 13 /* no allowable channels to scan */
+#define WLC_E_STATUS_CCXFASTRM 14 /* scan aborted due to CCX fast roam */
+
+/* roam reason codes */
+#define WLC_E_REASON_INITIAL_ASSOC 0 /* initial assoc */
+#define WLC_E_REASON_LOW_RSSI 1 /* roamed due to low RSSI */
+#define WLC_E_REASON_DEAUTH 2 /* roamed due to DEAUTH indication */
+#define WLC_E_REASON_DISASSOC 3 /* roamed due to DISASSOC indication */
+#define WLC_E_REASON_BCNS_LOST 4 /* roamed due to lost beacons */
+#define WLC_E_REASON_FAST_ROAM_FAILED 5 /* roamed due to fast roam failure */
+#define WLC_E_REASON_DIRECTED_ROAM 6 /* roamed due to request by AP */
+#define WLC_E_REASON_TSPEC_REJECTED 7 /* roamed due to TSPEC rejection */
+#define WLC_E_REASON_BETTER_AP 8 /* roamed due to finding better AP */
+
+/* prune reason codes */
+#define WLC_E_PRUNE_ENCR_MISMATCH 1 /* encryption mismatch */
+#define WLC_E_PRUNE_BCAST_BSSID 2 /* AP uses a broadcast BSSID */
+#define WLC_E_PRUNE_MAC_DENY 3 /* STA's MAC addr is in AP's MAC deny list */
+#define WLC_E_PRUNE_MAC_NA 4 /* STA's MAC addr is not in AP's MAC allow list */
+#define WLC_E_PRUNE_REG_PASSV 5 /* AP not allowed due to regulatory restriction */
+#define WLC_E_PRUNE_SPCT_MGMT 6 /* AP does not support STA locale spectrum mgmt */
+#define WLC_E_PRUNE_RADAR 7 /* AP is on a radar channel of STA locale */
+#define WLC_E_RSN_MISMATCH 8 /* STA does not support AP's RSN */
+#define WLC_E_PRUNE_NO_COMMON_RATES 9 /* No rates in common with AP */
+#define WLC_E_PRUNE_BASIC_RATES 10 /* STA does not support all basic rates of BSS */
+#define WLC_E_PRUNE_CIPHER_NA 12 /* BSS's cipher not supported */
+#define WLC_E_PRUNE_KNOWN_STA 13 /* AP is already known to us as a STA */
+#define WLC_E_PRUNE_WDS_PEER 15 /* AP is already known to us as a WDS peer */
+#define WLC_E_PRUNE_QBSS_LOAD 16 /* QBSS LOAD - AAC is too low */
+#define WLC_E_PRUNE_HOME_AP 17 /* prune home AP */
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif /* PACKED */
+
+#endif /* _BCMEVENT_H_ */
diff --git a/package/broadcom-wl/src/driver/proto/bcmip.h b/package/broadcom-wl/src/driver/proto/bcmip.h
new file mode 100644
index 0000000..4169060
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/bcmip.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ *
+ * Fundamental constants relating to IP Protocol
+ *
+ * $Id$
+ */
+
+#ifndef _bcmip_h_
+#define _bcmip_h_
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+
+/* IPV4 and IPV6 common */
+#define IP_VER_OFFSET 0x0 /* offset to version field */
+#define IP_VER_MASK 0xf0 /* version mask */
+#define IP_VER_SHIFT 4 /* version shift */
+#define IP_VER_4 4 /* version number for IPV4 */
+#define IP_VER_6 6 /* version number for IPV6 */
+
+#define IP_VER(ip_body) \
+ ((((uint8 *)(ip_body))[IP_VER_OFFSET] & IP_VER_MASK) >> IP_VER_SHIFT)
+
+#define IP_PROT_ICMP 0x1 /* ICMP protocol */
+#define IP_PROT_TCP 0x6 /* TCP protocol */
+#define IP_PROT_UDP 0x11 /* UDP protocol type */
+
+/* IPV4 field offsets */
+#define IPV4_VER_HL_OFFSET 0 /* version and ihl byte offset */
+#define IPV4_TOS_OFFSET 1 /* type of service offset */
+#define IPV4_PKTLEN_OFFSET 2 /* packet length offset */
+#define IPV4_PKTFLAG_OFFSET 6 /* more-frag,dont-frag flag offset */
+#define IPV4_PROT_OFFSET 9 /* protocol type offset */
+#define IPV4_CHKSUM_OFFSET 10 /* IP header checksum offset */
+#define IPV4_SRC_IP_OFFSET 12 /* src IP addr offset */
+#define IPV4_DEST_IP_OFFSET 16 /* dest IP addr offset */
+#define IPV4_OPTIONS_OFFSET 20 /* IP options offset */
+
+/* IPV4 field decodes */
+#define IPV4_VER_MASK 0xf0 /* IPV4 version mask */
+#define IPV4_VER_SHIFT 4 /* IPV4 version shift */
+
+#define IPV4_HLEN_MASK 0x0f /* IPV4 header length mask */
+#define IPV4_HLEN(ipv4_body) (4 * (((uint8 *)(ipv4_body))[IPV4_VER_HL_OFFSET] & IPV4_HLEN_MASK))
+
+#define IPV4_ADDR_LEN 4 /* IPV4 address length */
+
+#define IPV4_ADDR_NULL(a) ((((uint8 *)(a))[0] | ((uint8 *)(a))[1] | \
+ ((uint8 *)(a))[2] | ((uint8 *)(a))[3]) == 0)
+
+#define IPV4_ADDR_BCAST(a) ((((uint8 *)(a))[0] & ((uint8 *)(a))[1] & \
+ ((uint8 *)(a))[2] & ((uint8 *)(a))[3]) == 0xff)
+
+#define IPV4_TOS_DSCP_MASK 0xfc /* DiffServ codepoint mask */
+#define IPV4_TOS_DSCP_SHIFT 2 /* DiffServ codepoint shift */
+
+#define IPV4_TOS(ipv4_body) (((uint8 *)(ipv4_body))[IPV4_TOS_OFFSET])
+
+#define IPV4_TOS_PREC_MASK 0xe0 /* Historical precedence mask */
+#define IPV4_TOS_PREC_SHIFT 5 /* Historical precedence shift */
+
+#define IPV4_TOS_LOWDELAY 0x10 /* Lowest delay requested */
+#define IPV4_TOS_THROUGHPUT 0x8 /* Best throughput requested */
+#define IPV4_TOS_RELIABILITY 0x4 /* Most reliable delivery requested */
+
+#define IPV4_PROT(ipv4_body) (((uint8 *)(ipv4_body))[IPV4_PROT_OFFSET])
+
+#define IPV4_FRAG_RESV 0x8000 /* Reserved */
+#define IPV4_FRAG_DONT 0x4000 /* Don't fragment */
+#define IPV4_FRAG_MORE 0x2000 /* More fragments */
+#define IPV4_FRAG_OFFSET_MASK 0x1fff /* Fragment offset */
+
+#define IPV4_ADDR_STR_LEN 16 /* Max IP address length in string format */
+
+/* IPv4, no options only. */
+#define IPV4_NO_OPTIONS_HDR_LEN 20
+#define IPV4_NO_OPTIONS_PAYLOAD(ip_hdr) (&(((uint8 *)(ip_hdr))[IPV4_NO_OPTIONS_HDR_LEN]))
+
+#define IPV4_PAYLOAD_LEN(ip_body) \
+ (((int)(((uint8 *)(ip_body))[IPV4_PKTLEN_OFFSET + 0]) << 8) | \
+ ((uint8 *)(ip_body))[IPV4_PKTLEN_OFFSET + 1])
+
+/* IPV4 packet formats */
+struct ipv4_addr {
+ uint8 addr[IPV4_ADDR_LEN];
+} PACKED;
+
+struct ipv4_hdr {
+ uint8 version_ihl; /* Version and Internet Header Length */
+ uint8 tos; /* Type Of Service */
+ uint16 tot_len; /* Number of bytes in packet (max 65535) */
+ uint16 id;
+ uint16 frag; /* 3 flag bits and fragment offset */
+ uint8 ttl; /* Time To Live */
+ uint8 prot; /* Protocol */
+ uint16 hdr_chksum; /* IP header checksum */
+ uint8 src_ip[IPV4_ADDR_LEN]; /* Source IP Address */
+ uint8 dst_ip[IPV4_ADDR_LEN]; /* Destination IP Address */
+} PACKED;
+
+/* IPV6 field offsets */
+#define IPV6_PAYLOAD_LEN_OFFSET 4 /* payload length offset */
+#define IPV6_NEXT_HDR_OFFSET 6 /* next header/protocol offset */
+#define IPV6_HOP_LIMIT_OFFSET 7 /* hop limit offset */
+#define IPV6_SRC_IP_OFFSET 8 /* src IP addr offset */
+#define IPV6_DEST_IP_OFFSET 24 /* dst IP addr offset */
+
+/* IPV6 field decodes */
+#define IPV6_TRAFFIC_CLASS(ipv6_body) \
+ (((((uint8 *)(ipv6_body))[0] & 0x0f) << 4) | \
+ ((((uint8 *)(ipv6_body))[1] & 0xf0) >> 4))
+
+#define IPV6_FLOW_LABEL(ipv6_body) \
+ (((((uint8 *)(ipv6_body))[1] & 0x0f) << 16) | \
+ (((uint8 *)(ipv6_body))[2] << 8) | \
+ (((uint8 *)(ipv6_body))[3]))
+
+#define IPV6_PAYLOAD_LEN(ipv6_body) \
+ ((((uint8 *)(ipv6_body))[IPV6_PAYLOAD_LEN_OFFSET + 0] << 8) | \
+ ((uint8 *)(ipv6_body))[IPV6_PAYLOAD_LEN_OFFSET + 1])
+
+#define IPV6_NEXT_HDR(ipv6_body) \
+ (((uint8 *)(ipv6_body))[IPV6_NEXT_HDR_OFFSET])
+
+#define IPV6_PROT(ipv6_body) IPV6_NEXT_HDR(ipv6_body)
+
+#define IPV6_ADDR_LEN 16 /* IPV6 address length */
+
+/* IPV4 TOS or IPV6 Traffic Classifier or 0 */
+#define IP_TOS(ip_body) \
+ (IP_VER(ip_body) == IP_VER_4 ? IPV4_TOS(ip_body) : \
+ IP_VER(ip_body) == IP_VER_6 ? IPV6_TRAFFIC_CLASS(ip_body) : 0)
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#endif /* _bcmip_h_ */
diff --git a/package/broadcom-wl/src/driver/proto/bcmtcp.h b/package/broadcom-wl/src/driver/proto/bcmtcp.h
new file mode 100644
index 0000000..832fd43
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/bcmtcp.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ *
+ * Fundamental constants relating to TCP Protocol
+ *
+ * $Id$
+ */
+
+#ifndef _bcmtcp_h_
+#define _bcmtcp_h_
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+#define TCP_SRC_PORT_OFFSET 0 /* TCP source port offset */
+#define TCP_DEST_PORT_OFFSET 2 /* TCP dest port offset */
+#define TCP_CHKSUM_OFFSET 16 /* TCP body checksum offset */
+
+/* These fields are stored in network order */
+struct bcmtcp_hdr
+{
+ uint16 src_port; /* Source Port Address */
+ uint16 dst_port; /* Destination Port Address */
+ uint32 seq_num; /* TCP Sequence Number */
+ uint32 ack_num; /* TCP Sequence Number */
+ uint16 hdrlen_rsvd_flags; /* Header length, reserved bits and flags */
+ uint16 tcpwin; /* TCP window */
+ uint16 chksum; /* Segment checksum with pseudoheader */
+ uint16 urg_ptr; /* Points to seq-num of byte following urg data */
+} PACKED;
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+/* Byte offset of flags in TCP header */
+#define TCP_FLAGS_OFFSET 13
+
+#define TCP_FLAGS_FIN 0x01
+#define TCP_FLAGS_SYN 0x02
+#define TCP_FLAGS_RST 0x03
+#define TCP_FLAGS_PSH 0x04
+#define TCP_FLAGS_ACK 0x10
+#define TCP_FLAGS_URG 0x20
+#define TCP_FLAGS_ECN 0x40
+#define TCP_FLAGS_CWR 0x80
+
+#define TCP_FLAGS(tcp_hdr) (((uint8 *)(tcp_hdr))[TCP_FLAGS_OFFSET])
+#define TCP_IS_ACK(tcp_hdr) (TCP_FLAGS(tcp_hdr) & TCP_FLAGS_ACK)
+
+#define TCP_SRC_PORT(tcp_hdr) (ntoh16(((struct bcmtcp_hdr*)(tcp_hdr))->src_port))
+#define TCP_DST_PORT(tcp_hdr) (ntoh16(((struct bcmtcp_hdr*)(tcp_hdr))->dst_port))
+#define TCP_SEQ_NUM(tcp_hdr) (ntoh32(((struct bcmtcp_hdr*)(tcp_hdr))->seq_num))
+#define TCP_ACK_NUM(tcp_hdr) (ntoh32(((struct bcmtcp_hdr*)(tcp_hdr))->ack_num))
+
+#endif /* #ifndef _bcmtcp_h_ */
diff --git a/package/broadcom-wl/src/driver/proto/bcmudp.h b/package/broadcom-wl/src/driver/proto/bcmudp.h
new file mode 100644
index 0000000..5464284
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/bcmudp.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
+ * the contents of this file may not be disclosed to third parties, copied
+ * or duplicated in any form, in whole or in part, without the prior
+ * written permission of Broadcom Corporation.
+ *
+ * Fundamental constants relating to UDP Protocol
+ *
+ * $Id$
+ */
+
+#ifndef _bcmudp_h_
+#define _bcmudp_h_
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+/* UDP header */
+#define UDP_DEST_PORT_OFFSET 2 /* UDP dest port offset */
+#define UDP_LEN_OFFSET 4 /* UDP length offset */
+#define UDP_CHKSUM_OFFSET 6 /* UDP body checksum offset */
+
+#define UDP_HDR_LEN 8 /* UDP header length */
+#define UDP_PORT_LEN 2 /* UDP port length */
+
+/* These fields are stored in network order */
+struct bcmudp_hdr
+{
+ uint16 src_port; /* Source Port Address */
+ uint16 dst_port; /* Destination Port Address */
+ uint16 len; /* Number of bytes in datagram including header */
+ uint16 chksum; /* entire datagram checksum with pseudoheader */
+} PACKED;
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#endif /* #ifndef _bcmudp_h_ */
diff --git a/package/broadcom-wl/src/driver/proto/eap.h b/package/broadcom-wl/src/driver/proto/eap.h
new file mode 100644
index 0000000..5548e2f
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/eap.h
@@ -0,0 +1,45 @@
+/*
+ * Extensible Authentication Protocol (EAP) definitions
+ *
+ * See
+ * RFC 2284: PPP Extensible Authentication Protocol (EAP)
+ *
+ * Copyright (C) 2002 Broadcom Corporation
+ *
+ * $Id$
+ */
+
+#ifndef _eap_h_
+#define _eap_h_
+
+/* EAP packet format */
+typedef struct {
+ unsigned char code; /* EAP code */
+ unsigned char id; /* Current request ID */
+ unsigned short length; /* Length including header */
+ unsigned char type; /* EAP type (optional) */
+ unsigned char data[1]; /* Type data (optional) */
+} eap_header_t;
+
+#define EAP_HEADER_LEN 4
+
+/* EAP codes */
+#define EAP_REQUEST 1
+#define EAP_RESPONSE 2
+#define EAP_SUCCESS 3
+#define EAP_FAILURE 4
+
+/* EAP types */
+#define EAP_IDENTITY 1
+#define EAP_NOTIFICATION 2
+#define EAP_NAK 3
+#define EAP_MD5 4
+#define EAP_OTP 5
+#define EAP_GTC 6
+#define EAP_TLS 13
+#define EAP_EXPANDED 254
+#define BCM_EAP_SES 10
+#define BCM_EAP_EXP_LEN 12 /* EAP_LEN 5 + 3 bytes for SMI ID + 4 bytes for ven type */
+#define BCM_SMI_ID 0x113d
+
+#endif /* _eap_h_ */
diff --git a/package/broadcom-wl/src/driver/proto/eapol.h b/package/broadcom-wl/src/driver/proto/eapol.h
new file mode 100644
index 0000000..9a1a58d
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/eapol.h
@@ -0,0 +1,179 @@
+/*
+ * 802.1x EAPOL definitions
+ *
+ * See
+ * IEEE Std 802.1X-2001
+ * IEEE 802.1X RADIUS Usage Guidelines
+ *
+ * Copyright (C) 2002 Broadcom Corporation
+ *
+ * $Id$
+ */
+
+#ifndef _eapol_h_
+#define _eapol_h_
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+#include <bcmcrypto/aeskeywrap.h>
+
+/* EAPOL for 802.3/Ethernet */
+typedef struct {
+ struct ether_header eth; /* 802.3/Ethernet header */
+ unsigned char version; /* EAPOL protocol version */
+ unsigned char type; /* EAPOL type */
+ unsigned short length; /* Length of body */
+ unsigned char body[1]; /* Body (optional) */
+} eapol_header_t;
+
+#define EAPOL_HEADER_LEN 18
+
+/* EAPOL version */
+#define WPA2_EAPOL_VERSION 2
+#define WPA_EAPOL_VERSION 1
+#define LEAP_EAPOL_VERSION 1
+#define SES_EAPOL_VERSION 1
+
+/* EAPOL types */
+#define EAP_PACKET 0
+#define EAPOL_START 1
+#define EAPOL_LOGOFF 2
+#define EAPOL_KEY 3
+#define EAPOL_ASF 4
+
+/* EAPOL-Key types */
+#define EAPOL_RC4_KEY 1
+#ifdef BCMWPA2
+#define EAPOL_WPA2_KEY 2 /* 802.11i/WPA2 */
+#endif
+#define EAPOL_WPA_KEY 254 /* WPA */
+
+/* RC4 EAPOL-Key header field sizes */
+#define EAPOL_KEY_REPLAY_LEN 8
+#define EAPOL_KEY_IV_LEN 16
+#define EAPOL_KEY_SIG_LEN 16
+
+/* RC4 EAPOL-Key */
+typedef struct {
+ unsigned char type; /* Key Descriptor Type */
+ unsigned short length; /* Key Length (unaligned) */
+ unsigned char replay[EAPOL_KEY_REPLAY_LEN]; /* Replay Counter */
+ unsigned char iv[EAPOL_KEY_IV_LEN]; /* Key IV */
+ unsigned char index; /* Key Flags & Index */
+ unsigned char signature[EAPOL_KEY_SIG_LEN]; /* Key Signature */
+ unsigned char key[1]; /* Key (optional) */
+} PACKED eapol_key_header_t;
+
+#define EAPOL_KEY_HEADER_LEN 44
+
+/* RC4 EAPOL-Key flags */
+#define EAPOL_KEY_FLAGS_MASK 0x80
+#define EAPOL_KEY_BROADCAST 0
+#define EAPOL_KEY_UNICAST 0x80
+
+/* RC4 EAPOL-Key index */
+#define EAPOL_KEY_INDEX_MASK 0x7f
+
+/* WPA/802.11i/WPA2 EAPOL-Key header field sizes */
+#define EAPOL_WPA_KEY_REPLAY_LEN 8
+#define EAPOL_WPA_KEY_NONCE_LEN 32
+#define EAPOL_WPA_KEY_IV_LEN 16
+#define EAPOL_WPA_KEY_RSC_LEN 8
+#define EAPOL_WPA_KEY_ID_LEN 8
+#define EAPOL_WPA_KEY_MIC_LEN 16
+#define EAPOL_WPA_KEY_DATA_LEN (EAPOL_WPA_MAX_KEY_SIZE + AKW_BLOCK_LEN)
+#define EAPOL_WPA_MAX_KEY_SIZE 32
+
+/* WPA EAPOL-Key */
+typedef struct {
+ unsigned char type; /* Key Descriptor Type */
+ unsigned short key_info; /* Key Information (unaligned) */
+ unsigned short key_len; /* Key Length (unaligned) */
+ unsigned char replay[EAPOL_WPA_KEY_REPLAY_LEN]; /* Replay Counter */
+ unsigned char nonce[EAPOL_WPA_KEY_NONCE_LEN]; /* Nonce */
+ unsigned char iv[EAPOL_WPA_KEY_IV_LEN]; /* Key IV */
+ unsigned char rsc[EAPOL_WPA_KEY_RSC_LEN]; /* Key RSC */
+ unsigned char id[EAPOL_WPA_KEY_ID_LEN]; /* WPA:Key ID, 802.11i/WPA2: Reserved */
+ unsigned char mic[EAPOL_WPA_KEY_MIC_LEN]; /* Key MIC */
+ unsigned short data_len; /* Key Data Length */
+ unsigned char data[EAPOL_WPA_KEY_DATA_LEN]; /* Key data */
+} PACKED eapol_wpa_key_header_t;
+
+#define EAPOL_WPA_KEY_LEN 95
+
+/* WPA/802.11i/WPA2 KEY KEY_INFO bits */
+#define WPA_KEY_DESC_V1 0x01
+#define WPA_KEY_DESC_V2 0x02
+#define WPA_KEY_PAIRWISE 0x08
+#define WPA_KEY_INSTALL 0x40
+#define WPA_KEY_ACK 0x80
+#define WPA_KEY_MIC 0x100
+#define WPA_KEY_SECURE 0x200
+#define WPA_KEY_ERROR 0x400
+#define WPA_KEY_REQ 0x800
+
+/* WPA-only KEY KEY_INFO bits */
+#define WPA_KEY_INDEX_0 0x00
+#define WPA_KEY_INDEX_1 0x10
+#define WPA_KEY_INDEX_2 0x20
+#define WPA_KEY_INDEX_3 0x30
+#define WPA_KEY_INDEX_MASK 0x30
+#define WPA_KEY_INDEX_SHIFT 0x04
+
+#ifdef BCMWPA2
+/* 802.11i/WPA2-only KEY KEY_INFO bits */
+#define WPA_KEY_ENCRYPTED_DATA 0x1000
+
+/* Key Data encapsulation */
+typedef struct {
+ uint8 type;
+ uint8 length;
+ uint8 oui[3];
+ uint8 subtype;
+ uint8 data[1];
+} PACKED eapol_wpa2_encap_data_t;
+
+#define EAPOL_WPA2_ENCAP_DATA_HDR_LEN 6
+
+#define WPA2_KEY_DATA_SUBTYPE_GTK 1
+#define WPA2_KEY_DATA_SUBTYPE_STAKEY 2
+#define WPA2_KEY_DATA_SUBTYPE_MAC 3
+#define WPA2_KEY_DATA_SUBTYPE_PMKID 4
+
+/* GTK encapsulation */
+typedef struct {
+ uint8 flags;
+ uint8 reserved;
+ uint8 gtk[EAPOL_WPA_MAX_KEY_SIZE];
+} PACKED eapol_wpa2_key_gtk_encap_t;
+
+#define EAPOL_WPA2_KEY_GTK_ENCAP_HDR_LEN 2
+
+#define WPA2_GTK_INDEX_MASK 0x03
+#define WPA2_GTK_INDEX_SHIFT 0x00
+
+#define WPA2_GTK_TRANSMIT 0x04
+
+/* STAKey encapsulation */
+typedef struct {
+ uint8 reserved[2];
+ uint8 mac[ETHER_ADDR_LEN];
+ uint8 stakey[EAPOL_WPA_MAX_KEY_SIZE];
+} PACKED eapol_wpa2_key_stakey_encap_t;
+
+#define WPA2_KEY_DATA_PAD 0xdd
+
+#endif /* BCMWPA2 */
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#endif /* _eapol_h_ */
diff --git a/package/broadcom-wl/src/driver/proto/ethernet.h b/package/broadcom-wl/src/driver/proto/ethernet.h
new file mode 100644
index 0000000..b674e0c
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/ethernet.h
@@ -0,0 +1,175 @@
+/*
+ * From FreeBSD 2.2.7: Fundamental constants relating to ethernet.
+ *
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ *
+ * $Id$
+ */
+
+#ifndef _NET_ETHERNET_H_ /* use native BSD ethernet.h when available */
+#define _NET_ETHERNET_H_
+
+#ifndef _TYPEDEFS_H_
+#include "typedefs.h"
+#endif
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+/*
+ * The number of bytes in an ethernet (MAC) address.
+ */
+#define ETHER_ADDR_LEN 6
+
+/*
+ * The number of bytes in the type field.
+ */
+#define ETHER_TYPE_LEN 2
+
+/*
+ * The number of bytes in the trailing CRC field.
+ */
+#define ETHER_CRC_LEN 4
+
+/*
+ * The length of the combined header.
+ */
+#define ETHER_HDR_LEN (ETHER_ADDR_LEN * 2 + ETHER_TYPE_LEN)
+
+/*
+ * The minimum packet length.
+ */
+#define ETHER_MIN_LEN 64
+
+/*
+ * The minimum packet user data length.
+ */
+#define ETHER_MIN_DATA 46
+
+/*
+ * The maximum packet length.
+ */
+#define ETHER_MAX_LEN 1518
+
+/*
+ * The maximum packet user data length.
+ */
+#define ETHER_MAX_DATA 1500
+
+/* ether types */
+#define ETHER_TYPE_MIN 0x0600 /* Anything less than MIN is a length */
+#define ETHER_TYPE_IP 0x0800 /* IP */
+#define ETHER_TYPE_ARP 0x0806 /* ARP */
+#define ETHER_TYPE_8021Q 0x8100 /* 802.1Q */
+#define ETHER_TYPE_BRCM 0x886c /* Broadcom Corp. */
+#define ETHER_TYPE_802_1X 0x888e /* 802.1x */
+#ifdef BCMWPA2
+#define ETHER_TYPE_802_1X_PREAUTH 0x88c7 /* 802.1x preauthentication */
+#endif
+
+/* Broadcom subtype follows ethertype; First 2 bytes are reserved; Next 2 are subtype; */
+#define ETHER_BRCM_SUBTYPE_LEN 4 /* Broadcom 4 byte subtype */
+#define ETHER_BRCM_CRAM 0x1 /* Broadcom subtype cram protocol */
+
+/* ether header */
+#define ETHER_DEST_OFFSET (0 * ETHER_ADDR_LEN) /* dest address offset */
+#define ETHER_SRC_OFFSET (1 * ETHER_ADDR_LEN) /* src address offset */
+#define ETHER_TYPE_OFFSET (2 * ETHER_ADDR_LEN) /* ether type offset */
+
+/*
+ * A macro to validate a length with
+ */
+#define ETHER_IS_VALID_LEN(foo) \
+ ((foo) >= ETHER_MIN_LEN && (foo) <= ETHER_MAX_LEN)
+
+
+#ifndef __INCif_etherh /* Quick and ugly hack for VxWorks */
+/*
+ * Structure of a 10Mb/s Ethernet header.
+ */
+struct ether_header {
+ uint8 ether_dhost[ETHER_ADDR_LEN];
+ uint8 ether_shost[ETHER_ADDR_LEN];
+ uint16 ether_type;
+} PACKED;
+
+/*
+ * Structure of a 48-bit Ethernet address.
+ */
+#ifndef NOETHREQ /* Quick and ugly hack for VxWorks */
+struct ether_addr {
+ uint8 octet[ETHER_ADDR_LEN];
+} PACKED;
+#endif
+#endif /* !__INCif_etherh Quick and ugly hack for VxWorks */
+
+/*
+ * Takes a pointer, set, test, clear, toggle locally admininistered
+ * address bit in the 48-bit Ethernet address.
+ */
+#define ETHER_SET_LOCALADDR(ea) (((uint8 *)(ea))[0] = (((uint8 *)(ea))[0] | 2))
+#define ETHER_IS_LOCALADDR(ea) (((uint8 *)(ea))[0] & 2)
+#define ETHER_CLR_LOCALADDR(ea) (((uint8 *)(ea))[0] = (((uint8 *)(ea))[0] & 0xd))
+#define ETHER_TOGGLE_LOCALADDR(ea) (((uint8 *)(ea))[0] = (((uint8 *)(ea))[0] ^ 2))
+
+/* Takes a pointer, marks unicast address bit in the MAC address */
+#define ETHER_SET_UNICAST(ea) (((uint8 *)(ea))[0] = (((uint8 *)(ea))[0] & ~1))
+
+/*
+ * Takes a pointer, returns true if a 48-bit multicast address
+ * (including broadcast, since it is all ones)
+ */
+#define ETHER_ISMULTI(ea) (((const uint8 *)(ea))[0] & 1)
+
+
+/* compare two ethernet addresses - assumes the pointers can be referenced as shorts */
+#define ether_cmp(a, b) (!(((short*)a)[0] == ((short*)b)[0]) | \
+ !(((short*)a)[1] == ((short*)b)[1]) | \
+ !(((short*)a)[2] == ((short*)b)[2]))
+
+/* copy an ethernet address - assumes the pointers can be referenced as shorts */
+#define ether_copy(s, d) { \
+ ((short*)d)[0] = ((short*)s)[0]; \
+ ((short*)d)[1] = ((short*)s)[1]; \
+ ((short*)d)[2] = ((short*)s)[2]; }
+
+/*
+ * Takes a pointer, returns true if a 48-bit broadcast (all ones)
+ */
+#define ETHER_ISBCAST(ea) ((((uint8 *)(ea))[0] & \
+ ((uint8 *)(ea))[1] & \
+ ((uint8 *)(ea))[2] & \
+ ((uint8 *)(ea))[3] & \
+ ((uint8 *)(ea))[4] & \
+ ((uint8 *)(ea))[5]) == 0xff)
+
+static const struct ether_addr ether_bcast = {{255, 255, 255, 255, 255, 255}};
+static const struct ether_addr ether_null = {{0, 0, 0, 0, 0, 0}};
+
+/*
+ * Takes a pointer, returns true if a 48-bit null address (all zeros)
+ */
+#define ETHER_ISNULLADDR(ea) ((((uint8 *)(ea))[0] | \
+ ((uint8 *)(ea))[1] | \
+ ((uint8 *)(ea))[2] | \
+ ((uint8 *)(ea))[3] | \
+ ((uint8 *)(ea))[4] | \
+ ((uint8 *)(ea))[5]) == 0)
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#endif /* _NET_ETHERNET_H_ */
diff --git a/package/broadcom-wl/src/driver/proto/vlan.h b/package/broadcom-wl/src/driver/proto/vlan.h
new file mode 100644
index 0000000..2854b72
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/vlan.h
@@ -0,0 +1,52 @@
+/*
+ * 802.1Q VLAN protocol definitions
+ *
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ *
+ * $Id$
+ */
+
+#ifndef _vlan_h_
+#define _vlan_h_
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+#define VLAN_VID_MASK 0xfff /* low 12 bits are vlan id */
+#define VLAN_CFI_SHIFT 12 /* canonical format indicator bit */
+#define VLAN_PRI_SHIFT 13 /* user priority */
+
+#define VLAN_PRI_MASK 7 /* 3 bits of priority */
+
+#define VLAN_TAG_LEN 4
+#define VLAN_TAG_OFFSET (2 * ETHER_ADDR_LEN) /* offset in Ethernet II packet only */
+
+#define VLAN_TPID 0x8100 /* VLAN ethertype/Tag Protocol ID */
+
+struct ethervlan_header {
+ uint8 ether_dhost[ETHER_ADDR_LEN];
+ uint8 ether_shost[ETHER_ADDR_LEN];
+ uint16 vlan_type; /* 0x8100 */
+ uint16 vlan_tag; /* priority, cfi and vid */
+ uint16 ether_type;
+};
+
+#define ETHERVLAN_HDR_LEN (ETHER_HDR_LEN + VLAN_TAG_LEN)
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#endif /* _vlan_h_ */
diff --git a/package/broadcom-wl/src/driver/proto/wpa.h b/package/broadcom-wl/src/driver/proto/wpa.h
new file mode 100644
index 0000000..c4b6dd1
--- /dev/null
+++ b/package/broadcom-wl/src/driver/proto/wpa.h
@@ -0,0 +1,158 @@
+/*
+ * Fundamental types and constants relating to WPA
+ *
+ * Copyright 2007, Broadcom Corporation
+ * All Rights Reserved.
+ *
+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
+ * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
+ *
+ * $Id$
+ */
+
+#ifndef _proto_wpa_h_
+#define _proto_wpa_h_
+
+#include <typedefs.h>
+#include <proto/ethernet.h>
+
+/* enable structure packing */
+#if defined(__GNUC__)
+#define PACKED __attribute__((packed))
+#else
+#pragma pack(1)
+#define PACKED
+#endif
+
+/* Reason Codes */
+
+/* 13 through 23 taken from IEEE Std 802.11i-2004 */
+#define DOT11_RC_INVALID_WPA_IE 13 /* Invalid info. element */
+#define DOT11_RC_MIC_FAILURE 14 /* Michael failure */
+#define DOT11_RC_4WH_TIMEOUT 15 /* 4-way handshake timeout */
+#define DOT11_RC_GTK_UPDATE_TIMEOUT 16 /* Group key update timeout */
+#define DOT11_RC_WPA_IE_MISMATCH 17 /* WPA IE in 4-way handshake differs from
+ * (re-)assoc. request/probe response
+ */
+#define DOT11_RC_INVALID_MC_CIPHER 18 /* Invalid multicast cipher */
+#define DOT11_RC_INVALID_UC_CIPHER 19 /* Invalid unicast cipher */
+#define DOT11_RC_INVALID_AKMP 20 /* Invalid authenticated key management protocol */
+#define DOT11_RC_BAD_WPA_VERSION 21 /* Unsupported WPA version */
+#define DOT11_RC_INVALID_WPA_CAP 22 /* Invalid WPA IE capabilities */
+#define DOT11_RC_8021X_AUTH_FAIL 23 /* 802.1X authentication failure */
+
+#define WPA2_PMKID_LEN 16
+
+/* WPA IE fixed portion */
+typedef struct
+{
+ uint8 tag; /* TAG */
+ uint8 length; /* TAG length */
+ uint8 oui[3]; /* IE OUI */
+ uint8 oui_type; /* OUI type */
+ struct {
+ uint8 low;
+ uint8 high;
+ } PACKED version; /* IE version */
+} PACKED wpa_ie_fixed_t;
+#define WPA_IE_OUITYPE_LEN 4
+#define WPA_IE_FIXED_LEN 8
+#define WPA_IE_TAG_FIXED_LEN 6
+
+#ifdef BCMWPA2
+typedef struct {
+ uint8 tag; /* TAG */
+ uint8 length; /* TAG length */
+ struct {
+ uint8 low;
+ uint8 high;
+ } PACKED version; /* IE version */
+} PACKED wpa_rsn_ie_fixed_t;
+#define WPA_RSN_IE_FIXED_LEN 4
+#define WPA_RSN_IE_TAG_FIXED_LEN 2
+typedef uint8 wpa_pmkid_t[WPA2_PMKID_LEN];
+#endif
+
+/* WPA suite/multicast suite */
+typedef struct
+{
+ uint8 oui[3];
+ uint8 type;
+} PACKED wpa_suite_t, wpa_suite_mcast_t;
+#define WPA_SUITE_LEN 4
+
+/* WPA unicast suite list/key management suite list */
+typedef struct
+{
+ struct {
+ uint8 low;
+ uint8 high;
+ } PACKED count;
+ wpa_suite_t list[1];
+} PACKED wpa_suite_ucast_t, wpa_suite_auth_key_mgmt_t;
+#define WPA_IE_SUITE_COUNT_LEN 2
+#ifdef BCMWPA2
+typedef struct
+{
+ struct {
+ uint8 low;
+ uint8 high;
+ } PACKED count;
+ wpa_pmkid_t list[1];
+} PACKED wpa_pmkid_list_t;
+#endif
+
+/* WPA cipher suites */
+#define WPA_CIPHER_NONE 0 /* None */
+#define WPA_CIPHER_WEP_40 1 /* WEP (40-bit) */
+#define WPA_CIPHER_TKIP 2 /* TKIP: default for WPA */
+#define WPA_CIPHER_AES_OCB 3 /* AES (OCB) */
+#define WPA_CIPHER_AES_CCM 4 /* AES (CCM) */
+#define WPA_CIPHER_WEP_104 5 /* WEP (104-bit) */
+
+#define IS_WPA_CIPHER(cipher) ((cipher) == WPA_CIPHER_NONE || \
+ (cipher) == WPA_CIPHER_WEP_40 || \
+ (cipher) == WPA_CIPHER_WEP_104 || \
+ (cipher) == WPA_CIPHER_TKIP || \
+ (cipher) == WPA_CIPHER_AES_OCB || \
+ (cipher) == WPA_CIPHER_AES_CCM)
+
+/* WPA TKIP countermeasures parameters */
+#define WPA_TKIP_CM_DETECT 60 /* multiple MIC failure window (seconds) */
+#define WPA_TKIP_CM_BLOCK 60 /* countermeasures active window (seconds) */
+
+/* RSN IE defines */
+#define RSN_CAP_LEN 2 /* Length of RSN capabilities field (2 octets) */
+
+/* RSN Capabilities defined in 802.11i */
+#define RSN_CAP_PREAUTH 0x0001
+#define RSN_CAP_NOPAIRWISE 0x0002
+#define RSN_CAP_PTK_REPLAY_CNTR_MASK 0x000C
+#define RSN_CAP_PTK_REPLAY_CNTR_SHIFT 2
+#define RSN_CAP_GTK_REPLAY_CNTR_MASK 0x0030
+#define RSN_CAP_GTK_REPLAY_CNTR_SHIFT 4
+#define RSN_CAP_1_REPLAY_CNTR 0
+#define RSN_CAP_2_REPLAY_CNTRS 1
+#define RSN_CAP_4_REPLAY_CNTRS 2
+#define RSN_CAP_16_REPLAY_CNTRS 3
+
+/* WPA capabilities defined in 802.11i */
+#define WPA_CAP_4_REPLAY_CNTRS RSN_CAP_4_REPLAY_CNTRS
+#define WPA_CAP_16_REPLAY_CNTRS RSN_CAP_16_REPLAY_CNTRS
+#define WPA_CAP_REPLAY_CNTR_SHIFT RSN_CAP_PTK_REPLAY_CNTR_SHIFT
+#define WPA_CAP_REPLAY_CNTR_MASK RSN_CAP_PTK_REPLAY_CNTR_MASK
+
+/* WPA Specific defines */
+#define WPA_CAP_LEN RSN_CAP_LEN /* Length of RSN capabilities in RSN IE (2 octets) */
+
+#define WPA_CAP_WPA2_PREAUTH RSN_CAP_PREAUTH
+
+
+#undef PACKED
+#if !defined(__GNUC__)
+#pragma pack()
+#endif
+
+#endif /* _proto_wpa_h_ */
diff --git a/package/broadcom-wl/src/driver/sbhnddma.h b/package/broadcom-wl/src/driver/sbhnddma.h
index a26db73..b83baeb 100644
--- a/package/broadcom-wl/src/driver/sbhnddma.h
+++ b/package/broadcom-wl/src/driver/sbhnddma.h
@@ -2,7 +2,7 @@
* Generic Broadcom Home Networking Division (HND) DMA engine HW interface
* This supports the following chips: BCM42xx, 44xx, 47xx .
*
- * Copyright 2006, Broadcom Corporation
+ * Copyright 2007, Broadcom Corporation
* All Rights Reserved.
*
* THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
@@ -10,7 +10,7 @@
* SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
*
- * $Id: sbhnddma.h,v 1.1.1.2 2006/02/27 03:43:16 honor Exp $
+ * $Id$
*/
#ifndef _sbhnddma_h_
diff --git a/package/broadcom-wl/src/wlc/wlc.c b/package/broadcom-wl/src/wlc/wlc.c
index f5db9a7..aa9a559 100644
--- a/package/broadcom-wl/src/wlc/wlc.c
+++ b/package/broadcom-wl/src/wlc/wlc.c
@@ -56,7 +56,6 @@
static char wlbuf[8192];
static char interface[16] = "wl0";
-static unsigned long ptable[128];
static unsigned long kmem_offset = 0;
static int vif = 0, debug = 1, fromstdin = 0;
@@ -98,205 +97,6 @@ static inline int my_ether_ntoa(unsigned char *ea, char *buf)
ea[0], ea[1], ea[2], ea[3], ea[4], ea[5]);
}
-/*
- * find the starting point of wl.o in memory
- * by reading /proc/ksyms
- */
-static inline void wlc_get_mem_offset(void)
-{
- FILE *f;
- char s[64];
-
- /* yes, i'm lazy ;) */
- f = popen("grep '\\[wl]' /proc/ksyms | sort", "r");
- if (fgets(s, 64, f) == 0)
- return;
-
- pclose(f);
-
- s[8] = 0;
- kmem_offset = strtoul(s, NULL, 16);
-
- /* sanity check */
- if (kmem_offset < 0xc0000000)
- kmem_offset = 0;
-}
-
-
-static int ptable_init(void)
-{
- glob_t globbuf;
- struct stat statbuf;
- int fd;
-
- if (ptable[0] == PTABLE_MAGIC)
- return 0;
-
- glob("/lib/modules/2.4.*/wl.o.patch", 0, NULL, &globbuf);
-
- if (globbuf.gl_pathv[0] == NULL)
- return -1;
-
- if ((fd = open(globbuf.gl_pathv[0], O_RDONLY)) < 0)
- return -1;
-
- if (fstat(fd, &statbuf) < 0)
- goto failed;
-
- if (statbuf.st_size < 512)
- goto failed;
-
- if (read(fd, ptable, 512) < 512)
- goto failed;
-
- if (ptable[0] != PTABLE_MAGIC)
- goto failed;
-
- close(fd);
-
- wlc_get_mem_offset();
- if (kmem_offset == 0)
- return -1;
-
- return 0;
-
-failed:
- close(fd);
-
- return -1;
-}
-
-static inline unsigned long wlc_kmem_read(unsigned long offset)
-{
- int fd;
- unsigned long ret;
-
- if ((fd = open("/dev/kmem", O_RDONLY )) < 0)
- return -1;
-
- lseek(fd, 0x70000000, SEEK_SET);
- lseek(fd, (kmem_offset - 0x70000000) + offset, SEEK_CUR);
- read(fd, &ret, 4);
- close(fd);
-
- return ret;
-}
-
-static inline void wlc_kmem_write(unsigned long offset, unsigned long value)
-{
- int fd;
-
- if ((fd = open("/dev/kmem", O_WRONLY )) < 0)
- return;
-
- lseek(fd, 0x70000000, SEEK_SET);
- lseek(fd, (kmem_offset - 0x70000000) + offset, SEEK_CUR);
- write(fd, &value, 4);
- close(fd);
-}
-
-static int wlc_patcher_getval(unsigned long key, unsigned long *val)
-{
- unsigned long *pt = &ptable[1];
- unsigned long tmp;
-
- if (ptable_init() < 0) {
- fprintf(stderr, "Could not load the ptable\n");
- return -1;
- }
-
- while (*pt != PTABLE_END) {
- if (*pt == key) {
- tmp = wlc_kmem_read(pt[1]);
-
- if (tmp == pt[2])
- *val = 0xffffffff;
- else
- *val = tmp;
-
- return 0;
- }
- pt += 3;
- }
-
- return -1;
-}
-
-static int wlc_patcher_setval(unsigned long key, unsigned long val)
-{
- unsigned long *pt = &ptable[1];
-
- if (ptable_init() < 0) {
- fprintf(stderr, "Could not load the ptable\n");
- return -1;
- }
-
- if (val != 0xffffffff)
- val = (pt[2] & ~(0xffff)) | (val & 0xffff);
-
- while (*pt != PTABLE_END) {
- if (*pt == key) {
- if (val == 0xffffffff) /* default */
- val = pt[2];
-
- wlc_kmem_write(pt[1], val);
- }
- pt += 3;
- }
-
- return 0;
-}
-
-static int wlc_slottime(wlc_param param, void *data, void *value)
-{
- int *val = (int *) value;
- int ret = 0;
-
- if ((param & PARAM_MODE) == SET) {
- wlc_patcher_setval(PTABLE_SLT1, *val);
- wlc_patcher_setval(PTABLE_SLT2, ((*val == -1) ? *val : *val + 510));
- } else if ((param & PARAM_MODE) == GET) {
- ret = wlc_patcher_getval(PTABLE_SLT1, (unsigned long *) val);
- if (*val != 0xffffffff)
- *val &= 0xffff;
- }
-
- return ret;
-}
-
-static int wlc_noack(wlc_param param, void *data, void *value)
-{
- int *val = (int *) value;
- int ret = 0;
-
- if ((param & PARAM_MODE) == SET) {
- wlc_patcher_setval(PTABLE_ACKW, ((*val) ? 1 : 0));
- } else if ((param & PARAM_MODE) == GET) {
- ret = wlc_patcher_getval(PTABLE_ACKW, (unsigned long *) val);
- *val &= 0xffff;
- *val = (*val ? 1 : 0);
- }
-
- return ret;
-}
-
-static int wlc_ibss_merge(wlc_param param, void *data, void *value)
-{
- int *val = (int *) value;
- int ret = 0;
-
- if ((param & PARAM_MODE) == SET) {
- /* overwrite the instruction with 'lui v0,0x0' - fake a return
- * status of 0 for wlc_bcn_tsf_later */
- wlc_patcher_setval(PTABLE_ACKW, ((*val) ? -1 : 0x3c020000));
- } else if ((param & PARAM_MODE) == GET) {
- ret = wlc_patcher_getval(PTABLE_ACKW, (unsigned long *) val);
- *val = ((*val == -1) ? 1 : 0);
- }
-
- return ret;
-}
-
static int wlc_ioctl(wlc_param param, void *data, void *value)
{
unsigned int *var = ((unsigned int *) data);
@@ -957,6 +757,13 @@ static const struct wlc_call wlc_calls[] = {
.desc = "RTS threshold"
},
{
+ .name = "slottime",
+ .param = INT,
+ .handler = wlc_iovar,
+ .data.str = "acktiming",
+ .desc = "Slot time"
+ },
+ {
.name = "rxant",
.param = INT,
.handler = wlc_ioctl,
@@ -1052,24 +859,6 @@ static const struct wlc_call wlc_calls[] = {
.handler = wlc_afterburner,
.desc = "Broadcom Afterburner"
},
- {
- .name = "slottime",
- .param = INT,
- .handler = wlc_slottime,
- .desc = "Slot time (-1 = auto)"
- },
- {
- .name = "txack",
- .param = INT,
- .handler = wlc_noack,
- .desc = "Tx ACK enabled flag"
- },
- {
- .name = "ibss_merge",
- .param = INT,
- .handler = wlc_ibss_merge,
- .desc = "Allow IBSS merge in Ad-Hoc mode"
- }
};
#define wlc_calls_size (sizeof(wlc_calls) / sizeof(struct wlc_call))
diff --git a/package/broadcom-wl/src/wlcompat/Makefile b/package/broadcom-wl/src/wlcompat/Makefile
index 6f3224d..31e5424 100644
--- a/package/broadcom-wl/src/wlcompat/Makefile
+++ b/package/broadcom-wl/src/wlcompat/Makefile
@@ -15,6 +15,9 @@ ifneq ($(DEBUG),)
EXTRA_CFLAGS += -DDEBUG=1
_D=-debug
endif
+ifneq ($(WL_WEXT),)
+ EXTRA_CFLAGS += -DWL_WEXT=1
+endif
obj-m := wlcompat$(_D).o
modules: wlcompat$(_D).o
diff --git a/package/broadcom-wl/src/wlcompat/wlcompat.c b/package/broadcom-wl/src/wlcompat/wlcompat.c
index 2694a85..5d2e74d 100644
--- a/package/broadcom-wl/src/wlcompat/wlcompat.c
+++ b/package/broadcom-wl/src/wlcompat/wlcompat.c
@@ -30,6 +30,7 @@
#include <linux/wireless.h>
#include <linux/timer.h>
#include <linux/delay.h>
+#include <linux/random.h>
#include <net/iw_handler.h>
#include <asm/uaccess.h>
@@ -37,14 +38,15 @@
#include <bcmutils.h>
#include <wlioctl.h>
+char buf[WLC_IOCTL_MAXLEN];
static struct net_device *dev;
-static struct iw_statistics wstats;
#ifndef DEBUG
static int random = 1;
#endif
+#ifndef WL_WEXT
+static struct iw_statistics wstats;
static int last_mode = -1;
static int scan_cur = 0;
-char buf[WLC_IOCTL_MAXLEN];
/* The frequency of each channel in MHz */
const long channel_frequency[] = {
@@ -52,6 +54,7 @@ const long channel_frequency[] = {
2447, 2452, 2457, 2462, 2467, 2472, 2484
};
#define NUM_CHANNELS ( sizeof(channel_frequency) / sizeof(channel_frequency[0]) )
+#endif
#define SCAN_RETRY_MAX 5
#define RNG_POLL_FREQ 1
@@ -88,6 +91,7 @@ static int wl_ioctl(struct net_device *dev, int cmd, void *buf, int len)
return ret;
}
+#if !defined(DEBUG) || !defined(WL_WEXT)
static int
wl_iovar_getbuf(struct net_device *dev, char *iovar, void *param, int paramlen, void *bufptr, int buflen)
{
@@ -268,6 +272,9 @@ wl_bssiovar_get(struct net_device *dev, char *iovar, int bssidx, void *outbuf, i
return err;
}
#endif
+#endif
+
+#ifndef WL_WEXT
int get_primary_key(struct net_device *dev)
{
@@ -903,6 +910,7 @@ static const struct iw_handler_def wlcompat_handler_def =
.num_standard = sizeof(wlcompat_handler)/sizeof(iw_handler),
};
+#endif
#ifdef DEBUG
void print_buffer(int len, unsigned char *buf) {
@@ -923,8 +931,6 @@ void print_buffer(int len, unsigned char *buf) {
static int (*old_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
static int new_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) {
int ret = 0;
- struct iwreq *iwr = (struct iwreq *) ifr;
- struct iw_request_info info;
#ifdef DEBUG
printk("dev: %s ioctl: 0x%04x\n",dev->name,cmd);
@@ -975,23 +981,25 @@ static int __init wlcompat_init()
{
int found = 0, i;
char devname[4] = "wl0";
-
+
while (!found && (dev = dev_get_by_name(devname))) {
- if ((dev->wireless_handlers == NULL) && ((wl_ioctl(dev, WLC_GET_MAGIC, &i, sizeof(i)) == 0) && i == WLC_IOCTL_MAGIC))
+ if ((wl_ioctl(dev, WLC_GET_MAGIC, &i, sizeof(i)) == 0) && (i == WLC_IOCTL_MAGIC))
found = 1;
devname[2]++;
}
-
+
+
if (!found) {
printk("No Broadcom devices found.\n");
return -ENODEV;
}
-
old_ioctl = dev->do_ioctl;
dev->do_ioctl = new_ioctl;
+#ifndef WL_WEXT
dev->wireless_handlers = (struct iw_handler_def *)&wlcompat_handler_def;
dev->get_wireless_stats = wlcompat_get_wireless_stats;
+#endif
#ifndef DEBUG
if (random) {
@@ -1014,8 +1022,10 @@ static void __exit wlcompat_exit()
if (random)
del_timer(&rng_timer);
#endif
+#ifndef WL_WEXT
dev->get_wireless_stats = NULL;
dev->wireless_handlers = NULL;
+#endif
dev->do_ioctl = old_ioctl;
return;
}