0001
0002
0003
0004
0005
0006 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0007
0008 #include <linux/netdevice.h>
0009 #include <linux/module.h>
0010
0011 #include <brcmu_utils.h>
0012
0013 MODULE_AUTHOR("Broadcom Corporation");
0014 MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver utilities.");
0015 MODULE_LICENSE("Dual BSD/GPL");
0016
0017 struct sk_buff *brcmu_pkt_buf_get_skb(uint len)
0018 {
0019 struct sk_buff *skb;
0020
0021 skb = dev_alloc_skb(len);
0022 if (skb) {
0023 skb_put(skb, len);
0024 skb->priority = 0;
0025 }
0026
0027 return skb;
0028 }
0029 EXPORT_SYMBOL(brcmu_pkt_buf_get_skb);
0030
0031
0032 void brcmu_pkt_buf_free_skb(struct sk_buff *skb)
0033 {
0034 if (!skb)
0035 return;
0036
0037 WARN_ON(skb->next);
0038 dev_kfree_skb_any(skb);
0039 }
0040 EXPORT_SYMBOL(brcmu_pkt_buf_free_skb);
0041
0042
0043
0044
0045
0046 struct sk_buff *brcmu_pktq_penq(struct pktq *pq, int prec,
0047 struct sk_buff *p)
0048 {
0049 struct sk_buff_head *q;
0050
0051 if (pktq_full(pq) || pktq_pfull(pq, prec))
0052 return NULL;
0053
0054 q = &pq->q[prec].skblist;
0055 skb_queue_tail(q, p);
0056 pq->len++;
0057
0058 if (pq->hi_prec < prec)
0059 pq->hi_prec = (u8) prec;
0060
0061 return p;
0062 }
0063 EXPORT_SYMBOL(brcmu_pktq_penq);
0064
0065 struct sk_buff *brcmu_pktq_penq_head(struct pktq *pq, int prec,
0066 struct sk_buff *p)
0067 {
0068 struct sk_buff_head *q;
0069
0070 if (pktq_full(pq) || pktq_pfull(pq, prec))
0071 return NULL;
0072
0073 q = &pq->q[prec].skblist;
0074 skb_queue_head(q, p);
0075 pq->len++;
0076
0077 if (pq->hi_prec < prec)
0078 pq->hi_prec = (u8) prec;
0079
0080 return p;
0081 }
0082 EXPORT_SYMBOL(brcmu_pktq_penq_head);
0083
0084 struct sk_buff *brcmu_pktq_pdeq(struct pktq *pq, int prec)
0085 {
0086 struct sk_buff_head *q;
0087 struct sk_buff *p;
0088
0089 q = &pq->q[prec].skblist;
0090 p = skb_dequeue(q);
0091 if (p == NULL)
0092 return NULL;
0093
0094 pq->len--;
0095 return p;
0096 }
0097 EXPORT_SYMBOL(brcmu_pktq_pdeq);
0098
0099
0100
0101
0102
0103
0104
0105 struct sk_buff *brcmu_pktq_pdeq_match(struct pktq *pq, int prec,
0106 bool (*match_fn)(struct sk_buff *skb,
0107 void *arg), void *arg)
0108 {
0109 struct sk_buff_head *q;
0110 struct sk_buff *p, *next;
0111
0112 q = &pq->q[prec].skblist;
0113 skb_queue_walk_safe(q, p, next) {
0114 if (match_fn == NULL || match_fn(p, arg)) {
0115 skb_unlink(p, q);
0116 pq->len--;
0117 return p;
0118 }
0119 }
0120 return NULL;
0121 }
0122 EXPORT_SYMBOL(brcmu_pktq_pdeq_match);
0123
0124 struct sk_buff *brcmu_pktq_pdeq_tail(struct pktq *pq, int prec)
0125 {
0126 struct sk_buff_head *q;
0127 struct sk_buff *p;
0128
0129 q = &pq->q[prec].skblist;
0130 p = skb_dequeue_tail(q);
0131 if (p == NULL)
0132 return NULL;
0133
0134 pq->len--;
0135 return p;
0136 }
0137 EXPORT_SYMBOL(brcmu_pktq_pdeq_tail);
0138
0139 void
0140 brcmu_pktq_pflush(struct pktq *pq, int prec, bool dir,
0141 bool (*fn)(struct sk_buff *, void *), void *arg)
0142 {
0143 struct sk_buff_head *q;
0144 struct sk_buff *p, *next;
0145
0146 q = &pq->q[prec].skblist;
0147 skb_queue_walk_safe(q, p, next) {
0148 if (fn == NULL || (*fn) (p, arg)) {
0149 skb_unlink(p, q);
0150 brcmu_pkt_buf_free_skb(p);
0151 pq->len--;
0152 }
0153 }
0154 }
0155 EXPORT_SYMBOL(brcmu_pktq_pflush);
0156
0157 void brcmu_pktq_flush(struct pktq *pq, bool dir,
0158 bool (*fn)(struct sk_buff *, void *), void *arg)
0159 {
0160 int prec;
0161 for (prec = 0; prec < pq->num_prec; prec++)
0162 brcmu_pktq_pflush(pq, prec, dir, fn, arg);
0163 }
0164 EXPORT_SYMBOL(brcmu_pktq_flush);
0165
0166 void brcmu_pktq_init(struct pktq *pq, int num_prec, int max_len)
0167 {
0168 int prec;
0169
0170
0171 memset(pq, 0,
0172 offsetof(struct pktq, q) + (sizeof(struct pktq_prec) * num_prec));
0173
0174 pq->num_prec = (u16) num_prec;
0175
0176 pq->max = (u16) max_len;
0177
0178 for (prec = 0; prec < num_prec; prec++) {
0179 pq->q[prec].max = pq->max;
0180 skb_queue_head_init(&pq->q[prec].skblist);
0181 }
0182 }
0183 EXPORT_SYMBOL(brcmu_pktq_init);
0184
0185 struct sk_buff *brcmu_pktq_peek_tail(struct pktq *pq, int *prec_out)
0186 {
0187 int prec;
0188
0189 if (pq->len == 0)
0190 return NULL;
0191
0192 for (prec = 0; prec < pq->hi_prec; prec++)
0193 if (!skb_queue_empty(&pq->q[prec].skblist))
0194 break;
0195
0196 if (prec_out)
0197 *prec_out = prec;
0198
0199 return skb_peek_tail(&pq->q[prec].skblist);
0200 }
0201 EXPORT_SYMBOL(brcmu_pktq_peek_tail);
0202
0203
0204 int brcmu_pktq_mlen(struct pktq *pq, uint prec_bmp)
0205 {
0206 int prec, len;
0207
0208 len = 0;
0209
0210 for (prec = 0; prec <= pq->hi_prec; prec++)
0211 if (prec_bmp & (1 << prec))
0212 len += pq->q[prec].skblist.qlen;
0213
0214 return len;
0215 }
0216 EXPORT_SYMBOL(brcmu_pktq_mlen);
0217
0218
0219 struct sk_buff *brcmu_pktq_mdeq(struct pktq *pq, uint prec_bmp,
0220 int *prec_out)
0221 {
0222 struct sk_buff_head *q;
0223 struct sk_buff *p;
0224 int prec;
0225
0226 if (pq->len == 0)
0227 return NULL;
0228
0229 while ((prec = pq->hi_prec) > 0 &&
0230 skb_queue_empty(&pq->q[prec].skblist))
0231 pq->hi_prec--;
0232
0233 while ((prec_bmp & (1 << prec)) == 0 ||
0234 skb_queue_empty(&pq->q[prec].skblist))
0235 if (prec-- == 0)
0236 return NULL;
0237
0238 q = &pq->q[prec].skblist;
0239 p = skb_dequeue(q);
0240 if (p == NULL)
0241 return NULL;
0242
0243 pq->len--;
0244
0245 if (prec_out)
0246 *prec_out = prec;
0247
0248 return p;
0249 }
0250 EXPORT_SYMBOL(brcmu_pktq_mdeq);
0251
0252
0253 char *brcmu_boardrev_str(u32 brev, char *buf)
0254 {
0255 char c;
0256
0257 if (brev < 0x100) {
0258 snprintf(buf, BRCMU_BOARDREV_LEN, "%d.%d",
0259 (brev & 0xf0) >> 4, brev & 0xf);
0260 } else {
0261 c = (brev & 0xf000) == 0x1000 ? 'P' : 'A';
0262 snprintf(buf, BRCMU_BOARDREV_LEN, "%c%03x", c, brev & 0xfff);
0263 }
0264 return buf;
0265 }
0266 EXPORT_SYMBOL(brcmu_boardrev_str);
0267
0268 char *brcmu_dotrev_str(u32 dotrev, char *buf)
0269 {
0270 u8 dotval[4];
0271
0272 if (!dotrev) {
0273 snprintf(buf, BRCMU_DOTREV_LEN, "unknown");
0274 return buf;
0275 }
0276 dotval[0] = (dotrev >> 24) & 0xFF;
0277 dotval[1] = (dotrev >> 16) & 0xFF;
0278 dotval[2] = (dotrev >> 8) & 0xFF;
0279 dotval[3] = dotrev & 0xFF;
0280
0281 if (dotval[3])
0282 snprintf(buf, BRCMU_DOTREV_LEN, "%d.%d.%d.%d", dotval[0],
0283 dotval[1], dotval[2], dotval[3]);
0284 else if (dotval[2])
0285 snprintf(buf, BRCMU_DOTREV_LEN, "%d.%d.%d", dotval[0],
0286 dotval[1], dotval[2]);
0287 else
0288 snprintf(buf, BRCMU_DOTREV_LEN, "%d.%d", dotval[0],
0289 dotval[1]);
0290
0291 return buf;
0292 }
0293 EXPORT_SYMBOL(brcmu_dotrev_str);
0294
0295 #if defined(DEBUG)
0296
0297 void brcmu_prpkt(const char *msg, struct sk_buff *p0)
0298 {
0299 struct sk_buff *p;
0300
0301 if (msg && (msg[0] != '\0'))
0302 pr_debug("%s:\n", msg);
0303
0304 for (p = p0; p; p = p->next)
0305 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, p->data, p->len);
0306 }
0307 EXPORT_SYMBOL(brcmu_prpkt);
0308
0309 void brcmu_dbg_hex_dump(const void *data, size_t size, const char *fmt, ...)
0310 {
0311 struct va_format vaf;
0312 va_list args;
0313
0314 va_start(args, fmt);
0315
0316 vaf.fmt = fmt;
0317 vaf.va = &args;
0318
0319 pr_debug("%pV", &vaf);
0320
0321 va_end(args);
0322
0323 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, data, size);
0324 }
0325 EXPORT_SYMBOL(brcmu_dbg_hex_dump);
0326
0327 #endif