279 lines
5.9 KiB
C
279 lines
5.9 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.
|
|
*/
|
|
|
|
#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_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)
|
|
{
|
|
if (!skb)
|
|
return;
|
|
WARN_ON(skb->next);
|
|
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);
|
|
}
|
|
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);
|
|
|
|
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);
|
|
|
|
#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) */
|