release/src-rt/include/bcmutils.h

   1 /*
   2  * Misc useful os-independent macros and functions.
   3  *
   4  * Copyright (C) 2010, Broadcom Corporation. All Rights Reserved.
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  13  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  15  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  16  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  *
  18  * $Id: bcmutils.h,v 13.239.2.10 2011-01-27 19:03:20 Exp $
  19  */
  20
  21 #ifndef _bcmutils_h_
  22 #define _bcmutils_h_
  23
  24 #ifdef __cplusplus
  25 extern "C" {
  26 #endif
  27
  28 /* ctype replacement */
  29 #define _BCM_U  0x01    /* upper */
  30 #define _BCM_L  0x02    /* lower */
  31 #define _BCM_D  0x04    /* digit */
  32 #define _BCM_C  0x08    /* cntrl */
  33 #define _BCM_P  0x10    /* punct */
  34 #define _BCM_S  0x20    /* white space (space/lf/tab) */
  35 #define _BCM_X  0x40    /* hex digit */
  36 #define _BCM_SP 0x80    /* hard space (0x20) */
  37
  38 #if defined(BCMROMBUILD)
  39 extern const unsigned char BCMROMDATA(bcm_ctype)[];
  40 #else
  41 extern const unsigned char bcm_ctype[];
  42 #endif
  43 #define bcm_ismask(x)   (bcm_ctype[(int)(unsigned char)(x)])
  44
  45 #define bcm_isalnum(c)  ((bcm_ismask(c)&(_BCM_U|_BCM_L|_BCM_D)) != 0)
  46 #define bcm_isalpha(c)  ((bcm_ismask(c)&(_BCM_U|_BCM_L)) != 0)
  47 #define bcm_iscntrl(c)  ((bcm_ismask(c)&(_BCM_C)) != 0)
  48 #define bcm_isdigit(c)  ((bcm_ismask(c)&(_BCM_D)) != 0)
  49 #define bcm_isgraph(c)  ((bcm_ismask(c)&(_BCM_P|_BCM_U|_BCM_L|_BCM_D)) != 0)
  50 #define bcm_islower(c)  ((bcm_ismask(c)&(_BCM_L)) != 0)
  51 #define bcm_isprint(c)  ((bcm_ismask(c)&(_BCM_P|_BCM_U|_BCM_L|_BCM_D|_BCM_SP)) != 0)
  52 #define bcm_ispunct(c)  ((bcm_ismask(c)&(_BCM_P)) != 0)
  53 #define bcm_isspace(c)  ((bcm_ismask(c)&(_BCM_S)) != 0)
  54 #define bcm_isupper(c)  ((bcm_ismask(c)&(_BCM_U)) != 0)
  55 #define bcm_isxdigit(c) ((bcm_ismask(c)&(_BCM_D|_BCM_X)) != 0)
  56 #define bcm_tolower(c)  (bcm_isupper((c)) ? ((c) + 'a' - 'A') : (c))
  57 #define bcm_toupper(c)  (bcm_islower((c)) ? ((c) + 'A' - 'a') : (c))
  58
  59 /* Buffer structure for collecting string-formatted data
  60 * using bcm_bprintf() API.
  61 * Use bcm_binit() to initialize before use
  62 */
  63
  64 struct bcmstrbuf {
  65         char *buf;      /* pointer to current position in origbuf */
  66         unsigned int size;      /* current (residual) size in bytes */
  67         char *origbuf;  /* unmodified pointer to orignal buffer */
  68         unsigned int origsize;  /* unmodified orignal buffer size in bytes */
  69 };
  70
  71 /* ** driver-only section ** */
  72 #ifdef BCMDRIVER
  73 #include <osl.h>
  74
  75 #define GPIO_PIN_NOTDEFINED     0x20    /* Pin not defined */
  76
  77 /*
  78  * Spin at most 'us' microseconds while 'exp' is true.
  79  * Caller should explicitly test 'exp' when this completes
  80  * and take appropriate error action if 'exp' is still true.
  81  */
  82 #define SPINWAIT(exp, us) { \
  83         uint countdown = (us) + 9; \
  84         while ((exp) && (countdown >= 10)) {\
  85                 OSL_DELAY(10); \
  86                 countdown -= 10; \
  87         } \
  88 }
  89
  90
  91 /* osl multi-precedence packet queue */
  92 #ifndef PKTQ_LEN_DEFAULT
  93 #define PKTQ_LEN_DEFAULT        128     /* Max 128 packets */
  94 #endif
  95 #ifndef PKTQ_MAX_PREC
  96 #define PKTQ_MAX_PREC           16      /* Maximum precedence levels */
  97 #endif
  98
  99 typedef struct pktq_prec {
 100         void *head;     /* first packet to dequeue */
 101         void *tail;     /* last packet to dequeue */
 102         uint16 len;     /* number of queued packets */
 103         uint16 max;     /* maximum number of queued packets */
 104         uint16 threshold;       /* queue threshold to claim congestion */
 105 } pktq_prec_t;
 106
 107 #define PKTQ_COMMON     \
 108         uint16 num_prec;        /* number of precedences in use */                      \
 109         uint16 hi_prec;         /* rapid dequeue hint (>= highest non-empty prec) */    \
 110         uint16 max;             /* total max packets */                                 \
 111         uint16 threshold;       /* queue threshold to claim congestion */               \
 112         uint16 len;             /* total number of packets */
 113
 114 /* multi-priority pkt queue */
 115 struct pktq {
 116         PKTQ_COMMON
 117         /* q array must be last since # of elements can be either PKTQ_MAX_PREC or 1 */
 118         struct pktq_prec q[PKTQ_MAX_PREC];
 119 };
 120
 121 /* simple, non-priority pkt queue */
 122 struct spktq {
 123         PKTQ_COMMON
 124         /* q array must be last since # of elements can be either PKTQ_MAX_PREC or 1 */
 125         struct pktq_prec q[1];
 126 };
 127
 128 #define PKTQ_PREC_ITER(pq, prec)        for (prec = (pq)->num_prec - 1; prec >= 0; prec--)
 129
 130 /* fn(pkt, arg).  return true if pkt belongs to if */
 131 typedef bool (*ifpkt_cb_t)(void*, int);
 132
 133 #define PKTPOOL_MIN_LEN     32  /* limit small rxbuf using big pktpool buf */
 134 #ifndef PKTPOOL_LEN_MAX
 135 #define PKTPOOL_LEN_MAX         40
 136 #endif /* PKTPOOL_LEN_MAX */
 137 #define PKTPOOL_CB_MAX          3
 138
 139 struct pktpool;
 140 typedef void (*pktpool_cb_t)(struct pktpool *pool, void *arg);
 141 typedef struct {
 142         pktpool_cb_t cb;
 143         void *arg;
 144 } pktpool_cbinfo_t;
 145
 146 #ifdef BCMDBG_POOL
 147 /* pkt pool debug states */
 148 #define POOL_IDLE       0
 149 #define POOL_RXFILL     1
 150 #define POOL_RXDH       2
 151 #define POOL_RXD11      3
 152 #define POOL_TXDH       4
 153 #define POOL_TXD11      5
 154 #define POOL_AMPDU      6
 155 #define POOL_TXENQ      7
 156
 157 typedef struct {
 158         void *p;
 159         uint32 cycles;
 160         uint32 dur;
 161 } pktpool_dbg_t;
 162
 163 typedef struct {
 164         uint8 txdh;     /* tx to host */
 165         uint8 txd11;    /* tx to d11 */
 166         uint8 enq;      /* waiting in q */
 167         uint8 rxdh;     /* rx from host */
 168         uint8 rxd11;    /* rx from d11 */
 169         uint8 rxfill;   /* dma_rxfill */
 170         uint8 idle;     /* avail in pool */
 171 } pktpool_stats_t;
 172 #endif /* BCMDBG_POOL */
 173
 174 typedef struct pktpool {
 175         bool    inited;
 176         uint16 r;
 177         uint16 w;
 178         uint16 len;
 179         uint16 maxlen;
 180         uint16 plen;
 181         bool istx;
 182         bool empty;
 183         uint8 cbtoggle;
 184         uint8 cbcnt;
 185         uint8 ecbcnt;
 186         pktpool_cbinfo_t cbs[PKTPOOL_CB_MAX];
 187         pktpool_cbinfo_t ecbs[PKTPOOL_CB_MAX];
 188         void *q[PKTPOOL_LEN_MAX + 1];
 189
 190 #ifdef BCMDBG_POOL
 191         uint8 dbg_cbcnt;
 192         pktpool_cbinfo_t dbg_cbs[PKTPOOL_CB_MAX];
 193         uint16 dbg_qlen;
 194         pktpool_dbg_t dbg_q[PKTPOOL_LEN_MAX + 1];
 195 #endif
 196 } pktpool_t;
 197
 198 extern int pktpool_init(osl_t *osh, pktpool_t *pktp, int *pktplen, int plen, bool istx);
 199 extern int pktpool_deinit(osl_t *osh, pktpool_t *pktp);
 200 extern int pktpool_fill(osl_t *osh, pktpool_t *pktp, bool minimal);
 201 extern void* pktpool_get(pktpool_t *pktp);
 202 extern void pktpool_free(pktpool_t *pktp, void *p);
 203 extern int pktpool_add(pktpool_t *pktp, void *p);
 204 extern uint16 pktpool_avail(pktpool_t *pktp);
 205 extern int pktpool_avail_register(pktpool_t *pktp, pktpool_cb_t cb, void *arg);
 206 extern int pktpool_empty_register(pktpool_t *pktp, pktpool_cb_t cb, void *arg);
 207 extern int pktpool_setmaxlen(pktpool_t *pktp, uint16 maxlen);
 208
 209 #define POOLPTR(pp)                     ((pktpool_t *)(pp))
 210 #define pktpool_len(pp)                 (POOLPTR(pp)->len - 1)
 211 #define pktpool_plen(pp)                (POOLPTR(pp)->plen)
 212 #define pktpool_maxlen(pp)              (POOLPTR(pp)->maxlen)
 213
 214 #ifdef BCMDBG_POOL
 215 extern int pktpool_dbg_register(pktpool_t *pktp, pktpool_cb_t cb, void *arg);
 216 extern int pktpool_start_trigger(pktpool_t *pktp, void *p);
 217 extern int pktpool_dbg_dump(pktpool_t *pktp);
 218 extern int pktpool_dbg_notify(pktpool_t *pktp);
 219 extern int pktpool_stats_dump(pktpool_t *pktp, pktpool_stats_t *stats);
 220 #endif /* BCMDBG_POOL */
 221
 222 /* forward definition of ether_addr structure used by some function prototypes */
 223
 224 struct ether_addr;
 225
 226 extern int ether_isbcast(const void *ea);
 227 extern int ether_isnulladdr(const void *ea);
 228
 229 /* operations on a specific precedence in packet queue */
 230
 231 #define pktq_psetmax(pq, prec, _max)    ((pq)->q[prec].max = (_max))
 232 #define pktq_plen(pq, prec)             ((pq)->q[prec].len)
 233 #define pktq_pavail(pq, prec)           ((pq)->q[prec].max - (pq)->q[prec].len)
 234 #define pktq_pfull(pq, prec)            ((pq)->q[prec].len >= (pq)->q[prec].max)
 235 #define pktq_pempty(pq, prec)           ((pq)->q[prec].len == 0)
 236 #define pktq_pcongested(pq, prec)       ((pq)->q[prec].len >= (pq)->q[prec].threshold)
 237
 238 #define pktq_ppeek(pq, prec)            ((pq)->q[prec].head)
 239 #define pktq_ppeek_tail(pq, prec)       ((pq)->q[prec].tail)
 240
 241 extern void *pktq_penq(struct pktq *pq, int prec, void *p);
 242 extern void *pktq_penq_head(struct pktq *pq, int prec, void *p);
 243 extern void *pktq_pdeq(struct pktq *pq, int prec);
 244 extern void *pktq_pdeq_tail(struct pktq *pq, int prec);
 245 /* Empty the queue at particular precedence level */
 246 extern void pktq_pflush(osl_t *osh, struct pktq *pq, int prec, bool dir, ifpkt_cb_t fn, int arg);
 247 /* Remove a specified packet from its queue */
 248 extern bool pktq_pdel(struct pktq *pq, void *p, int prec);
 249
 250 /* operations on a set of precedences in packet queue */
 251
 252 extern int pktq_mlen(struct pktq *pq, uint prec_bmp);
 253 extern void *pktq_mdeq(struct pktq *pq, uint prec_bmp, int *prec_out);
 254 extern void *pktq_mpeek(struct pktq *pq, uint prec_bmp, int *prec_out);
 255
 256 /* operations on packet queue as a whole */
 257
 258 #define pktq_len(pq)            ((int)(pq)->len)
 259 #define pktq_max(pq)            ((int)(pq)->max)
 260 #define pktq_avail(pq)          ((int)((pq)->max - (pq)->len))
 261 #define pktq_full(pq)           ((pq)->len >= (pq)->max)
 262 #define pktq_empty(pq)          ((pq)->len == 0)
 263 #define pktq_congested(pq)      ((pq)->len >= (pq)->threshold)
 264
 265 /* operations for single precedence queues */
 266 #define pktenq(pq, p)           pktq_penq(((struct pktq *)(void *)pq), 0, (p))
 267 #define pktenq_head(pq, p)      pktq_penq_head(((struct pktq *)(void *)pq), 0, (p))
 268 #define pktdeq(pq)              pktq_pdeq(((struct pktq *)(void *)pq), 0)
 269 #define pktdeq_tail(pq)         pktq_pdeq_tail(((struct pktq *)(void *)pq), 0)
 270 #define pktqinit(pq, len)       pktq_init(((struct pktq *)(void *)pq), 1, len)
 271
 272 extern void pktq_init(struct pktq *pq, int num_prec, int max_len);
 273 extern void pktq_init_threshold(struct pktq *pq, int num_prec, int max_len, int threshold);
 274 /* prec_out may be NULL if caller is not interested in return value */
 275 extern void *pktq_deq(struct pktq *pq, int *prec_out);
 276 extern void *pktq_deq_tail(struct pktq *pq, int *prec_out);
 277 extern void *pktq_peek(struct pktq *pq, int *prec_out);
 278 extern void *pktq_peek_tail(struct pktq *pq, int *prec_out);
 279 extern void pktq_flush(osl_t *osh, struct pktq *pq, bool dir, ifpkt_cb_t fn, int arg);
 280
 281 /* externs */
 282 /* packet */
 283 extern uint pktcopy(osl_t *osh, void *p, uint offset, int len, uchar *buf);
 284 extern uint pktfrombuf(osl_t *osh, void *p, uint offset, int len, uchar *buf);
 285 extern uint pkttotlen(osl_t *osh, void *p);
 286 extern void *pktlast(osl_t *osh, void *p);
 287 extern uint pktsegcnt(osl_t *osh, void *p);
 288 extern uint pktsegcnt_war(osl_t *osh, void *p);
 289
 290 /* Get priority from a packet and pass it back in scb (or equiv) */
 291 extern uint pktsetprio(void *pkt, bool update_vtag);
 292 #define PKTPRIO_VDSCP   0x100           /* DSCP prio found after VLAN tag */
 293 #define PKTPRIO_VLAN    0x200           /* VLAN prio found */
 294 #define PKTPRIO_UPD     0x400           /* DSCP used to update VLAN prio */
 295 #define PKTPRIO_DSCP    0x800           /* DSCP prio found */
 296
 297 /* string */
 298 extern int BCMROMFN(bcm_atoi)(char *s);
 299 extern ulong BCMROMFN(bcm_strtoul)(char *cp, char **endp, uint base);
 300 extern char *BCMROMFN(bcmstrstr)(char *haystack, char *needle);
 301 extern char *BCMROMFN(bcmstrcat)(char *dest, const char *src);
 302 extern char *BCMROMFN(bcmstrncat)(char *dest, const char *src, uint size);
 303 extern ulong wchar2ascii(char *abuf, ushort *wbuf, ushort wbuflen, ulong abuflen);
 304 char* bcmstrtok(char **string, const char *delimiters, char *tokdelim);
 305 int bcmstricmp(const char *s1, const char *s2);
 306 int bcmstrnicmp(const char* s1, const char* s2, int cnt);
 307
 308
 309 /* ethernet address */
 310 extern char *bcm_ether_ntoa(const struct ether_addr *ea, char *buf);
 311 extern int BCMROMFN(bcm_ether_atoe)(char *p, struct ether_addr *ea);
 312
 313 /* ip address */
 314 struct ipv4_addr;
 315 extern char *bcm_ip_ntoa(struct ipv4_addr *ia, char *buf);
 316
 317 /* delay */
 318 extern void bcm_mdelay(uint ms);
 319 /* variable access */
 320 extern char *getvar(char *vars, const char *name);
 321 extern int getintvar(char *vars, const char *name);
 322 extern int getintvararray(char *vars, const char *name, int indx);
 323 extern int getintvararraysize(char *vars, const char *name);
 324 extern uint getgpiopin(char *vars, char *pin_name, uint def_pin);
 325 #ifdef BCMDBG
 326 extern void prpkt(const char *msg, osl_t *osh, void *p0);
 327 #endif /* BCMDBG */
 328 #ifdef BCMPERFSTATS
 329 extern void bcm_perf_enable(void);
 330 extern void bcmstats(char *fmt);
 331 extern void bcmlog(char *fmt, uint a1, uint a2);
 332 extern void bcmdumplog(char *buf, int size);
 333 extern int bcmdumplogent(char *buf, uint idx);
 334 #else
 335 #define bcm_perf_enable()
 336 #define bcmstats(fmt)
 337 #define bcmlog(fmt, a1, a2)
 338 #define bcmdumplog(buf, size)   *buf = '\0'
 339 #define bcmdumplogent(buf, idx) -1
 340 #endif /* BCMPERFSTATS */
 341
 342 #if defined(BCMTSTAMPEDLOGS)
 343 #define TSF_TICKS_PER_MS        1024
 344 /* Store a TSF timestamp and a log line in the log buffer */
 345 extern void bcmtslog(uint32 tstamp, char *fmt, uint a1, uint a2);
 346 /* Print out the log buffer with timestamps */
 347 extern void bcmprinttslogs(void);
 348 /* Print out a microsecond timestamp as "sec.ms.us " */
 349 extern void bcmprinttstamp(uint32 us);
 350 #else
 351 #define bcmtslog(tstamp, fmt, a1, a2)
 352 #define bcmprinttslogs()
 353 #define bcmprinttstamp(us)
 354 #endif /* BCMTSTAMPEDLOGS */
 355
 356 extern char *bcm_nvram_vars(uint *length);
 357 extern int bcm_nvram_cache(void *sih);
 358
 359 /* Support for sharing code across in-driver iovar implementations.
 360  * The intent is that a driver use this structure to map iovar names
 361  * to its (private) iovar identifiers, and the lookup function to
 362  * find the entry.  Macros are provided to map ids and get/set actions
 363  * into a single number space for a switch statement.
 364  */
 365
 366 /* iovar structure */
 367 typedef struct bcm_iovar {
 368         const char *name;       /* name for lookup and display */
 369         uint16 varid;           /* id for switch */
 370         uint16 flags;           /* driver-specific flag bits */
 371         uint16 type;            /* base type of argument */
 372         uint16 minlen;          /* min length for buffer vars */
 373 } bcm_iovar_t;
 374
 375 /* varid definitions are per-driver, may use these get/set bits */
 376
 377 /* IOVar action bits for id mapping */
 378 #define IOV_GET 0 /* Get an iovar */
 379 #define IOV_SET 1 /* Set an iovar */
 380
 381 /* Varid to actionid mapping */
 382 #define IOV_GVAL(id)            ((id)*2)
 383 #define IOV_SVAL(id)            (((id)*2)+IOV_SET)
 384 #define IOV_ISSET(actionid)     ((actionid & IOV_SET) == IOV_SET)
 385 #define IOV_ID(actionid)        (actionid >> 1)
 386
 387 /* flags are per-driver based on driver attributes */
 388
 389 extern const bcm_iovar_t *bcm_iovar_lookup(const bcm_iovar_t *table, const char *name);
 390 extern int bcm_iovar_lencheck(const bcm_iovar_t *table, void *arg, int len, bool set);
 391 #if defined(WLTINYDUMP) || defined(BCMDBG) || defined(WLMSG_INFORM) || \
 392         defined(WLMSG_ASSOC) || defined(WLMSG_PRPKT) || defined(WLMSG_WSEC)
 393 extern int bcm_format_ssid(char* buf, const uchar ssid[], uint ssid_len);
 394 #endif /* WLTINYDUMP || BCMDBG || WLMSG_INFORM || WLMSG_ASSOC || WLMSG_PRPKT */
 395 #endif  /* BCMDRIVER */
 396
 397 /* Base type definitions */
 398 #define IOVT_VOID       0       /* no value (implictly set only) */
 399 #define IOVT_BOOL       1       /* any value ok (zero/nonzero) */
 400 #define IOVT_INT8       2       /* integer values are range-checked */
 401 #define IOVT_UINT8      3       /* unsigned int 8 bits */
 402 #define IOVT_INT16      4       /* int 16 bits */
 403 #define IOVT_UINT16     5       /* unsigned int 16 bits */
 404 #define IOVT_INT32      6       /* int 32 bits */
 405 #define IOVT_UINT32     7       /* unsigned int 32 bits */
 406 #define IOVT_BUFFER     8       /* buffer is size-checked as per minlen */
 407 #define BCM_IOVT_VALID(type) (((unsigned int)(type)) <= IOVT_BUFFER)
 408
 409 /* Initializer for IOV type strings */
 410 #define BCM_IOV_TYPE_INIT { \
 411         "void", \
 412         "bool", \
 413         "int8", \
 414         "uint8", \
 415         "int16", \
 416         "uint16", \
 417         "int32", \
 418         "uint32", \
 419         "buffer", \
 420         "" }
 421
 422 #define BCM_IOVT_IS_INT(type) (\
 423         (type == IOVT_BOOL) || \
 424         (type == IOVT_INT8) || \
 425         (type == IOVT_UINT8) || \
 426         (type == IOVT_INT16) || \
 427         (type == IOVT_UINT16) || \
 428         (type == IOVT_INT32) || \
 429         (type == IOVT_UINT32))
 430
 431 /* ** driver/apps-shared section ** */
 432
 433 #define BCME_STRLEN             64      /* Max string length for BCM errors */
 434 #define VALID_BCMERROR(e)  ((e <= 0) && (e >= BCME_LAST))
 435
 436
 437 /*
 438  * error codes could be added but the defined ones shouldn't be changed/deleted
 439  * these error codes are exposed to the user code
 440  * when ever a new error code is added to this list
 441  * please update errorstring table with the related error string and
 442  * update osl files with os specific errorcode map
 443 */
 444
 445 #define BCME_OK                         0       /* Success */
 446 #define BCME_ERROR                      -1      /* Error generic */
 447 #define BCME_BADARG                     -2      /* Bad Argument */
 448 #define BCME_BADOPTION                  -3      /* Bad option */
 449 #define BCME_NOTUP                      -4      /* Not up */
 450 #define BCME_NOTDOWN                    -5      /* Not down */
 451 #define BCME_NOTAP                      -6      /* Not AP */
 452 #define BCME_NOTSTA                     -7      /* Not STA  */
 453 #define BCME_BADKEYIDX                  -8      /* BAD Key Index */
 454 #define BCME_RADIOOFF                   -9      /* Radio Off */
 455 #define BCME_NOTBANDLOCKED              -10     /* Not  band locked */
 456 #define BCME_NOCLK                      -11     /* No Clock */
 457 #define BCME_BADRATESET                 -12     /* BAD Rate valueset */
 458 #define BCME_BADBAND                    -13     /* BAD Band */
 459 #define BCME_BUFTOOSHORT                -14     /* Buffer too short */
 460 #define BCME_BUFTOOLONG                 -15     /* Buffer too long */
 461 #define BCME_BUSY                       -16     /* Busy */
 462 #define BCME_NOTASSOCIATED              -17     /* Not Associated */
 463 #define BCME_BADSSIDLEN                 -18     /* Bad SSID len */
 464 #define BCME_OUTOFRANGECHAN             -19     /* Out of Range Channel */
 465 #define BCME_BADCHAN                    -20     /* Bad Channel */
 466 #define BCME_BADADDR                    -21     /* Bad Address */
 467 #define BCME_NORESOURCE                 -22     /* Not Enough Resources */
 468 #define BCME_UNSUPPORTED                -23     /* Unsupported */
 469 #define BCME_BADLEN                     -24     /* Bad length */
 470 #define BCME_NOTREADY                   -25     /* Not Ready */
 471 #define BCME_EPERM                      -26     /* Not Permitted */
 472 #define BCME_NOMEM                      -27     /* No Memory */
 473 #define BCME_ASSOCIATED                 -28     /* Associated */
 474 #define BCME_RANGE                      -29     /* Not In Range */
 475 #define BCME_NOTFOUND                   -30     /* Not Found */
 476 #define BCME_WME_NOT_ENABLED            -31     /* WME Not Enabled */
 477 #define BCME_TSPEC_NOTFOUND             -32     /* TSPEC Not Found */
 478 #define BCME_ACM_NOTSUPPORTED           -33     /* ACM Not Supported */
 479 #define BCME_NOT_WME_ASSOCIATION        -34     /* Not WME Association */
 480 #define BCME_SDIO_ERROR                 -35     /* SDIO Bus Error */
 481 #define BCME_DONGLE_DOWN                -36     /* Dongle Not Accessible */
 482 #define BCME_VERSION                    -37     /* Incorrect version */
 483 #define BCME_TXFAIL                     -38     /* TX failure */
 484 #define BCME_RXFAIL                     -39     /* RX failure */
 485 #define BCME_NODEVICE                   -40     /* Device not present */
 486 #define BCME_NMODE_DISABLED             -41     /* NMODE disabled */
 487 #define BCME_NONRESIDENT                -42 /* access to nonresident overlay */
 488 #define BCME_LAST                       BCME_NONRESIDENT
 489
 490 /* These are collection of BCME Error strings */
 491 #define BCMERRSTRINGTABLE {             \
 492         "OK",                           \
 493         "Undefined error",              \
 494         "Bad Argument",                 \
 495         "Bad Option",                   \
 496         "Not up",                       \
 497         "Not down",                     \
 498         "Not AP",                       \
 499         "Not STA",                      \
 500         "Bad Key Index",                \
 501         "Radio Off",                    \
 502         "Not band locked",              \
 503         "No clock",                     \
 504         "Bad Rate valueset",            \
 505         "Bad Band",                     \
 506         "Buffer too short",             \
 507         "Buffer too long",              \
 508         "Busy",                         \
 509         "Not Associated",               \
 510         "Bad SSID len",                 \
 511         "Out of Range Channel",         \
 512         "Bad Channel",                  \
 513         "Bad Address",                  \
 514         "Not Enough Resources",         \
 515         "Unsupported",                  \
 516         "Bad length",                   \
 517         "Not Ready",                    \
 518         "Not Permitted",                \
 519         "No Memory",                    \
 520         "Associated",                   \
 521         "Not In Range",                 \
 522         "Not Found",                    \
 523         "WME Not Enabled",              \
 524         "TSPEC Not Found",              \
 525         "ACM Not Supported",            \
 526         "Not WME Association",          \
 527         "SDIO Bus Error",               \
 528         "Dongle Not Accessible",        \
 529         "Incorrect version",            \
 530         "TX Failure",                   \
 531         "RX Failure",                   \
 532         "Device Not Present",           \
 533         "NMODE Disabled",               \
 534         "Nonresident overlay access", \
 535 }
 536
 537 #ifndef ABS
 538 #define ABS(a)                  (((a) < 0)?-(a):(a))
 539 #endif /* ABS */
 540
 541 #ifndef MIN
 542 #define MIN(a, b)               (((a) < (b))?(a):(b))
 543 #endif /* MIN */
 544
 545 #ifndef MAX
 546 #define MAX(a, b)               (((a) > (b))?(a):(b))
 547 #endif /* MAX */
 548
 549 #define CEIL(x, y)              (((x) + ((y)-1)) / (y))
 550 #define ROUNDUP(x, y)           ((((x)+((y)-1))/(y))*(y))
 551 #define ISALIGNED(a, x)         (((a) & ((x)-1)) == 0)
 552 #define ALIGN_ADDR(addr, boundary) (void *)(((uintptr)(addr) + (boundary) - 1) \
 553                                                  & ~((boundary) - 1))
 554 #define ISPOWEROF2(x)           ((((x)-1)&(x)) == 0)
 555 #define VALID_MASK(mask)        !((mask) & ((mask) + 1))
 556 #ifndef OFFSETOF
 557 #define OFFSETOF(type, member)  ((uint)(uintptr)&((type *)0)->member)
 558 #endif /* OFFSETOF */
 559 #ifndef ARRAYSIZE
 560 #define ARRAYSIZE(a)            (sizeof(a)/sizeof(a[0]))
 561 #endif
 562
 563 /* bit map related macros */
 564 #ifndef setbit
 565 #ifndef NBBY                /* the BSD family defines NBBY */
 566 #define NBBY    8       /* 8 bits per byte */
 567 #endif /* #ifndef NBBY */
 568 #define setbit(a, i)    (((uint8 *)a)[(i)/NBBY] |= 1<<((i)%NBBY))
 569 #define clrbit(a, i)    (((uint8 *)a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))
 570 #define isset(a, i)     (((const uint8 *)a)[(i)/NBBY] & (1<<((i)%NBBY)))
 571 #define isclr(a, i)     ((((const uint8 *)a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
 572 #endif /* setbit */
 573
 574 #define NBITS(type)     (sizeof(type) * 8)
 575 #define NBITVAL(nbits)  (1 << (nbits))
 576 #define MAXBITVAL(nbits)        ((1 << (nbits)) - 1)
 577 #define NBITMASK(nbits) MAXBITVAL(nbits)
 578 #define MAXNBVAL(nbyte) MAXBITVAL((nbyte) * 8)
 579
 580 /* basic mux operation - can be optimized on several architectures */
 581 #define MUX(pred, true, false) ((pred) ? (true) : (false))
 582
 583 /* modulo inc/dec - assumes x E [0, bound - 1] */
 584 #define MODDEC(x, bound) MUX((x) == 0, (bound) - 1, (x) - 1)
 585 #define MODINC(x, bound) MUX((x) == (bound) - 1, 0, (x) + 1)
 586
 587 /* modulo inc/dec, bound = 2^k */
 588 #define MODDEC_POW2(x, bound) (((x) - 1) & ((bound) - 1))
 589 #define MODINC_POW2(x, bound) (((x) + 1) & ((bound) - 1))
 590
 591 /* modulo add/sub - assumes x, y E [0, bound - 1] */
 592 #define MODADD(x, y, bound) \
 593     MUX((x) + (y) >= (bound), (x) + (y) - (bound), (x) + (y))
 594 #define MODSUB(x, y, bound) \
 595     MUX(((int)(x)) - ((int)(y)) < 0, (x) - (y) + (bound), (x) - (y))
 596
 597 /* module add/sub, bound = 2^k */
 598 #define MODADD_POW2(x, y, bound) (((x) + (y)) & ((bound) - 1))
 599 #define MODSUB_POW2(x, y, bound) (((x) - (y)) & ((bound) - 1))
 600
 601 /* crc defines */
 602 #define CRC8_INIT_VALUE  0xff           /* Initial CRC8 checksum value */
 603 #define CRC8_GOOD_VALUE  0x9f           /* Good final CRC8 checksum value */
 604 #define CRC16_INIT_VALUE 0xffff         /* Initial CRC16 checksum value */
 605 #define CRC16_GOOD_VALUE 0xf0b8         /* Good final CRC16 checksum value */
 606 #define CRC32_INIT_VALUE 0xffffffff     /* Initial CRC32 checksum value */
 607 #define CRC32_GOOD_VALUE 0xdebb20e3     /* Good final CRC32 checksum value */
 608
 609 /* bcm_format_flags() bit description structure */
 610 typedef struct bcm_bit_desc {
 611         uint32  bit;
 612         const char* name;
 613 } bcm_bit_desc_t;
 614
 615 /* tag_ID/length/value_buffer tuple */
 616 typedef struct bcm_tlv {
 617         uint8   id;
 618         uint8   len;
 619         uint8   data[1];
 620 } bcm_tlv_t;
 621
 622 /* Check that bcm_tlv_t fits into the given buflen */
 623 #define bcm_valid_tlv(elt, buflen) ((buflen) >= 2 && (int)(buflen) >= (int)(2 + (elt)->len))
 624
 625 /* buffer length for ethernet address from bcm_ether_ntoa() */
 626 #define ETHER_ADDR_STR_LEN      18      /* 18-bytes of Ethernet address buffer length */
 627
 628 /* crypto utility function */
 629 /* 128-bit xor: *dst = *src1 xor *src2. dst1, src1 and src2 may have any alignment */
 630 static INLINE void
 631 xor_128bit_block(const uint8 *src1, const uint8 *src2, uint8 *dst)
 632 {
 633         if (
 634 #ifdef __i386__
 635             1 ||
 636 #endif
 637             (((uintptr)src1 | (uintptr)src2 | (uintptr)dst) & 3) == 0) {
 638                 /* ARM CM3 rel time: 1229 (727 if alignment check could be omitted) */
 639                 /* x86 supports unaligned.  This version runs 6x-9x faster on x86. */
 640                 ((uint32 *)dst)[0] = ((const uint32 *)src1)[0] ^ ((const uint32 *)src2)[0];
 641                 ((uint32 *)dst)[1] = ((const uint32 *)src1)[1] ^ ((const uint32 *)src2)[1];
 642                 ((uint32 *)dst)[2] = ((const uint32 *)src1)[2] ^ ((const uint32 *)src2)[2];
 643                 ((uint32 *)dst)[3] = ((const uint32 *)src1)[3] ^ ((const uint32 *)src2)[3];
 644         } else {
 645                 /* ARM CM3 rel time: 4668 (4191 if alignment check could be omitted) */
 646                 int k;
 647                 for (k = 0; k < 16; k++)
 648                         dst[k] = src1[k] ^ src2[k];
 649         }
 650 }
 651
 652 /* externs */
 653 /* crc */
 654 extern uint8 BCMROMFN(hndcrc8)(uint8 *p, uint nbytes, uint8 crc);
 655 extern uint16 BCMROMFN(hndcrc16)(uint8 *p, uint nbytes, uint16 crc);
 656 extern uint32 BCMROMFN(hndcrc32)(uint8 *p, uint nbytes, uint32 crc);
 657 /* format/print */
 658 #if defined(BCMDBG) || defined(DHD_DEBUG) || defined(BCMDBG_ERR) || \
 659         defined(WLMSG_PRHDRS) || defined(WLMSG_PRPKT) || defined(WLMSG_ASSOC) || \
 660         defined(BCMDBG_DUMP)
 661 extern int bcm_format_flags(const bcm_bit_desc_t *bd, uint32 flags, char* buf, int len);
 662 extern int bcm_format_hex(char *str, const void *bytes, int len);
 663 #endif
 664 #ifdef BCMDBG
 665 extern void deadbeef(void *p, uint len);
 666 #endif
 667 extern const char *bcm_crypto_algo_name(uint algo);
 668 extern char *bcm_chipname(uint chipid, char *buf, uint len);
 669 extern char *bcm_brev_str(uint32 brev, char *buf);
 670 extern void printbig(char *buf);
 671 extern void prhex(const char *msg, uchar *buf, uint len);
 672
 673 /* IE parsing */
 674 extern bcm_tlv_t *BCMROMFN(bcm_next_tlv)(bcm_tlv_t *elt, int *buflen);
 675 extern bcm_tlv_t *BCMROMFN(bcm_parse_tlvs)(void *buf, int buflen, uint key);
 676 extern bcm_tlv_t *BCMROMFN(bcm_parse_ordered_tlvs)(void *buf, int buflen, uint key);
 677
 678 /* bcmerror */
 679 extern const char *bcmerrorstr(int bcmerror);
 680
 681 /* multi-bool data type: set of bools, mbool is true if any is set */
 682 typedef uint32 mbool;
 683 #define mboolset(mb, bit)               ((mb) |= (bit))         /* set one bool */
 684 #define mboolclr(mb, bit)               ((mb) &= ~(bit))        /* clear one bool */
 685 #define mboolisset(mb, bit)             (((mb) & (bit)) != 0)   /* TRUE if one bool is set */
 686 #define mboolmaskset(mb, mask, val)     ((mb) = (((mb) & ~(mask)) | (val)))
 687
 688 /* power conversion */
 689 extern uint16 BCMROMFN(bcm_qdbm_to_mw)(uint8 qdbm);
 690 extern uint8 BCMROMFN(bcm_mw_to_qdbm)(uint16 mw);
 691
 692 /* generic datastruct to help dump routines */
 693 struct fielddesc {
 694         const char *nameandfmt;
 695         uint32  offset;
 696         uint32  len;
 697 };
 698
 699 extern void bcm_binit(struct bcmstrbuf *b, char *buf, uint size);
 700 extern int bcm_bprintf(struct bcmstrbuf *b, const char *fmt, ...);
 701 extern void bcm_bprhex(struct bcmstrbuf *b, const char *msg, bool newline, uint8 *buf, int len);
 702
 703 extern void bcm_inc_bytes(uchar *num, int num_bytes, uint8 amount);
 704 extern int bcm_cmp_bytes(uchar *arg1, uchar *arg2, uint8 nbytes);
 705 extern void bcm_print_bytes(char *name, const uchar *cdata, int len);
 706
 707 typedef  uint32 (*bcmutl_rdreg_rtn)(void *arg0, uint arg1, uint32 offset);
 708 extern uint bcmdumpfields(bcmutl_rdreg_rtn func_ptr, void *arg0, uint arg1, struct fielddesc *str,
 709                           char *buf, uint32 bufsize);
 710
 711 extern uint bcm_mkiovar(char *name, char *data, uint datalen, char *buf, uint len);
 712 extern uint BCMROMFN(bcm_bitcount)(uint8 *bitmap, uint bytelength);
 713
 714 #ifdef BCMDBG_PKT      /* pkt logging for debugging */
 715 #define PKTLIST_SIZE 3000
 716
 717 #ifdef BCMDBG_PTRACE
 718 #define PKTTRACE_MAX_BYTES      12
 719 #define PKTTRACE_MAX_BITS       (PKTTRACE_MAX_BYTES * NBBY)
 720
 721 enum pkttrace_info {
 722         PKTLIST_PRECQ,          /* Pkt in Prec Q */
 723         PKTLIST_FAIL_PRECQ,     /* Pkt failed to Q in PRECQ */
 724         PKTLIST_DMAQ,           /* Pkt in DMA Q */
 725         PKTLIST_MI_TFS_RCVD,    /* Received TX status */
 726         PKTLIST_TXDONE,         /* Pkt TX done */
 727         PKTLIST_TXFAIL,         /* Pkt TX failed */
 728         PKTLIST_PKTFREE         /* pkt is freed */
 729 };
 730 #endif /* BCMDBG_PTRACE */
 731
 732 typedef struct pkt_dbginfo {
 733         int     line;
 734         char    *file;
 735         void    *pkt;
 736 #ifdef BCMDBG_PTRACE
 737         char    pkt_trace[PKTTRACE_MAX_BYTES];
 738 #endif /* BCMDBG_PTRACE */
 739 } pkt_dbginfo_t;
 740
 741 typedef struct {
 742         pkt_dbginfo_t list[PKTLIST_SIZE]; /* List of pointers to packets */
 743         uint16 count; /* Total count of the packets */
 744 } pktlist_info_t;
 745
 746
 747 extern void pktlist_add(pktlist_info_t *pktlist, void *p, int len, char *file);
 748 extern void pktlist_remove(pktlist_info_t *pktlist, void *p);
 749 extern char* pktlist_dump(pktlist_info_t *pktlist, char *buf);
 750 #ifdef BCMDBG_PTRACE
 751 extern void pktlist_trace(pktlist_info_t *pktlist, void *pkt, uint16 bit);
 752 #endif /* BCMDBG_PTRACE */
 753 #endif  /* BCMDBG_PKT */
 754
 755 #ifdef __cplusplus
 756         }
 757 #endif
 758
 759 #endif  /* _bcmutils_h_ */