Back to home page

OSCL-LXR

 
 

    


0001 // SPDX-License-Identifier: ISC
0002 /*
0003  * Copyright (c) 2010 Broadcom Corporation
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 /* Free the driver packet. Free the tag if present */
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  * osl multiple-precedence packet queue
0044  * hi_prec is always >= the number of the highest non-empty precedence
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  * precedence based dequeue with match function. Passing a NULL pointer
0101  * for the match function parameter is considered to be a wildcard so
0102  * any packet on the queue is returned. In that case it is no different
0103  * from brcmu_pktq_pdeq() above.
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     /* pq is variable size; only zero out what's requested */
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 /* Return sum of lengths of a specific set of precedences */
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 /* Priority dequeue from a specific set of precedences */
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 /* Produce a human-readable string for boardrev */
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 /* pretty hex print a pkt buffer chain */
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              /* defined(DEBUG) */