mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-10 20:44:09 +08:00
5b435de0d7
Add the brcm80211 tree to drivers/net/wireless, and disable the version that's in drivers/staging. This version includes the sources currently in staging, plus any changes that have been sent out for review. Sources in staging will be deleted in a followup patch. Signed-off-by: Arend van Spriel <arend@broadcom.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
601 lines
12 KiB
C
601 lines
12 KiB
C
/*
|
|
* Copyright (c) 2010 Broadcom Corporation
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
|
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
|
|
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <linux/netdevice.h>
|
|
#include <brcmu_utils.h>
|
|
|
|
MODULE_AUTHOR("Broadcom Corporation");
|
|
MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver utilities.");
|
|
MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN cards");
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
|
|
struct sk_buff *brcmu_pkt_buf_get_skb(uint len)
|
|
{
|
|
struct sk_buff *skb;
|
|
|
|
skb = dev_alloc_skb(len);
|
|
if (skb) {
|
|
skb_put(skb, len);
|
|
skb->priority = 0;
|
|
}
|
|
|
|
return skb;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pkt_buf_get_skb);
|
|
|
|
/* Free the driver packet. Free the tag if present */
|
|
void brcmu_pkt_buf_free_skb(struct sk_buff *skb)
|
|
{
|
|
struct sk_buff *nskb;
|
|
int nest = 0;
|
|
|
|
/* perversion: we use skb->next to chain multi-skb packets */
|
|
while (skb) {
|
|
nskb = skb->next;
|
|
skb->next = NULL;
|
|
|
|
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);
|
|
|
|
nest++;
|
|
skb = nskb;
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pkt_buf_free_skb);
|
|
|
|
|
|
/* copy a buffer into a pkt buffer chain */
|
|
uint brcmu_pktfrombuf(struct sk_buff *p, uint offset, int len,
|
|
unsigned char *buf)
|
|
{
|
|
uint n, ret = 0;
|
|
|
|
/* skip 'offset' bytes */
|
|
for (; p && offset; p = p->next) {
|
|
if (offset < (uint) (p->len))
|
|
break;
|
|
offset -= p->len;
|
|
}
|
|
|
|
if (!p)
|
|
return 0;
|
|
|
|
/* copy the data */
|
|
for (; p && len; p = p->next) {
|
|
n = min((uint) (p->len) - offset, (uint) len);
|
|
memcpy(p->data + offset, buf, n);
|
|
buf += n;
|
|
len -= n;
|
|
ret += n;
|
|
offset = 0;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktfrombuf);
|
|
|
|
/* return total length of buffer chain */
|
|
uint brcmu_pkttotlen(struct sk_buff *p)
|
|
{
|
|
uint total;
|
|
|
|
total = 0;
|
|
for (; p; p = p->next)
|
|
total += p->len;
|
|
return total;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pkttotlen);
|
|
|
|
/*
|
|
* osl multiple-precedence packet queue
|
|
* hi_prec is always >= the number of the highest non-empty precedence
|
|
*/
|
|
struct sk_buff *brcmu_pktq_penq(struct pktq *pq, int prec,
|
|
struct sk_buff *p)
|
|
{
|
|
struct pktq_prec *q;
|
|
|
|
if (pktq_full(pq) || pktq_pfull(pq, prec))
|
|
return NULL;
|
|
|
|
q = &pq->q[prec];
|
|
|
|
if (q->head)
|
|
q->tail->prev = p;
|
|
else
|
|
q->head = p;
|
|
|
|
q->tail = p;
|
|
q->len++;
|
|
|
|
pq->len++;
|
|
|
|
if (pq->hi_prec < prec)
|
|
pq->hi_prec = (u8) prec;
|
|
|
|
return p;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktq_penq);
|
|
|
|
struct sk_buff *brcmu_pktq_penq_head(struct pktq *pq, int prec,
|
|
struct sk_buff *p)
|
|
{
|
|
struct pktq_prec *q;
|
|
|
|
if (pktq_full(pq) || pktq_pfull(pq, prec))
|
|
return NULL;
|
|
|
|
q = &pq->q[prec];
|
|
|
|
if (q->head == NULL)
|
|
q->tail = p;
|
|
|
|
p->prev = q->head;
|
|
q->head = p;
|
|
q->len++;
|
|
|
|
pq->len++;
|
|
|
|
if (pq->hi_prec < prec)
|
|
pq->hi_prec = (u8) prec;
|
|
|
|
return p;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktq_penq_head);
|
|
|
|
struct sk_buff *brcmu_pktq_pdeq(struct pktq *pq, int prec)
|
|
{
|
|
struct pktq_prec *q;
|
|
struct sk_buff *p;
|
|
|
|
q = &pq->q[prec];
|
|
|
|
p = q->head;
|
|
if (p == NULL)
|
|
return NULL;
|
|
|
|
q->head = p->prev;
|
|
if (q->head == NULL)
|
|
q->tail = NULL;
|
|
|
|
q->len--;
|
|
|
|
pq->len--;
|
|
|
|
p->prev = NULL;
|
|
|
|
return p;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktq_pdeq);
|
|
|
|
struct sk_buff *brcmu_pktq_pdeq_tail(struct pktq *pq, int prec)
|
|
{
|
|
struct pktq_prec *q;
|
|
struct sk_buff *p, *prev;
|
|
|
|
q = &pq->q[prec];
|
|
|
|
p = q->head;
|
|
if (p == NULL)
|
|
return NULL;
|
|
|
|
for (prev = NULL; p != q->tail; p = p->prev)
|
|
prev = p;
|
|
|
|
if (prev)
|
|
prev->prev = NULL;
|
|
else
|
|
q->head = NULL;
|
|
|
|
q->tail = prev;
|
|
q->len--;
|
|
|
|
pq->len--;
|
|
|
|
return p;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktq_pdeq_tail);
|
|
|
|
void
|
|
brcmu_pktq_pflush(struct pktq *pq, int prec, bool dir,
|
|
bool (*fn)(struct sk_buff *, void *), void *arg)
|
|
{
|
|
struct pktq_prec *q;
|
|
struct sk_buff *p, *prev = NULL;
|
|
|
|
q = &pq->q[prec];
|
|
p = q->head;
|
|
while (p) {
|
|
if (fn == NULL || (*fn) (p, arg)) {
|
|
bool head = (p == q->head);
|
|
if (head)
|
|
q->head = p->prev;
|
|
else
|
|
prev->prev = p->prev;
|
|
p->prev = NULL;
|
|
brcmu_pkt_buf_free_skb(p);
|
|
q->len--;
|
|
pq->len--;
|
|
p = (head ? q->head : prev->prev);
|
|
} else {
|
|
prev = p;
|
|
p = p->prev;
|
|
}
|
|
}
|
|
|
|
if (q->head == NULL)
|
|
q->tail = NULL;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktq_pflush);
|
|
|
|
void brcmu_pktq_flush(struct pktq *pq, bool dir,
|
|
bool (*fn)(struct sk_buff *, void *), void *arg)
|
|
{
|
|
int prec;
|
|
for (prec = 0; prec < pq->num_prec; prec++)
|
|
brcmu_pktq_pflush(pq, prec, dir, fn, arg);
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktq_flush);
|
|
|
|
void brcmu_pktq_init(struct pktq *pq, int num_prec, int max_len)
|
|
{
|
|
int prec;
|
|
|
|
/* pq is variable size; only zero out what's requested */
|
|
memset(pq, 0,
|
|
offsetof(struct pktq, q) + (sizeof(struct pktq_prec) * num_prec));
|
|
|
|
pq->num_prec = (u16) num_prec;
|
|
|
|
pq->max = (u16) max_len;
|
|
|
|
for (prec = 0; prec < num_prec; prec++)
|
|
pq->q[prec].max = pq->max;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktq_init);
|
|
|
|
struct sk_buff *brcmu_pktq_peek_tail(struct pktq *pq, int *prec_out)
|
|
{
|
|
int prec;
|
|
|
|
if (pq->len == 0)
|
|
return NULL;
|
|
|
|
for (prec = 0; prec < pq->hi_prec; prec++)
|
|
if (pq->q[prec].head)
|
|
break;
|
|
|
|
if (prec_out)
|
|
*prec_out = prec;
|
|
|
|
return pq->q[prec].tail;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktq_peek_tail);
|
|
|
|
/* Return sum of lengths of a specific set of precedences */
|
|
int brcmu_pktq_mlen(struct pktq *pq, uint prec_bmp)
|
|
{
|
|
int prec, len;
|
|
|
|
len = 0;
|
|
|
|
for (prec = 0; prec <= pq->hi_prec; prec++)
|
|
if (prec_bmp & (1 << prec))
|
|
len += pq->q[prec].len;
|
|
|
|
return len;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktq_mlen);
|
|
|
|
/* Priority dequeue from a specific set of precedences */
|
|
struct sk_buff *brcmu_pktq_mdeq(struct pktq *pq, uint prec_bmp,
|
|
int *prec_out)
|
|
{
|
|
struct pktq_prec *q;
|
|
struct sk_buff *p;
|
|
int prec;
|
|
|
|
if (pq->len == 0)
|
|
return NULL;
|
|
|
|
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;
|
|
|
|
q = &pq->q[prec];
|
|
|
|
p = q->head;
|
|
if (p == NULL)
|
|
return NULL;
|
|
|
|
q->head = p->prev;
|
|
if (q->head == NULL)
|
|
q->tail = NULL;
|
|
|
|
q->len--;
|
|
|
|
if (prec_out)
|
|
*prec_out = prec;
|
|
|
|
pq->len--;
|
|
|
|
p->prev = NULL;
|
|
|
|
return p;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_pktq_mdeq);
|
|
|
|
#if defined(BCMDBG)
|
|
/* pretty hex print a pkt buffer chain */
|
|
void brcmu_prpkt(const char *msg, struct sk_buff *p0)
|
|
{
|
|
struct sk_buff *p;
|
|
|
|
if (msg && (msg[0] != '\0'))
|
|
printk(KERN_DEBUG "%s:\n", msg);
|
|
|
|
for (p = p0; p; p = p->next)
|
|
print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, p->data, p->len);
|
|
}
|
|
EXPORT_SYMBOL(brcmu_prpkt);
|
|
#endif /* defined(BCMDBG) */
|
|
|
|
/*
|
|
* 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
|
|
*/
|
|
struct brcmu_tlv *brcmu_parse_tlvs(void *buf, int buflen, uint key)
|
|
{
|
|
struct brcmu_tlv *elt;
|
|
int totlen;
|
|
|
|
elt = (struct brcmu_tlv *) buf;
|
|
totlen = buflen;
|
|
|
|
/* find tagged parameter */
|
|
while (totlen >= 2) {
|
|
int len = elt->len;
|
|
|
|
/* validate remaining totlen */
|
|
if ((elt->id == key) && (totlen >= (len + 2)))
|
|
return elt;
|
|
|
|
elt = (struct brcmu_tlv *) ((u8 *) elt + (len + 2));
|
|
totlen -= (len + 2);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_parse_tlvs);
|
|
|
|
|
|
#if defined(BCMDBG)
|
|
int
|
|
brcmu_format_flags(const struct brcmu_bit_desc *bd, u32 flags, char *buf,
|
|
int len)
|
|
{
|
|
int i;
|
|
char *p = buf;
|
|
char hexstr[16];
|
|
int slen = 0, nlen = 0;
|
|
u32 bit;
|
|
const char *name;
|
|
|
|
if (len < 2 || !buf)
|
|
return 0;
|
|
|
|
buf[0] = '\0';
|
|
|
|
for (i = 0; flags != 0; i++) {
|
|
bit = bd[i].bit;
|
|
name = bd[i].name;
|
|
if (bit == 0 && flags != 0) {
|
|
/* print any unnamed bits */
|
|
snprintf(hexstr, 16, "0x%X", flags);
|
|
name = hexstr;
|
|
flags = 0; /* exit loop */
|
|
} else if ((flags & bit) == 0)
|
|
continue;
|
|
flags &= ~bit;
|
|
nlen = strlen(name);
|
|
slen += nlen;
|
|
/* count btwn flag space */
|
|
if (flags != 0)
|
|
slen += 1;
|
|
/* need NULL char as well */
|
|
if (len <= slen)
|
|
break;
|
|
/* copy NULL char but don't count it */
|
|
strncpy(p, name, nlen + 1);
|
|
p += nlen;
|
|
/* copy btwn flag space and NULL char */
|
|
if (flags != 0)
|
|
p += snprintf(p, 2, " ");
|
|
len -= slen;
|
|
}
|
|
|
|
/* indicate the str was too short */
|
|
if (flags != 0) {
|
|
if (len < 2)
|
|
p -= 2 - len; /* overwrite last char */
|
|
p += snprintf(p, 2, ">");
|
|
}
|
|
|
|
return (int)(p - buf);
|
|
}
|
|
EXPORT_SYMBOL(brcmu_format_flags);
|
|
|
|
/*
|
|
* print bytes formatted as hex to a string. return the resulting
|
|
* string length
|
|
*/
|
|
int brcmu_format_hex(char *str, const void *bytes, int len)
|
|
{
|
|
int i;
|
|
char *p = str;
|
|
const u8 *src = (const u8 *)bytes;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
p += snprintf(p, 3, "%02X", *src);
|
|
src++;
|
|
}
|
|
return (int)(p - str);
|
|
}
|
|
EXPORT_SYMBOL(brcmu_format_hex);
|
|
#endif /* defined(BCMDBG) */
|
|
|
|
char *brcmu_chipname(uint chipid, char *buf, uint len)
|
|
{
|
|
const char *fmt;
|
|
|
|
fmt = ((chipid > 0xa000) || (chipid < 0x4000)) ? "%d" : "%x";
|
|
snprintf(buf, len, fmt, chipid);
|
|
return buf;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_chipname);
|
|
|
|
uint brcmu_mkiovar(char *name, char *data, uint datalen, char *buf, uint buflen)
|
|
{
|
|
uint len;
|
|
|
|
len = strlen(name) + 1;
|
|
|
|
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;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_mkiovar);
|
|
|
|
/* 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 u16.
|
|
*/
|
|
|
|
#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 u16 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
|
|
};
|
|
|
|
u16 brcmu_qdbm_to_mw(u8 qdbm)
|
|
{
|
|
uint factor = 1;
|
|
int idx = qdbm - QDBM_OFFSET;
|
|
|
|
if (idx >= QDBM_TABLE_LEN)
|
|
/* clamp to max u16 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;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_qdbm_to_mw);
|
|
|
|
u8 brcmu_mw_to_qdbm(u16 mw)
|
|
{
|
|
u8 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 += (u8) offset;
|
|
|
|
return qdbm;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_mw_to_qdbm);
|
|
|
|
uint brcmu_bitcount(u8 *bitmap, uint length)
|
|
{
|
|
uint bitcount = 0, i;
|
|
u8 tmp;
|
|
for (i = 0; i < length; i++) {
|
|
tmp = bitmap[i];
|
|
while (tmp) {
|
|
bitcount++;
|
|
tmp &= (tmp - 1);
|
|
}
|
|
}
|
|
return bitcount;
|
|
}
|
|
EXPORT_SYMBOL(brcmu_bitcount);
|