?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updates to Tomato RAF including NGINX && PHP
[tomato.git] / release / src / shared / bcmutils.c
blobe78ce72ceeae1d6dd68a2d40599c847b8d297ea9
1 /*
2 * Driver O/S-independent utility routines
3 *
4 * Copyright 2007, Broadcom Corporation
5 * All Rights Reserved.
6 *
7 * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8 * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
9 * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
10 * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
11 * $Id$
12 */
13
14 #include <typedefs.h>
15 #include <bcmdefs.h>
16 #include <stdarg.h>
17 #include <bcmutils.h>
18 #ifdef BCMDRIVER
19 #include <osl.h>
20 #include <sbutils.h>
21 #include <bcmnvram.h>
22 #else
23 #include <stdio.h>
24 #include <string.h>
25 #endif /* BCMDRIVER */
26 #if defined(_WIN32) || defined(NDIS) || defined(__vxworks) || \
27 defined(_CFE_) || defined(EFI)
28 /* debatable */
29 #include <bcmstdlib.h>
30 #endif
31 #include <bcmendian.h>
32 #include <bcmdevs.h>
33 #include <proto/ethernet.h>
34 #include <proto/vlan.h>
35 #include <proto/bcmip.h>
36 #include <proto/bcmtcp.h>
37 #include <proto/802.1d.h>
38
39 #ifdef BCMPERFSTATS
40 #include <bcmperf.h>
41 #endif
42
43 #ifdef BCMDRIVER
44 /* nvram vars cache */
45 static char *nvram_vars = NULL;
46 static int vars_len = -1;
47
48 /* copy a pkt buffer chain into a buffer */
49 uint
50 pktcopy(osl_t *osh, void *p, uint offset, int len, uchar *buf)
51 {
52 uint n, ret = 0;
53
54 if (len < 0)
55 len = 4096; /* "infinite" */
56
57 /* skip 'offset' bytes */
58 for (; p && offset; p = PKTNEXT(osh, p)) {
59 if (offset < (uint)PKTLEN(osh, p))
60 break;
61 offset -= PKTLEN(osh, p);
62 }
63
64 if (!p)
65 return 0;
66
67 /* copy the data */
68 for (; p && len; p = PKTNEXT(osh, p)) {
69 n = MIN((uint)PKTLEN(osh, p) - offset, (uint)len);
70 bcopy(PKTDATA(osh, p) + offset, buf, n);
71 buf += n;
72 len -= n;
73 ret += n;
74 offset = 0;
75 }
76
77 return ret;
78 }
79
80 /* return total length of buffer chain */
81 uint
82 pkttotlen(osl_t *osh, void *p)
83 {
84 uint total;
85
86 total = 0;
87 for (; p; p = PKTNEXT(osh, p))
88 total += PKTLEN(osh, p);
89 return (total);
90 }
91
92 /* return the last buffer of chained pkt */
93 void *
94 pktlast(osl_t *osh, void *p)
95 {
96 for (; PKTNEXT(osh, p); p = PKTNEXT(osh, p))
97 ;
98
99 return (p);
100 }
101
102
103 /*
104 * osl multiple-precedence packet queue
105 * hi_prec is always >= the number of the highest non-empty precedence
106 */
107 void *
108 pktq_penq(struct pktq *pq, int prec, void *p)
109 {
110 struct pktq_prec *q;
111
112 ASSERT(prec >= 0 && prec < pq->num_prec);
113 ASSERT(PKTLINK(p) == NULL); /* queueing chains not allowed */
114
115 ASSERT(!pktq_full(pq));
116 ASSERT(!pktq_pfull(pq, prec));
117
118 q = &pq->q[prec];
119
120 if (q->head)
121 PKTSETLINK(q->tail, p);
122 else
123 q->head = p;
124
125 q->tail = p;
126 q->len++;
127
128 pq->len++;
129
130 if (pq->hi_prec < prec)
131 pq->hi_prec = (uint8)prec;
132
133 return p;
134 }
135
136 void *
137 pktq_penq_head(struct pktq *pq, int prec, void *p)
138 {
139 struct pktq_prec *q;
140
141 ASSERT(prec >= 0 && prec < pq->num_prec);
142 ASSERT(PKTLINK(p) == NULL); /* queueing chains not allowed */
143
144 ASSERT(!pktq_full(pq));
145 ASSERT(!pktq_pfull(pq, prec));
146
147 q = &pq->q[prec];
148
149 if (q->head == NULL)
150 q->tail = p;
151
152 PKTSETLINK(p, q->head);
153 q->head = p;
154 q->len++;
155
156 pq->len++;
157
158 if (pq->hi_prec < prec)
159 pq->hi_prec = (uint8)prec;
160
161 return p;
162 }
163
164 void *
165 pktq_pdeq(struct pktq *pq, int prec)
166 {
167 struct pktq_prec *q;
168 void *p;
169
170 ASSERT(prec >= 0 && prec < pq->num_prec);
171
172 q = &pq->q[prec];
173
174 if ((p = q->head) == NULL)
175 return NULL;
176
177 if ((q->head = PKTLINK(p)) == NULL)
178 q->tail = NULL;
179
180 q->len--;
181
182 pq->len--;
183
184 PKTSETLINK(p, NULL);
185
186 return p;
187 }
188
189 void *
190 pktq_pdeq_tail(struct pktq *pq, int prec)
191 {
192 struct pktq_prec *q;
193 void *p, *prev;
194
195 ASSERT(prec >= 0 && prec < pq->num_prec);
196
197 q = &pq->q[prec];
198
199 if ((p = q->head) == NULL)
200 return NULL;
201
202 for (prev = NULL; p != q->tail; p = PKTLINK(p))
203 prev = p;
204
205 if (prev)
206 PKTSETLINK(prev, NULL);
207 else
208 q->head = NULL;
209
210 q->tail = prev;
211 q->len--;
212
213 pq->len--;
214
215 return p;
216 }
217
218 void
219 pktq_pflush(osl_t *osh, struct pktq *pq, int prec, bool dir)
220 {
221 struct pktq_prec *q;
222 void *p;
223
224 q = &pq->q[prec];
225 p = q->head;
226 while (p) {
227 q->head = PKTLINK(p);
228 PKTSETLINK(p, NULL);
229 PKTFREE(osh, p, dir);
230 q->len--;
231 pq->len--;
232 p = q->head;
233 }
234 ASSERT(q->len == 0);
235 q->tail = NULL;
236 }
237
238 bool
239 pktq_pdel(struct pktq *pq, void *pktbuf, int prec)
240 {
241 struct pktq_prec *q;
242 void *p;
243
244 ASSERT(prec >= 0 && prec < pq->num_prec);
245
246 if (!pktbuf)
247 return FALSE;
248
249 q = &pq->q[prec];
250
251 if (q->head == pktbuf) {
252 if ((q->head = PKTLINK(pktbuf)) == NULL)
253 q->tail = NULL;
254 } else {
255 for (p = q->head; p && PKTLINK(p) != pktbuf; p = PKTLINK(p))
256 ;
257 if (p == NULL)
258 return FALSE;
259
260 PKTSETLINK(p, PKTLINK(pktbuf));
261 if (q->tail == pktbuf)
262 q->tail = p;
263 }
264
265 q->len--;
266 pq->len--;
267 PKTSETLINK(pktbuf, NULL);
268 return TRUE;
269 }
270
271 void
272 pktq_init(struct pktq *pq, int num_prec, int max_len)
273 {
274 int prec;
275
276 ASSERT(num_prec > 0 && num_prec <= PKTQ_MAX_PREC);
277
278 /* pq is variable size; only zero out what's requested */
279 bzero(pq, OFFSETOF(struct pktq, q) + (sizeof(struct pktq_prec) * num_prec));
280
281 pq->num_prec = (uint16)num_prec;
282
283 pq->max = (uint16)max_len;
284
285 for (prec = 0; prec < num_prec; prec++)
286 pq->q[prec].max = pq->max;
287 }
288
289 int
290 pktq_setmax(struct pktq *pq, int max_len)
291 {
292 int prec;
293
294 if (!max_len)
295 return pq->max;
296
297 pq->max = (uint16)max_len;
298 for (prec = 0; prec < pq->num_prec; prec++)
299 pq->q[prec].max = pq->max;
300
301 return pq->max;
302 }
303
304 void *
305 pktq_deq(struct pktq *pq, int *prec_out)
306 {
307 struct pktq_prec *q;
308 void *p;
309 int prec;
310
311 if (pq->len == 0)
312 return NULL;
313
314 while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
315 pq->hi_prec--;
316
317 q = &pq->q[prec];
318
319 if ((p = q->head) == NULL)
320 return NULL;
321
322 if ((q->head = PKTLINK(p)) == NULL)
323 q->tail = NULL;
324
325 q->len--;
326
327 pq->len--;
328
329 if (prec_out)
330 *prec_out = prec;
331
332 PKTSETLINK(p, NULL);
333
334 return p;
335 }
336
337 void *
338 pktq_deq_tail(struct pktq *pq, int *prec_out)
339 {
340 struct pktq_prec *q;
341 void *p, *prev;
342 int prec;
343
344 if (pq->len == 0)
345 return NULL;
346
347 for (prec = 0; prec < pq->hi_prec; prec++)
348 if (pq->q[prec].head)
349 break;
350
351 q = &pq->q[prec];
352
353 if ((p = q->head) == NULL)
354 return NULL;
355
356 for (prev = NULL; p != q->tail; p = PKTLINK(p))
357 prev = p;
358
359 if (prev)
360 PKTSETLINK(prev, NULL);
361 else
362 q->head = NULL;
363
364 q->tail = prev;
365 q->len--;
366
367 pq->len--;
368
369 if (prec_out)
370 *prec_out = prec;
371
372 PKTSETLINK(p, NULL);
373
374 return p;
375 }
376
377 void *
378 pktq_peek(struct pktq *pq, int *prec_out)
379 {
380 int prec;
381
382 if (pq->len == 0)
383 return NULL;
384
385 while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
386 pq->hi_prec--;
387
388 if (prec_out)
389 *prec_out = prec;
390
391 return (pq->q[prec].head);
392 }
393
394 void *
395 pktq_peek_tail(struct pktq *pq, int *prec_out)
396 {
397 int prec;
398
399 if (pq->len == 0)
400 return NULL;
401
402 for (prec = 0; prec < pq->hi_prec; prec++)
403 if (pq->q[prec].head)
404 break;
405
406 if (prec_out)
407 *prec_out = prec;
408
409 return (pq->q[prec].tail);
410 }
411
412 void
413 pktq_flush(osl_t *osh, struct pktq *pq, bool dir)
414 {
415 int prec;
416 for (prec = 0; prec < pq->num_prec; prec++)
417 pktq_pflush(osh, pq, prec, dir);
418 ASSERT(pq->len == 0);
419 }
420
421 /* Return sum of lengths of a specific set of precedences */
422 int
423 pktq_mlen(struct pktq *pq, uint prec_bmp)
424 {
425 int prec, len;
426
427 len = 0;
428
429 for (prec = 0; prec <= pq->hi_prec; prec++)
430 if (prec_bmp & (1 << prec))
431 len += pq->q[prec].len;
432
433 return len;
434 }
435
436 /* Priority dequeue from a specific set of precedences */
437 void *
438 pktq_mdeq(struct pktq *pq, uint prec_bmp, int *prec_out)
439 {
440 struct pktq_prec *q;
441 void *p;
442 int prec;
443
444 if (pq->len == 0)
445 return NULL;
446
447 while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
448 pq->hi_prec--;
449
450 while ((prec_bmp & (1 << prec)) == 0 || pq->q[prec].head == NULL)
451 if (prec-- == 0)
452 return NULL;
453
454 q = &pq->q[prec];
455
456 if ((p = q->head) == NULL)
457 return NULL;
458
459 if ((q->head = PKTLINK(p)) == NULL)
460 q->tail = NULL;
461
462 q->len--;
463
464 if (prec_out)
465 *prec_out = prec;
466
467 pq->len--;
468
469 PKTSETLINK(p, NULL);
470
471 return p;
472 }
473 #endif /* BCMDRIVER */
474
475 #ifndef BCMROMOFFLOAD
476
477 const unsigned char bcm_ctype[] = {
478 _BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C, /* 0-7 */
479 _BCM_C, _BCM_C|_BCM_S, _BCM_C|_BCM_S, _BCM_C|_BCM_S, _BCM_C|_BCM_S, _BCM_C|_BCM_S, _BCM_C,
480 _BCM_C, /* 8-15 */
481 _BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C, /* 16-23 */
482 _BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C, /* 24-31 */
483 _BCM_S|_BCM_SP,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P, /* 32-39 */
484 _BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P, /* 40-47 */
485 _BCM_D,_BCM_D,_BCM_D,_BCM_D,_BCM_D,_BCM_D,_BCM_D,_BCM_D, /* 48-55 */
486 _BCM_D,_BCM_D,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P, /* 56-63 */
487 _BCM_P, _BCM_U|_BCM_X, _BCM_U|_BCM_X, _BCM_U|_BCM_X, _BCM_U|_BCM_X, _BCM_U|_BCM_X,
488 _BCM_U|_BCM_X, _BCM_U, /* 64-71 */
489 _BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U, /* 72-79 */
490 _BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U, /* 80-87 */
491 _BCM_U,_BCM_U,_BCM_U,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P, /* 88-95 */
492 _BCM_P, _BCM_L|_BCM_X, _BCM_L|_BCM_X, _BCM_L|_BCM_X, _BCM_L|_BCM_X, _BCM_L|_BCM_X,
493 _BCM_L|_BCM_X, _BCM_L, /* 96-103 */
494 _BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L, /* 104-111 */
495 _BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L, /* 112-119 */
496 _BCM_L,_BCM_L,_BCM_L,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_C, /* 120-127 */
497 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 128-143 */
498 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 144-159 */
499 _BCM_S|_BCM_SP, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P,
500 _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, /* 160-175 */
501 _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P,
502 _BCM_P, _BCM_P, _BCM_P, _BCM_P, _BCM_P, /* 176-191 */
503 _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U,
504 _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, /* 192-207 */
505 _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_P, _BCM_U, _BCM_U, _BCM_U,
506 _BCM_U, _BCM_U, _BCM_U, _BCM_U, _BCM_L, /* 208-223 */
507 _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L,
508 _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, /* 224-239 */
509 _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_P, _BCM_L, _BCM_L, _BCM_L,
510 _BCM_L, _BCM_L, _BCM_L, _BCM_L, _BCM_L /* 240-255 */
511 };
512
513 ulong
514 BCMROMFN(bcm_strtoul)(char *cp, char **endp, uint base)
515 {
516 ulong result, value;
517 bool minus;
518
519 minus = FALSE;
520
521 while (bcm_isspace(*cp))
522 cp++;
523
524 if (cp[0] == '+')
525 cp++;
526 else if (cp[0] == '-') {
527 minus = TRUE;
528 cp++;
529 }
530
531 if (base == 0) {
532 if (cp[0] == '0') {
533 if ((cp[1] == 'x') || (cp[1] == 'X')) {
534 base = 16;
535 cp = &cp[2];
536 } else {
537 base = 8;
538 cp = &cp[1];
539 }
540 } else
541 base = 10;
542 } else if (base == 16 && (cp[0] == '0') && ((cp[1] == 'x') || (cp[1] == 'X'))) {
543 cp = &cp[2];
544 }
545
546 result = 0;
547
548 while (bcm_isxdigit(*cp) &&
549 (value = bcm_isdigit(*cp) ? *cp-'0' : bcm_toupper(*cp)-'A'+10) < base) {
550 result = result*base + value;
551 cp++;
552 }
553
554 if (minus)
555 result = (ulong)(result * -1);
556
557 if (endp)
558 *endp = (char *)cp;
559
560 return (result);
561 }
562
563 int
564 BCMROMFN(bcm_atoi)(char *s)
565 {
566 return (int)bcm_strtoul(s, NULL, 10);
567 }
568
569 /* return pointer to location of substring 'needle' in 'haystack' */
570 char*
571 BCMROMFN(bcmstrstr)(char *haystack, char *needle)
572 {
573 int len, nlen;
574 int i;
575
576 if ((haystack == NULL) || (needle == NULL))
577 return (haystack);
578
579 nlen = strlen(needle);
580 len = strlen(haystack) - nlen + 1;
581
582 for (i = 0; i < len; i++)
583 if (memcmp(needle, &haystack[i], nlen) == 0)
584 return (&haystack[i]);
585 return (NULL);
586 }
587
588 char*
589 BCMROMFN(bcmstrcat)(char *dest, const char *src)
590 {
591 strcpy(&dest[strlen(dest)], src);
592 return (dest);
593 }
594
595 char*
596 BCMROMFN(bcmstrncat)(char *dest, const char *src, uint size)
597 {
598 char *endp;
599 char *p;
600
601 p = dest + strlen(dest);
602 endp = p + size;
603
604 while (p != endp && (*p++ = *src++) != '\0')
605 ;
606
607 return (dest);
608 }
609
610 /* parse a xx:xx:xx:xx:xx:xx format ethernet address */
611 int
612 BCMROMFN(bcm_ether_atoe)(char *p, struct ether_addr *ea)
613 {
614 int i = 0;
615
616 for (;;) {
617 ea->octet[i++] = (char) bcm_strtoul(p, &p, 16);
618 if (!*p++ || i == 6)
619 break;
620 }
621
622 return (i == 6);
623 }
624 #endif /* !BCMROMOFFLOAD */
625
626 #if defined(CONFIG_USBRNDIS_RETAIL) || defined(NDIS_MINIPORT_DRIVER)
627 /* registry routine buffer preparation utility functions:
628 * parameter order is like strncpy, but returns count
629 * of bytes copied. Minimum bytes copied is null char(1)/wchar(2)
630 */
631 ulong
632 wchar2ascii(
633 char *abuf,
634 ushort *wbuf,
635 ushort wbuflen,
636 ulong abuflen
637 )
638 {
639 ulong copyct = 1;
640 ushort i;
641
642 if (abuflen == 0)
643 return 0;
644
645 /* wbuflen is in bytes */
646 wbuflen /= sizeof(ushort);
647
648 for (i = 0; i < wbuflen; ++i) {
649 if (--abuflen == 0)
650 break;
651 *abuf++ = (char) *wbuf++;
652 ++copyct;
653 }
654 *abuf = '\0';
655
656 return copyct;
657 }
658 #endif /* CONFIG_USBRNDIS_RETAIL || NDIS_MINIPORT_DRIVER */
659
660 char *
661 bcm_ether_ntoa(struct ether_addr *ea, char *buf)
662 {
663 snprintf(buf, 18, "%02x:%02x:%02x:%02x:%02x:%02x",
664 ea->octet[0]&0xff, ea->octet[1]&0xff, ea->octet[2]&0xff,
665 ea->octet[3]&0xff, ea->octet[4]&0xff, ea->octet[5]&0xff);
666 return (buf);
667 }
668
669 char *
670 bcm_ip_ntoa(struct ipv4_addr *ia, char *buf)
671 {
672 snprintf(buf, 16, "%d.%d.%d.%d",
673 ia->addr[0], ia->addr[1], ia->addr[2], ia->addr[3]);
674 return (buf);
675 }
676
677 #ifdef BCMDRIVER
678
679 void
680 bcm_mdelay(uint ms)
681 {
682 uint i;
683
684 for (i = 0; i < ms; i++) {
685 OSL_DELAY(1000);
686 }
687 }
688
689 /*
690 * Search the name=value vars for a specific one and return its value.
691 * Returns NULL if not found.
692 */
693 char *
694 getvar(char *vars, const char *name)
695 {
696 #ifdef _MINOSL_
697 return NULL;
698 #else
699 char *s;
700 int len;
701
702 if (!name)
703 return NULL;
704
705 len = strlen(name);
706 if (len == 0)
707 return NULL;
708
709 /* first look in vars[] */
710 for (s = vars; s && *s;) {
711 /* CSTYLED */
712 if ((bcmp(s, name, len) == 0) && (s[len] == '='))
713 return (&s[len+1]);
714
715 while (*s++)
716 ;
717 }
718
719 /* then query nvram */
720 return (nvram_get(name));
721 #endif /* _MINOSL_ */
722 }
723
724 /*
725 * Search the vars for a specific one and return its value as
726 * an integer. Returns 0 if not found.
727 */
728 int
729 getintvar(char *vars, const char *name)
730 {
731 #ifdef _MINOSL_
732 return 0;
733 #else
734 char *val;
735
736 if ((val = getvar(vars, name)) == NULL)
737 return (0);
738
739 return (bcm_strtoul(val, NULL, 0));
740 #endif /* _MINOSL_ */
741 }
742
743
744 /* Search for token in comma separated token-string */
745 static int
746 findmatch(char *string, char *name)
747 {
748 uint len;
749 char *c;
750
751 len = strlen(name);
752 /* CSTYLED */
753 while ((c = strchr(string, ',')) != NULL) {
754 if (len == (uint)(c - string) && !strncmp(string, name, len))
755 return 1;
756 string = c + 1;
757 }
758
759 return (!strcmp(string, name));
760 }
761
762 /* Return gpio pin number assigned to the named pin
763 *
764 * Variable should be in format:
765 *
766 * gpio<N>=pin_name,pin_name
767 *
768 * This format allows multiple features to share the gpio with mutual
769 * understanding.
770 *
771 * 'def_pin' is returned if a specific gpio is not defined for the requested functionality
772 * and if def_pin is not used by others.
773 */
774 uint
775 getgpiopin(char *vars, char *pin_name, uint def_pin)
776 {
777 char name[] = "gpioXXXX";
778 char *val;
779 uint pin;
780
781 /* Go thru all possibilities till a match in pin name */
782 for (pin = 0; pin < GPIO_NUMPINS; pin ++) {
783 snprintf(name, sizeof(name), "gpio%d", pin);
784 val = getvar(vars, name);
785 if (val && findmatch(val, pin_name))
786 return pin;
787 }
788
789 if (def_pin != GPIO_PIN_NOTDEFINED) {
790 /* make sure the default pin is not used by someone else */
791 snprintf(name, sizeof(name), "gpio%d", def_pin);
792 if (getvar(vars, name)) {
793 def_pin = GPIO_PIN_NOTDEFINED;
794 }
795 }
796
797 return def_pin;
798 }
799
800 #ifdef BCMPERFSTATS
801
802 #define LOGSIZE 256 /* should be power of 2 to avoid div below */
803 static struct {
804 uint cycles;
805 char *fmt;
806 uint a1;
807 uint a2;
808 } logtab[LOGSIZE];
809
810 /* last entry logged */
811 static uint logi = 0;
812 /* next entry to read */
813 static uint readi = 0;
814
815 void
816 bcm_perf_enable()
817 {
818 BCMPERF_ENABLE_INSTRCOUNT();
819 BCMPERF_ENABLE_ICACHE_MISS();
820 BCMPERF_ENABLE_ICACHE_HIT();
821 }
822
823 void
824 bcmlog(char *fmt, uint a1, uint a2)
825 {
826 static uint last = 0;
827 uint cycles, i;
828 OSL_GETCYCLES(cycles);
829
830 i = logi;
831
832 logtab[i].cycles = cycles - last;
833 logtab[i].fmt = fmt;
834 logtab[i].a1 = a1;
835 logtab[i].a2 = a2;
836
837 logi = (i + 1) % LOGSIZE;
838 last = cycles;
839 }
840
841
842 void
843 bcmstats(char *fmt)
844 {
845 static uint last = 0;
846 static uint32 ic_miss = 0;
847 static uint32 instr_count = 0;
848 uint32 ic_miss_cur;
849 uint32 instr_count_cur;
850 uint cycles, i;
851
852 OSL_GETCYCLES(cycles);
853 BCMPERF_GETICACHE_MISS(ic_miss_cur);
854 BCMPERF_GETINSTRCOUNT(instr_count_cur);
855
856 i = logi;
857
858 logtab[i].cycles = cycles - last;
859 logtab[i].a1 = ic_miss_cur - ic_miss;
860 logtab[i].a2 = instr_count_cur - instr_count;
861 logtab[i].fmt = fmt;
862
863 logi = (i + 1) % LOGSIZE;
864
865 last = cycles;
866 instr_count = instr_count_cur;
867 ic_miss = ic_miss_cur;
868 }
869
870
871 void
872 bcmdumplog(char *buf, int size)
873 {
874 char *limit, *line;
875 int j = 0;
876 int num;
877
878 limit = buf + size - 80;
879 *buf = '\0';
880
881 num = logi - readi;
882
883 if (num < 0)
884 num += LOGSIZE;
885
886 /* print in chronological order */
887
888 for (j = 0; j < num && (buf < limit); readi = (readi + 1) % LOGSIZE, j++) {
889 if (logtab[readi].fmt == NULL)
890 continue;
891 line = buf;
892 buf += sprintf(buf, "%d\t", logtab[readi].cycles);
893 buf += sprintf(buf, logtab[readi].fmt, logtab[readi].a1, logtab[readi].a2);
894 buf += sprintf(buf, "\n");
895 }
896
897 }
898
899
900 /*
901 * Dump one log entry at a time.
902 * Return index of next entry or -1 when no more .
903 */
904 int
905 bcmdumplogent(char *buf, uint i)
906 {
907 bool hit;
908
909 /*
910 * If buf is NULL, return the starting index,
911 * interpreting i as the indicator of last 'i' entries to dump.
912 */
913 if (buf == NULL) {
914 i = ((i > 0) && (i < (LOGSIZE - 1))) ? i : (LOGSIZE - 1);
915 return ((logi - i) % LOGSIZE);
916 }
917
918 *buf = '\0';
919
920 ASSERT(i < LOGSIZE);
921
922 if (i == logi)
923 return (-1);
924
925 hit = FALSE;
926 for (; (i != logi) && !hit; i = (i + 1) % LOGSIZE) {
927 if (logtab[i].fmt == NULL)
928 continue;
929 buf += sprintf(buf, "%d: %d\t", i, logtab[i].cycles);
930 buf += sprintf(buf, logtab[i].fmt, logtab[i].a1, logtab[i].a2);
931 buf += sprintf(buf, "\n");
932 hit = TRUE;
933 }
934
935 return (i);
936 }
937
938 #endif /* BCMPERFSTATS */
939
940
941 /* Takes an Ethernet frame and sets out-of-bound PKTPRIO.
942 * Also updates the inplace vlan tag if requested.
943 * For debugging, it returns an indication of what it did.
944 */
945 uint
946 pktsetprio(void *pkt, bool update_vtag)
947 {
948 struct ether_header *eh;
949 struct ethervlan_header *evh;
950 uint8 *pktdata;
951 int priority = 0;
952 int rc = 0;
953
954 pktdata = (uint8 *) PKTDATA(NULL, pkt);
955 ASSERT(ISALIGNED((uintptr)pktdata, sizeof(uint16)));
956
957 eh = (struct ether_header *) pktdata;
958
959 if (ntoh16(eh->ether_type) == ETHER_TYPE_8021Q) {
960 uint16 vlan_tag;
961 int vlan_prio, dscp_prio = 0;
962
963 evh = (struct ethervlan_header *)eh;
964
965 vlan_tag = ntoh16(evh->vlan_tag);
966 vlan_prio = (int) (vlan_tag >> VLAN_PRI_SHIFT) & VLAN_PRI_MASK;
967
968 if (ntoh16(evh->ether_type) == ETHER_TYPE_IP) {
969 uint8 *ip_body = pktdata + sizeof(struct ethervlan_header);
970 uint8 tos_tc = IP_TOS(ip_body);
971 dscp_prio = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
972 if ((IP_VER(ip_body) == IP_VER_4) && (IPV4_PROT(ip_body) == IP_PROT_TCP)) {
973 int ip_len;
974 int src_port;
975 bool src_port_exc;
976 uint8 *tcp_hdr;
977
978 ip_len = IPV4_PAYLOAD_LEN(ip_body);
979 tcp_hdr = IPV4_NO_OPTIONS_PAYLOAD(ip_body);
980 src_port = TCP_SRC_PORT(tcp_hdr);
981 src_port_exc = (src_port == 10110) || (src_port == 10120) ||
982 (src_port == 10130) || (src_port == 10140);
983
984 if ((ip_len == 40) && src_port_exc && TCP_IS_ACK(tcp_hdr)) {
985 dscp_prio = 7;
986 }
987 }
988 }
989
990 /* DSCP priority gets precedence over 802.1P (vlan tag) */
991 if (dscp_prio != 0) {
992 priority = dscp_prio;
993 rc |= PKTPRIO_VDSCP;
994 } else {
995 priority = vlan_prio;
996 rc |= PKTPRIO_VLAN;
997 }
998 /*
999 * If the DSCP priority is not the same as the VLAN priority,
1000 * then overwrite the priority field in the vlan tag, with the
1001 * DSCP priority value. This is required for Linux APs because
1002 * the VLAN driver on Linux, overwrites the skb->priority field
1003 * with the priority value in the vlan tag
1004 */
1005 if (update_vtag && (priority != vlan_prio)) {
1006 vlan_tag &= ~(VLAN_PRI_MASK << VLAN_PRI_SHIFT);
1007 vlan_tag |= (uint16)priority << VLAN_PRI_SHIFT;
1008 evh->vlan_tag = hton16(vlan_tag);
1009 rc |= PKTPRIO_UPD;
1010 }
1011 } else if (ntoh16(eh->ether_type) == ETHER_TYPE_IP) {
1012 uint8 *ip_body = pktdata + sizeof(struct ether_header);
1013 uint8 tos_tc = IP_TOS(ip_body);
1014 priority = (int)(tos_tc >> IPV4_TOS_PREC_SHIFT);
1015 rc |= PKTPRIO_DSCP;
1016 if ((IP_VER(ip_body) == IP_VER_4) && (IPV4_PROT(ip_body) == IP_PROT_TCP)) {
1017 int ip_len;
1018 int src_port;
1019 bool src_port_exc;
1020 uint8 *tcp_hdr;
1021
1022 ip_len = IPV4_PAYLOAD_LEN(ip_body);
1023 tcp_hdr = IPV4_NO_OPTIONS_PAYLOAD(ip_body);
1024 src_port = TCP_SRC_PORT(tcp_hdr);
1025 src_port_exc = (src_port == 10110) || (src_port == 10120) ||
1026 (src_port == 10130) || (src_port == 10140);
1027
1028 if ((ip_len == 40) && src_port_exc && TCP_IS_ACK(tcp_hdr)) {
1029 priority = 7;
1030 }
1031 }
1032 }
1033
1034 ASSERT(priority >= 0 && priority <= MAXPRIO);
1035 PKTSETPRIO(pkt, priority);
1036 return (rc | priority);
1037 }
1038
1039 static char bcm_undeferrstr[BCME_STRLEN];
1040
1041 static const char *bcmerrorstrtable[] = BCMERRSTRINGTABLE;
1042
1043 /* Convert the error codes into related error strings */
1044 const char *
1045 bcmerrorstr(int bcmerror)
1046 {
1047 /* check if someone added a bcmerror code but forgot to add errorstring */
1048 ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(bcmerrorstrtable) - 1));
1049
1050 if (bcmerror > 0 || bcmerror < BCME_LAST) {
1051 snprintf(bcm_undeferrstr, BCME_STRLEN, "Undefined error %d", bcmerror);
1052 return bcm_undeferrstr;
1053 }
1054
1055 ASSERT(strlen(bcmerrorstrtable[-bcmerror]) < BCME_STRLEN);
1056
1057 return bcmerrorstrtable[-bcmerror];
1058 }
1059
1060 static void
1061 BCMINITFN(bcm_nvram_refresh)(char *flash)
1062 {
1063 int i;
1064 int ret = 0;
1065
1066 ASSERT(flash);
1067
1068 /* default "empty" vars cache */
1069 bzero(flash, 2);
1070
1071 if ((ret = nvram_getall(flash, NVRAM_SPACE)))
1072 return;
1073
1074 /* determine nvram length */
1075 for (i = 0; i < NVRAM_SPACE; i++) {
1076 if (flash[i] == '\0' && flash[i+1] == '\0')
1077 break;
1078 }
1079
1080 if (i > 1)
1081 vars_len = i + 2;
1082 else
1083 vars_len = 0;
1084 }
1085
1086 char *
1087 bcm_nvram_vars(uint *length)
1088 {
1089 #ifndef BCMNVRAMR
1090 /* cache may be stale if nvram is read/write */
1091 if (nvram_vars) {
1092 ASSERT(!bcmreclaimed);
1093 bcm_nvram_refresh(nvram_vars);
1094 }
1095 #endif
1096 if (length)
1097 *length = vars_len;
1098 return nvram_vars;
1099 }
1100
1101 /* copy nvram vars into locally-allocated multi-string array */
1102 int
1103 BCMINITFN(bcm_nvram_cache)(void *sbh)
1104 {
1105 void *osh;
1106 int ret = 0;
1107 char *flash = NULL;
1108
1109 if (vars_len >= 0) {
1110 #ifndef BCMNVRAMR
1111 bcm_nvram_refresh(nvram_vars);
1112 #endif
1113 return 0;
1114 }
1115
1116 osh = sb_osh((sb_t *)sbh);
1117
1118 /* allocate memory and read in flash */
1119 if (!(flash = MALLOC(osh, NVRAM_SPACE))) {
1120 ret = BCME_NOMEM;
1121 goto exit;
1122 }
1123
1124 bcm_nvram_refresh(flash);
1125
1126 #ifdef BCMNVRAMR
1127 if (vars_len > 3) {
1128 /* copy into a properly-sized buffer */
1129 if (!(nvram_vars = MALLOC(osh, vars_len))) {
1130 ret = BCME_NOMEM;
1131 } else
1132 bcopy(flash, nvram_vars, vars_len);
1133 }
1134 MFREE(osh, flash, NVRAM_SPACE);
1135 #else
1136 /* cache must be full size of nvram if read/write */
1137 nvram_vars = flash;
1138 #endif /* BCMNVRAMR */
1139
1140 exit:
1141 return ret;
1142 }
1143
1144 #ifdef BCMDBG_PKT /* pkt logging for debugging */
1145 /* Add a packet to the pktlist */
1146 void
1147 pktlist_add(pktlist_info_t *pktlist, void *pkt)
1148 {
1149 uint i;
1150 ASSERT(pktlist->count < PKTLIST_SIZE);
1151
1152 /* Verify the packet is not already part of the list */
1153 for (i = 0; i < pktlist->count; i++) {
1154 if (pktlist->list[i] == pkt)
1155 ASSERT(0);
1156 }
1157 pktlist->list[pktlist->count] = pkt;
1158 pktlist->count++;
1159 return;
1160 }
1161
1162 /* Remove a packet from the pktlist */
1163 void
1164 pktlist_remove(pktlist_info_t *pktlist, void *pkt)
1165 {
1166 uint i;
1167 uint num = pktlist->count;
1168
1169 /* find the index where pkt exists */
1170 for (i = 0; i < num; i++)
1171 {
1172 /* check for the existence of pkt in the list */
1173 if (pktlist->list[i] == pkt)
1174 {
1175 /* replace with the last element */
1176 pktlist->list[i] = pktlist->list[num-1];
1177 pktlist->count--;
1178 return;
1179 }
1180 }
1181 ASSERT(0);
1182 }
1183
1184 /* Dump the pktlist (and the contents of each packet if 'data'
1185 * is set). 'buf' should be large enough
1186 */
1187
1188 char *
1189 pktlist_dump(pktlist_info_t *pktlist, char *buf)
1190 {
1191 char *obuf;
1192 uint i;
1193
1194 obuf = buf;
1195
1196 buf += sprintf(buf, "Packet list dump:\n");
1197
1198 for (i = 0; i < (pktlist->count); i++) {
1199 buf += sprintf(buf, "0x%p\t", pktlist->list[i]);
1200
1201 #ifdef NOTDEF /* Remove this ifdef to print pkttag and pktdata */
1202 if (PKTTAG(pktlist->list[i])) {
1203 /* Print pkttag */
1204 buf += sprintf(buf, "Pkttag(in hex): ");
1205 buf += bcm_format_hex(buf, PKTTAG(pktlist->list[i]), OSL_PKTTAG_SZ);
1206 }
1207 buf += sprintf(buf, "Pktdata(in hex): ");
1208 buf += bcm_format_hex(buf, PKTDATA(NULL, pktlist->list[i]),
1209 PKTLEN(NULL, pktlist->list[i]));
1210 #endif /* NOTDEF */
1211
1212 buf += sprintf(buf, "\n");
1213 }
1214 return obuf;
1215 }
1216 #endif /* BCMDBG_PKT */
1217
1218 /* iovar table lookup */
1219 const bcm_iovar_t*
1220 bcm_iovar_lookup(const bcm_iovar_t *table, const char *name)
1221 {
1222 const bcm_iovar_t *vi;
1223 const char *lookup_name;
1224
1225 /* skip any ':' delimited option prefixes */
1226 lookup_name = strrchr(name, ':');
1227 if (lookup_name != NULL)
1228 lookup_name++;
1229 else
1230 lookup_name = name;
1231
1232 ASSERT(table);
1233
1234 for (vi = table; vi->name; vi++) {
1235 if (!strcmp(vi->name, lookup_name))
1236 return vi;
1237 }
1238 /* ran to end of table */
1239
1240 return NULL; /* var name not found */
1241 }
1242
1243 int
1244 bcm_iovar_lencheck(const bcm_iovar_t *vi, void *arg, int len, bool set)
1245 {
1246 int bcmerror = 0;
1247
1248 /* length check on io buf */
1249 switch (vi->type) {
1250 case IOVT_BOOL:
1251 case IOVT_INT8:
1252 case IOVT_INT16:
1253 case IOVT_INT32:
1254 case IOVT_UINT8:
1255 case IOVT_UINT16:
1256 case IOVT_UINT32:
1257 /* all integers are int32 sized args at the ioctl interface */
1258 if (len < (int)sizeof(int)) {
1259 bcmerror = BCME_BUFTOOSHORT;
1260 }
1261 break;
1262
1263 case IOVT_BUFFER:
1264 /* buffer must meet minimum length requirement */
1265 if (len < vi->minlen) {
1266 bcmerror = BCME_BUFTOOSHORT;
1267 }
1268 break;
1269
1270 case IOVT_VOID:
1271 if (!set) {
1272 /* Cannot return nil... */
1273 bcmerror = BCME_UNSUPPORTED;
1274 } else if (len) {
1275 /* Set is an action w/o parameters */
1276 bcmerror = BCME_BUFTOOLONG;
1277 }
1278 break;
1279
1280 default:
1281 /* unknown type for length check in iovar info */
1282 ASSERT(0);
1283 bcmerror = BCME_UNSUPPORTED;
1284 }
1285
1286 return bcmerror;
1287 }
1288
1289 #endif /* BCMDRIVER */
1290
1291
1292 #ifndef BCMROMOFFLOAD
1293 /*******************************************************************************
1294 * crc8
1295 *
1296 * Computes a crc8 over the input data using the polynomial:
1297 *
1298 * x^8 + x^7 +x^6 + x^4 + x^2 + 1
1299 *
1300 * The caller provides the initial value (either CRC8_INIT_VALUE
1301 * or the previous returned value) to allow for processing of
1302 * discontiguous blocks of data. When generating the CRC the
1303 * caller is responsible for complementing the final return value
1304 * and inserting it into the byte stream. When checking, a final
1305 * return value of CRC8_GOOD_VALUE indicates a valid CRC.
1306 *
1307 * Reference: Dallas Semiconductor Application Note 27
1308 * Williams, Ross N., "A Painless Guide to CRC Error Detection Algorithms",
1309 * ver 3, Aug 1993, ross@guest.adelaide.edu.au, Rocksoft Pty Ltd.,
1310 * ftp://ftp.rocksoft.com/clients/rocksoft/papers/crc_v3.txt
1311 *
1312 * ****************************************************************************
1313 */
1314
1315 static const uint8 crc8_table[256] = {
1316 0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
1317 0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
1318 0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
1319 0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5,
1320 0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14,
1321 0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E,
1322 0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80,
1323 0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA,
1324 0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95,
1325 0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF,
1326 0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01,
1327 0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B,
1328 0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA,
1329 0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0,
1330 0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E,
1331 0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34,
1332 0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0,
1333 0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A,
1334 0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54,
1335 0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E,
1336 0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF,
1337 0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5,
1338 0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B,
1339 0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61,
1340 0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E,
1341 0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74,
1342 0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA,
1343 0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0,
1344 0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41,
1345 0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B,
1346 0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5,
1347 0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F
1348 };
1349
1350 #define CRC_INNER_LOOP(n, c, x) \
1351 (c) = ((c) >> 8) ^ crc##n##_table[((c) ^ (x)) & 0xff]
1352
1353 uint8
1354 BCMROMFN(hndcrc8)(
1355 uint8 *pdata, /* pointer to array of data to process */
1356 uint nbytes, /* number of input data bytes to process */
1357 uint8 crc /* either CRC8_INIT_VALUE or previous return value */
1358 )
1359 {
1360 /* hard code the crc loop instead of using CRC_INNER_LOOP macro
1361 * to avoid the undefined and unnecessary (uint8 >> 8) operation.
1362 */
1363 while (nbytes-- > 0)
1364 crc = crc8_table[(crc ^ *pdata++) & 0xff];
1365
1366 return crc;
1367 }
1368
1369 /*******************************************************************************
1370 * crc16
1371 *
1372 * Computes a crc16 over the input data using the polynomial:
1373 *
1374 * x^16 + x^12 +x^5 + 1
1375 *
1376 * The caller provides the initial value (either CRC16_INIT_VALUE
1377 * or the previous returned value) to allow for processing of
1378 * discontiguous blocks of data. When generating the CRC the
1379 * caller is responsible for complementing the final return value
1380 * and inserting it into the byte stream. When checking, a final
1381 * return value of CRC16_GOOD_VALUE indicates a valid CRC.
1382 *
1383 * Reference: Dallas Semiconductor Application Note 27
1384 * Williams, Ross N., "A Painless Guide to CRC Error Detection Algorithms",
1385 * ver 3, Aug 1993, ross@guest.adelaide.edu.au, Rocksoft Pty Ltd.,
1386 * ftp://ftp.rocksoft.com/clients/rocksoft/papers/crc_v3.txt
1387 *
1388 * ****************************************************************************
1389 */
1390
1391 static const uint16 crc16_table[256] = {
1392 0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF,
1393 0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7,
1394 0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E,
1395 0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876,
1396 0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD,
1397 0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5,
1398 0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C,
1399 0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974,
1400 0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB,
1401 0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3,
1402 0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A,
1403 0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72,
1404 0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9,
1405 0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1,
1406 0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738,
1407 0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70,
1408 0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7,
1409 0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF,
1410 0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036,
1411 0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E,
1412 0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5,
1413 0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD,
1414 0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134,
1415 0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C,
1416 0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3,
1417 0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB,
1418 0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232,
1419 0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A,
1420 0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1,
1421 0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9,
1422 0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330,
1423 0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78
1424 };
1425
1426 uint16
1427 BCMROMFN(hndcrc16)(
1428 uint8 *pdata, /* pointer to array of data to process */
1429 uint nbytes, /* number of input data bytes to process */
1430 uint16 crc /* either CRC16_INIT_VALUE or previous return value */
1431 )
1432 {
1433 while (nbytes-- > 0)
1434 CRC_INNER_LOOP(16, crc, *pdata++);
1435 return crc;
1436 }
1437
1438 static const uint32 crc32_table[256] = {
1439 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
1440 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
1441 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
1442 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
1443 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
1444 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
1445 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
1446 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
1447 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
1448 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
1449 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
1450 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
1451 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
1452 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
1453 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
1454 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
1455 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
1456 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
1457 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
1458 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
1459 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
1460 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
1461 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
1462 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
1463 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
1464 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
1465 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
1466 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
1467 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
1468 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
1469 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
1470 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
1471 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
1472 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
1473 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
1474 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
1475 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
1476 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
1477 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
1478 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
1479 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
1480 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
1481 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
1482 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
1483 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
1484 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
1485 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
1486 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
1487 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
1488 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
1489 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
1490 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
1491 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
1492 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
1493 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
1494 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
1495 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
1496 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
1497 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
1498 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
1499 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
1500 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
1501 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
1502 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
1503 };
1504
1505 uint32
1506 BCMROMFN(hndcrc32)(
1507 uint8 *pdata, /* pointer to array of data to process */
1508 uint nbytes, /* number of input data bytes to process */
1509 uint32 crc /* either CRC32_INIT_VALUE or previous return value */
1510 )
1511 {
1512 uint8 *pend;
1513 #ifdef __mips__
1514 uint8 tmp[4];
1515 ulong *tptr = (ulong *)tmp;
1516
1517 /* in case the beginning of the buffer isn't aligned */
1518 pend = (uint8 *)((uint)(pdata + 3) & 0xfffffffc);
1519 nbytes -= (pend - pdata);
1520 while (pdata < pend)
1521 CRC_INNER_LOOP(32, crc, *pdata++);
1522
1523 /* handle bulk of data as 32-bit words */
1524 pend = pdata + (nbytes & 0xfffffffc);
1525 while (pdata < pend) {
1526 *tptr = *(ulong *)pdata;
1527 pdata += sizeof(ulong *);
1528 CRC_INNER_LOOP(32, crc, tmp[0]);
1529 CRC_INNER_LOOP(32, crc, tmp[1]);
1530 CRC_INNER_LOOP(32, crc, tmp[2]);
1531 CRC_INNER_LOOP(32, crc, tmp[3]);
1532 }
1533
1534 /* 1-3 bytes at end of buffer */
1535 pend = pdata + (nbytes & 0x03);
1536 while (pdata < pend)
1537 CRC_INNER_LOOP(32, crc, *pdata++);
1538 #else
1539 pend = pdata + nbytes;
1540 while (pdata < pend)
1541 CRC_INNER_LOOP(32, crc, *pdata++);
1542 #endif /* __mips__ */
1543
1544 return crc;
1545 }
1546
1547 #ifdef notdef
1548 #define CLEN 1499 /* CRC Length */
1549 #define CBUFSIZ (CLEN+4)
1550 #define CNBUFS 5 /* # of bufs */
1551
1552 void testcrc32(void)
1553 {
1554 uint j, k, l;
1555 uint8 *buf;
1556 uint len[CNBUFS];
1557 uint32 crcr;
1558 uint32 crc32tv[CNBUFS] =
1559 {0xd2cb1faa, 0xd385c8fa, 0xf5b4f3f3, 0x55789e20, 0x00343110};
1560
1561 ASSERT((buf = MALLOC(CBUFSIZ*CNBUFS)) != NULL);
1562
1563 /* step through all possible alignments */
1564 for (l = 0; l <= 4; l++) {
1565 for (j = 0; j < CNBUFS; j++) {
1566 len[j] = CLEN;
1567 for (k = 0; k < len[j]; k++)
1568 *(buf + j*CBUFSIZ + (k+l)) = (j+k) & 0xff;
1569 }
1570
1571 for (j = 0; j < CNBUFS; j++) {
1572 crcr = crc32(buf + j*CBUFSIZ + l, len[j], CRC32_INIT_VALUE);
1573 ASSERT(crcr == crc32tv[j]);
1574 }
1575 }
1576
1577 MFREE(buf, CBUFSIZ*CNBUFS);
1578 return;
1579 }
1580 #endif /* notdef */
1581
1582 /*
1583 * Advance from the current 1-byte tag/1-byte length/variable-length value
1584 * triple, to the next, returning a pointer to the next.
1585 * If the current or next TLV is invalid (does not fit in given buffer length),
1586 * NULL is returned.
1587 * *buflen is not modified if the TLV elt parameter is invalid, or is decremented
1588 * by the TLV parameter's length if it is valid.
1589 */
1590 bcm_tlv_t *
1591 BCMROMFN(bcm_next_tlv)(bcm_tlv_t *elt, int *buflen)
1592 {
1593 int len;
1594
1595 /* validate current elt */
1596 if (!bcm_valid_tlv(elt, *buflen))
1597 return NULL;
1598
1599 /* advance to next elt */
1600 len = elt->len;
1601 elt = (bcm_tlv_t*)(elt->data + len);
1602 *buflen -= (2 + len);
1603
1604 /* validate next elt */
1605 if (!bcm_valid_tlv(elt, *buflen))
1606 return NULL;
1607
1608 return elt;
1609 }
1610
1611 /*
1612 * Traverse a string of 1-byte tag/1-byte length/variable-length value
1613 * triples, returning a pointer to the substring whose first element
1614 * matches tag
1615 */
1616 bcm_tlv_t *
1617 BCMROMFN(bcm_parse_tlvs)(void *buf, int buflen, uint key)
1618 {
1619 bcm_tlv_t *elt;
1620 int totlen;
1621
1622 elt = (bcm_tlv_t*)buf;
1623 totlen = buflen;
1624
1625 /* find tagged parameter */
1626 while (totlen >= 2) {
1627 int len = elt->len;
1628
1629 /* validate remaining totlen */
1630 if ((elt->id == key) && (totlen >= (len + 2)))
1631 return (elt);
1632
1633 elt = (bcm_tlv_t*)((uint8*)elt + (len + 2));
1634 totlen -= (len + 2);
1635 }
1636
1637 return NULL;
1638 }
1639
1640 /*
1641 * Traverse a string of 1-byte tag/1-byte length/variable-length value
1642 * triples, returning a pointer to the substring whose first element
1643 * matches tag. Stop parsing when we see an element whose ID is greater
1644 * than the target key.
1645 */
1646 bcm_tlv_t *
1647 BCMROMFN(bcm_parse_ordered_tlvs)(void *buf, int buflen, uint key)
1648 {
1649 bcm_tlv_t *elt;
1650 int totlen;
1651
1652 elt = (bcm_tlv_t*)buf;
1653 totlen = buflen;
1654
1655 /* find tagged parameter */
1656 while (totlen >= 2) {
1657 uint id = elt->id;
1658 int len = elt->len;
1659
1660 /* Punt if we start seeing IDs > than target key */
1661 if (id > key)
1662 return (NULL);
1663
1664 /* validate remaining totlen */
1665 if ((id == key) && (totlen >= (len + 2)))
1666 return (elt);
1667
1668 elt = (bcm_tlv_t*)((uint8*)elt + (len + 2));
1669 totlen -= (len + 2);
1670 }
1671 return NULL;
1672 }
1673 #endif /* !BCMROMOFFLOAD */
1674
1675
1676 /* Produce a human-readable string for boardrev */
1677 char *
1678 bcm_brev_str(uint16 brev, char *buf)
1679 {
1680 if (brev < 0x100)
1681 snprintf(buf, 8, "%d.%d", (brev & 0xf0) >> 4, brev & 0xf);
1682 else
1683 snprintf(buf, 8, "%c%03x", ((brev & 0xf000) == 0x1000) ? 'P' : 'A', brev & 0xfff);
1684
1685 return (buf);
1686 }
1687
1688 #define BUFSIZE_TODUMP_ATONCE 512 /* Buffer size */
1689
1690 /* dump large strings to console */
1691 void
1692 printfbig(char *buf)
1693 {
1694 uint len, max_len;
1695 char c;
1696
1697 len = strlen(buf);
1698
1699 max_len = BUFSIZE_TODUMP_ATONCE;
1700
1701 while (len > max_len) {
1702 c = buf[max_len];
1703 buf[max_len] = '\0';
1704 printf("%s", buf);
1705 buf[max_len] = c;
1706
1707 buf += max_len;
1708 len -= max_len;
1709 }
1710 /* print the remaining string */
1711 printf("%s\n", buf);
1712 return;
1713 }
1714
1715 /* routine to dump fields in a fileddesc structure */
1716 uint
1717 bcmdumpfields(readreg_rtn read_rtn, void *arg0, void *arg1, struct fielddesc *fielddesc_array,
1718 char *buf, uint32 bufsize)
1719 {
1720 uint filled_len;
1721 int len;
1722 struct fielddesc *cur_ptr;
1723
1724 filled_len = 0;
1725 cur_ptr = fielddesc_array;
1726
1727 while (bufsize > 1) {
1728 if (cur_ptr->nameandfmt == NULL)
1729 break;
1730 len = snprintf(buf, bufsize, cur_ptr->nameandfmt,
1731 read_rtn(arg0, arg1, cur_ptr->offset));
1732 /* check for snprintf overflow or error */
1733 if (len < 0 || (uint32)len >= bufsize)
1734 len = bufsize - 1;
1735 buf += len;
1736 bufsize -= len;
1737 filled_len += len;
1738 cur_ptr++;
1739 }
1740 return filled_len;
1741 }
1742
1743 uint
1744 bcm_mkiovar(char *name, char *data, uint datalen, char *buf, uint buflen)
1745 {
1746 uint len;
1747
1748 len = strlen(name) + 1;
1749
1750 if ((len + datalen) > buflen)
1751 return 0;
1752
1753 strncpy(buf, name, buflen);
1754
1755 /* append data onto the end of the name string */
1756 memcpy(&buf[len], data, datalen);
1757 len += datalen;
1758
1759 return len;
1760 }
1761
1762 #ifndef BCMROMOFFLOAD
1763
1764 /* Quarter dBm units to mW
1765 * Table starts at QDBM_OFFSET, so the first entry is mW for qdBm=153
1766 * Table is offset so the last entry is largest mW value that fits in
1767 * a uint16.
1768 */
1769
1770 #define QDBM_OFFSET 153 /* Offset for first entry */
1771 #define QDBM_TABLE_LEN 40 /* Table size */
1772
1773 /* Smallest mW value that will round up to the first table entry, QDBM_OFFSET.
1774 * Value is ( mW(QDBM_OFFSET - 1) + mW(QDBM_OFFSET) ) / 2
1775 */
1776 #define QDBM_TABLE_LOW_BOUND 6493 /* Low bound */
1777
1778 /* Largest mW value that will round down to the last table entry,
1779 * QDBM_OFFSET + QDBM_TABLE_LEN-1.
1780 * Value is ( mW(QDBM_OFFSET + QDBM_TABLE_LEN - 1) + mW(QDBM_OFFSET + QDBM_TABLE_LEN) ) / 2.
1781 */
1782 #define QDBM_TABLE_HIGH_BOUND 64938 /* High bound */
1783
1784 static const uint16 nqdBm_to_mW_map[QDBM_TABLE_LEN] = {
1785 /* qdBm: +0 +1 +2 +3 +4 +5 +6 +7 */
1786 /* 153: */ 6683, 7079, 7499, 7943, 8414, 8913, 9441, 10000,
1787 /* 161: */ 10593, 11220, 11885, 12589, 13335, 14125, 14962, 15849,
1788 /* 169: */ 16788, 17783, 18836, 19953, 21135, 22387, 23714, 25119,
1789 /* 177: */ 26607, 28184, 29854, 31623, 33497, 35481, 37584, 39811,
1790 /* 185: */ 42170, 44668, 47315, 50119, 53088, 56234, 59566, 63096
1791 };
1792
1793 uint16
1794 BCMROMFN(bcm_qdbm_to_mw)(uint8 qdbm)
1795 {
1796 uint factor = 1;
1797 int idx = qdbm - QDBM_OFFSET;
1798
1799 if (idx > QDBM_TABLE_LEN) {
1800 /* clamp to max uint16 mW value */
1801 return 0xFFFF;
1802 }
1803
1804 /* scale the qdBm index up to the range of the table 0-40
1805 * where an offset of 40 qdBm equals a factor of 10 mW.
1806 */
1807 while (idx < 0) {
1808 idx += 40;
1809 factor *= 10;
1810 }
1811
1812 /* return the mW value scaled down to the correct factor of 10,
1813 * adding in factor/2 to get proper rounding.
1814 */
1815 return ((nqdBm_to_mW_map[idx] + factor/2) / factor);
1816 }
1817
1818 uint8
1819 BCMROMFN(bcm_mw_to_qdbm)(uint16 mw)
1820 {
1821 uint8 qdbm;
1822 int offset;
1823 uint mw_uint = mw;
1824 uint boundary;
1825
1826 /* handle boundary case */
1827 if (mw_uint <= 1)
1828 return 0;
1829
1830 offset = QDBM_OFFSET;
1831
1832 /* move mw into the range of the table */
1833 while (mw_uint < QDBM_TABLE_LOW_BOUND) {
1834 mw_uint *= 10;
1835 offset -= 40;
1836 }
1837
1838 for (qdbm = 0; qdbm < QDBM_TABLE_LEN-1; qdbm++) {
1839 boundary = nqdBm_to_mW_map[qdbm] + (nqdBm_to_mW_map[qdbm+1] -
1840 nqdBm_to_mW_map[qdbm])/2;
1841 if (mw_uint < boundary) break;
1842 }
1843
1844 qdbm += (uint8)offset;
1845
1846 return (qdbm);
1847 }
1848
1849
1850 uint
1851 BCMROMFN(bcm_bitcount)(uint8 *bitmap, uint length)
1852 {
1853 uint bitcount = 0, i;
1854 uint8 tmp;
1855 for (i = 0; i < length; i++) {
1856 tmp = bitmap[i];
1857 while (tmp) {
1858 bitcount++;
1859 tmp &= (tmp - 1);
1860 }
1861 }
1862 return bitcount;
1863 }
1864
1865 #endif /* !BCMROMOFFLOAD */
1866
1867 #ifdef BCMDRIVER
1868
1869 /* Initialization of bcmstrbuf structure */
1870 void
1871 bcm_binit(struct bcmstrbuf *b, char *buf, uint size)
1872 {
1873 b->origsize = b->size = size;
1874 b->origbuf = b->buf = buf;
1875 }
1876
1877 /* Buffer sprintf wrapper to guard against buffer overflow */
1878 int
1879 bcm_bprintf(struct bcmstrbuf *b, const char *fmt, ...)
1880 {
1881 va_list ap;
1882 int r;
1883
1884 va_start(ap, fmt);
1885 r = vsnprintf(b->buf, b->size, fmt, ap);
1886
1887 /* Non Ansi C99 compliant returns -1,
1888 * Ansi compliant return r >= b->size,
1889 * bcmstdlib returns 0, handle all
1890 */
1891 if ((r == -1) || (r >= (int)b->size) || (r == 0)) {
1892 b->size = 0;
1893 } else {
1894 b->size -= r;
1895 b->buf += r;
1896 }
1897
1898 va_end(ap);
1899
1900 return r;
1901 }
1902 #endif /* BCMDRIVER */
Tomato firmware and modifications.