forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
327 lines
6.6 KiB
327 lines
6.6 KiB
// SPDX-License-Identifier: ISC |
|
/* |
|
* Copyright (c) 2010 Broadcom Corporation |
|
*/ |
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
|
|
|
#include <linux/netdevice.h> |
|
#include <linux/module.h> |
|
|
|
#include <brcmu_utils.h> |
|
|
|
MODULE_AUTHOR("Broadcom Corporation"); |
|
MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver utilities."); |
|
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) |
|
{ |
|
if (!skb) |
|
return; |
|
|
|
WARN_ON(skb->next); |
|
dev_kfree_skb_any(skb); |
|
} |
|
EXPORT_SYMBOL(brcmu_pkt_buf_free_skb); |
|
|
|
/* |
|
* 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 sk_buff_head *q; |
|
|
|
if (pktq_full(pq) || pktq_pfull(pq, prec)) |
|
return NULL; |
|
|
|
q = &pq->q[prec].skblist; |
|
skb_queue_tail(q, p); |
|
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 sk_buff_head *q; |
|
|
|
if (pktq_full(pq) || pktq_pfull(pq, prec)) |
|
return NULL; |
|
|
|
q = &pq->q[prec].skblist; |
|
skb_queue_head(q, p); |
|
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 sk_buff_head *q; |
|
struct sk_buff *p; |
|
|
|
q = &pq->q[prec].skblist; |
|
p = skb_dequeue(q); |
|
if (p == NULL) |
|
return NULL; |
|
|
|
pq->len--; |
|
return p; |
|
} |
|
EXPORT_SYMBOL(brcmu_pktq_pdeq); |
|
|
|
/* |
|
* precedence based dequeue with match function. Passing a NULL pointer |
|
* for the match function parameter is considered to be a wildcard so |
|
* any packet on the queue is returned. In that case it is no different |
|
* from brcmu_pktq_pdeq() above. |
|
*/ |
|
struct sk_buff *brcmu_pktq_pdeq_match(struct pktq *pq, int prec, |
|
bool (*match_fn)(struct sk_buff *skb, |
|
void *arg), void *arg) |
|
{ |
|
struct sk_buff_head *q; |
|
struct sk_buff *p, *next; |
|
|
|
q = &pq->q[prec].skblist; |
|
skb_queue_walk_safe(q, p, next) { |
|
if (match_fn == NULL || match_fn(p, arg)) { |
|
skb_unlink(p, q); |
|
pq->len--; |
|
return p; |
|
} |
|
} |
|
return NULL; |
|
} |
|
EXPORT_SYMBOL(brcmu_pktq_pdeq_match); |
|
|
|
struct sk_buff *brcmu_pktq_pdeq_tail(struct pktq *pq, int prec) |
|
{ |
|
struct sk_buff_head *q; |
|
struct sk_buff *p; |
|
|
|
q = &pq->q[prec].skblist; |
|
p = skb_dequeue_tail(q); |
|
if (p == NULL) |
|
return NULL; |
|
|
|
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 sk_buff_head *q; |
|
struct sk_buff *p, *next; |
|
|
|
q = &pq->q[prec].skblist; |
|
skb_queue_walk_safe(q, p, next) { |
|
if (fn == NULL || (*fn) (p, arg)) { |
|
skb_unlink(p, q); |
|
brcmu_pkt_buf_free_skb(p); |
|
pq->len--; |
|
} |
|
} |
|
} |
|
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; |
|
skb_queue_head_init(&pq->q[prec].skblist); |
|
} |
|
} |
|
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 (!skb_queue_empty(&pq->q[prec].skblist)) |
|
break; |
|
|
|
if (prec_out) |
|
*prec_out = prec; |
|
|
|
return skb_peek_tail(&pq->q[prec].skblist); |
|
} |
|
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].skblist.qlen; |
|
|
|
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 sk_buff_head *q; |
|
struct sk_buff *p; |
|
int prec; |
|
|
|
if (pq->len == 0) |
|
return NULL; |
|
|
|
while ((prec = pq->hi_prec) > 0 && |
|
skb_queue_empty(&pq->q[prec].skblist)) |
|
pq->hi_prec--; |
|
|
|
while ((prec_bmp & (1 << prec)) == 0 || |
|
skb_queue_empty(&pq->q[prec].skblist)) |
|
if (prec-- == 0) |
|
return NULL; |
|
|
|
q = &pq->q[prec].skblist; |
|
p = skb_dequeue(q); |
|
if (p == NULL) |
|
return NULL; |
|
|
|
pq->len--; |
|
|
|
if (prec_out) |
|
*prec_out = prec; |
|
|
|
return p; |
|
} |
|
EXPORT_SYMBOL(brcmu_pktq_mdeq); |
|
|
|
/* Produce a human-readable string for boardrev */ |
|
char *brcmu_boardrev_str(u32 brev, char *buf) |
|
{ |
|
char c; |
|
|
|
if (brev < 0x100) { |
|
snprintf(buf, BRCMU_BOARDREV_LEN, "%d.%d", |
|
(brev & 0xf0) >> 4, brev & 0xf); |
|
} else { |
|
c = (brev & 0xf000) == 0x1000 ? 'P' : 'A'; |
|
snprintf(buf, BRCMU_BOARDREV_LEN, "%c%03x", c, brev & 0xfff); |
|
} |
|
return buf; |
|
} |
|
EXPORT_SYMBOL(brcmu_boardrev_str); |
|
|
|
char *brcmu_dotrev_str(u32 dotrev, char *buf) |
|
{ |
|
u8 dotval[4]; |
|
|
|
if (!dotrev) { |
|
snprintf(buf, BRCMU_DOTREV_LEN, "unknown"); |
|
return buf; |
|
} |
|
dotval[0] = (dotrev >> 24) & 0xFF; |
|
dotval[1] = (dotrev >> 16) & 0xFF; |
|
dotval[2] = (dotrev >> 8) & 0xFF; |
|
dotval[3] = dotrev & 0xFF; |
|
|
|
if (dotval[3]) |
|
snprintf(buf, BRCMU_DOTREV_LEN, "%d.%d.%d.%d", dotval[0], |
|
dotval[1], dotval[2], dotval[3]); |
|
else if (dotval[2]) |
|
snprintf(buf, BRCMU_DOTREV_LEN, "%d.%d.%d", dotval[0], |
|
dotval[1], dotval[2]); |
|
else |
|
snprintf(buf, BRCMU_DOTREV_LEN, "%d.%d", dotval[0], |
|
dotval[1]); |
|
|
|
return buf; |
|
} |
|
EXPORT_SYMBOL(brcmu_dotrev_str); |
|
|
|
#if defined(DEBUG) |
|
/* 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')) |
|
pr_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); |
|
|
|
void brcmu_dbg_hex_dump(const void *data, size_t size, const char *fmt, ...) |
|
{ |
|
struct va_format vaf; |
|
va_list args; |
|
|
|
va_start(args, fmt); |
|
|
|
vaf.fmt = fmt; |
|
vaf.va = &args; |
|
|
|
pr_debug("%pV", &vaf); |
|
|
|
va_end(args); |
|
|
|
print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, data, size); |
|
} |
|
EXPORT_SYMBOL(brcmu_dbg_hex_dump); |
|
|
|
#endif /* defined(DEBUG) */
|
|
|