drivers/net/wireless/rkwifi/bcmdhd/include/bcmutils.h

   1 /*
   2  * Misc useful os-independent macros and functions.
   3  *
   4  * $Copyright Open Broadcom Corporation$
   5  *
   6  * $Id: bcmutils.h 412804 2013-07-16 16:26:39Z $
   7  */
   8
   9 #ifndef _bcmutils_h_
  10 #define _bcmutils_h_
  11
  12 #define bcm_strcpy_s(dst, noOfElements, src)            strcpy((dst), (src))
  13 #define bcm_strncpy_s(dst, noOfElements, src, count)    strncpy((dst), (src), (count))
  14 #define bcm_strcat_s(dst, noOfElements, src)            strcat((dst), (src))
  15
  16 #ifdef __cplusplus
  17 extern "C" {
  18 #endif
  19
  20 #ifdef PKTQ_LOG
  21 #include <wlioctl.h>
  22 #endif
  23
  24
  25 #define _BCM_U  0x01
  26 #define _BCM_L  0x02
  27 #define _BCM_D  0x04
  28 #define _BCM_C  0x08
  29 #define _BCM_P  0x10
  30 #define _BCM_S  0x20
  31 #define _BCM_X  0x40
  32 #define _BCM_SP 0x80
  33
  34 extern const unsigned char bcm_ctype[];
  35 #define bcm_ismask(x)   (bcm_ctype[(int)(unsigned char)(x)])
  36
  37 #define bcm_isalnum(c)  ((bcm_ismask(c)&(_BCM_U|_BCM_L|_BCM_D)) != 0)
  38 #define bcm_isalpha(c)  ((bcm_ismask(c)&(_BCM_U|_BCM_L)) != 0)
  39 #define bcm_iscntrl(c)  ((bcm_ismask(c)&(_BCM_C)) != 0)
  40 #define bcm_isdigit(c)  ((bcm_ismask(c)&(_BCM_D)) != 0)
  41 #define bcm_isgraph(c)  ((bcm_ismask(c)&(_BCM_P|_BCM_U|_BCM_L|_BCM_D)) != 0)
  42 #define bcm_islower(c)  ((bcm_ismask(c)&(_BCM_L)) != 0)
  43 #define bcm_isprint(c)  ((bcm_ismask(c)&(_BCM_P|_BCM_U|_BCM_L|_BCM_D|_BCM_SP)) != 0)
  44 #define bcm_ispunct(c)  ((bcm_ismask(c)&(_BCM_P)) != 0)
  45 #define bcm_isspace(c)  ((bcm_ismask(c)&(_BCM_S)) != 0)
  46 #define bcm_isupper(c)  ((bcm_ismask(c)&(_BCM_U)) != 0)
  47 #define bcm_isxdigit(c) ((bcm_ismask(c)&(_BCM_D|_BCM_X)) != 0)
  48 #define bcm_tolower(c)  (bcm_isupper((c)) ? ((c) + 'a' - 'A') : (c))
  49 #define bcm_toupper(c)  (bcm_islower((c)) ? ((c) + 'A' - 'a') : (c))
  50
  51
  52
  53 struct bcmstrbuf {
  54         char *buf;
  55         unsigned int size;
  56         char *origbuf;
  57         unsigned int origsize;
  58 };
  59
  60
  61 #ifdef BCMDRIVER
  62 #include <osl.h>
  63
  64 #define GPIO_PIN_NOTDEFINED     0x20
  65
  66
  67 #define SPINWAIT(exp, us) { \
  68         uint countdown = (us) + 9; \
  69         while ((exp) && (countdown >= 10)) {\
  70                 OSL_DELAY(10); \
  71                 countdown -= 10; \
  72         } \
  73 }
  74
  75
  76 #ifndef PKTQ_LEN_DEFAULT
  77 #define PKTQ_LEN_DEFAULT        128
  78 #endif
  79 #ifndef PKTQ_MAX_PREC
  80 #define PKTQ_MAX_PREC           16
  81 #endif
  82
  83 typedef struct pktq_prec {
  84         void *head;
  85         void *tail;
  86         uint16 len;
  87         uint16 max;
  88 } pktq_prec_t;
  89
  90 #ifdef PKTQ_LOG
  91 typedef struct {
  92         uint32 requested;
  93         uint32 stored;
  94         uint32 saved;
  95         uint32 selfsaved;
  96         uint32 full_dropped;
  97         uint32 dropped;
  98         uint32 sacrificed;
  99         uint32 busy;
 100         uint32 retry;
 101         uint32 ps_retry;
 102         uint32 retry_drop;
 103         uint32 max_avail;
 104         uint32 max_used;
 105         uint32 queue_capacity;
 106         uint32 rtsfail;
 107         uint32 acked;
 108 } pktq_counters_t;
 109 #endif
 110
 111
 112 #define PKTQ_COMMON     \
 113         uint16 num_prec;                                \
 114         uint16 hi_prec;                 \
 115         uint16 max;                                                     \
 116         uint16 len;
 117
 118
 119 struct pktq {
 120         PKTQ_COMMON
 121
 122         struct pktq_prec q[PKTQ_MAX_PREC];
 123 #ifdef PKTQ_LOG
 124         pktq_counters_t _prec_cnt[PKTQ_MAX_PREC];
 125         pktq_counters_t _prec_bytes[PKTQ_MAX_PREC];
 126         uint32 _logtime;
 127 #endif
 128 };
 129
 130
 131 struct spktq {
 132         PKTQ_COMMON
 133
 134         struct pktq_prec q[1];
 135 };
 136
 137 #define PKTQ_PREC_ITER(pq, prec)        for (prec = (pq)->num_prec - 1; prec >= 0; prec--)
 138
 139
 140 typedef bool (*ifpkt_cb_t)(void*, int);
 141
 142 #ifdef BCMPKTPOOL
 143 #define POOL_ENAB(pool)         ((pool) && (pool)->inited)
 144 #define SHARED_POOL             (pktpool_shared)
 145 #else
 146 #define POOL_ENAB(bus)          0
 147 #define SHARED_POOL             ((struct pktpool *)NULL)
 148 #endif
 149
 150 #ifndef PKTPOOL_LEN_MAX
 151 #define PKTPOOL_LEN_MAX         40
 152 #endif
 153 #define PKTPOOL_CB_MAX          3
 154
 155 struct pktpool;
 156 typedef void (*pktpool_cb_t)(struct pktpool *pool, void *arg);
 157 typedef struct {
 158         pktpool_cb_t cb;
 159         void *arg;
 160 } pktpool_cbinfo_t;
 161
 162 #ifdef BCMDBG_POOL
 163
 164 #define POOL_IDLE       0
 165 #define POOL_RXFILL     1
 166 #define POOL_RXDH       2
 167 #define POOL_RXD11      3
 168 #define POOL_TXDH       4
 169 #define POOL_TXD11      5
 170 #define POOL_AMPDU      6
 171 #define POOL_TXENQ      7
 172
 173 typedef struct {
 174         void *p;
 175         uint32 cycles;
 176         uint32 dur;
 177 } pktpool_dbg_t;
 178
 179 typedef struct {
 180         uint8 txdh;
 181         uint8 txd11;
 182         uint8 enq;
 183         uint8 rxdh;
 184         uint8 rxd11;
 185         uint8 rxfill;
 186         uint8 idle;
 187 } pktpool_stats_t;
 188 #endif
 189
 190 typedef struct pktpool {
 191         bool inited;
 192         uint16 r;
 193         uint16 w;
 194         uint16 len;
 195         uint16 maxlen;
 196         uint16 plen;
 197         bool istx;
 198         bool empty;
 199         uint8 cbtoggle;
 200         uint8 cbcnt;
 201         uint8 ecbcnt;
 202         bool emptycb_disable;
 203         pktpool_cbinfo_t *availcb_excl;
 204         pktpool_cbinfo_t cbs[PKTPOOL_CB_MAX];
 205         pktpool_cbinfo_t ecbs[PKTPOOL_CB_MAX];
 206         void *q[PKTPOOL_LEN_MAX + 1];
 207
 208 #ifdef BCMDBG_POOL
 209         uint8 dbg_cbcnt;
 210         pktpool_cbinfo_t dbg_cbs[PKTPOOL_CB_MAX];
 211         uint16 dbg_qlen;
 212         pktpool_dbg_t dbg_q[PKTPOOL_LEN_MAX + 1];
 213 #endif
 214 } pktpool_t;
 215
 216 extern pktpool_t *pktpool_shared;
 217
 218 extern int pktpool_init(osl_t *osh, pktpool_t *pktp, int *pktplen, int plen, bool istx);
 219 extern int pktpool_deinit(osl_t *osh, pktpool_t *pktp);
 220 extern int pktpool_fill(osl_t *osh, pktpool_t *pktp, bool minimal);
 221 extern void* pktpool_get(pktpool_t *pktp);
 222 extern void pktpool_free(pktpool_t *pktp, void *p);
 223 extern int pktpool_add(pktpool_t *pktp, void *p);
 224 extern uint16 pktpool_avail(pktpool_t *pktp);
 225 extern int pktpool_avail_notify_normal(osl_t *osh, pktpool_t *pktp);
 226 extern int pktpool_avail_notify_exclusive(osl_t *osh, pktpool_t *pktp, pktpool_cb_t cb);
 227 extern int pktpool_avail_register(pktpool_t *pktp, pktpool_cb_t cb, void *arg);
 228 extern int pktpool_empty_register(pktpool_t *pktp, pktpool_cb_t cb, void *arg);
 229 extern int pktpool_setmaxlen(pktpool_t *pktp, uint16 maxlen);
 230 extern int pktpool_setmaxlen_strict(osl_t *osh, pktpool_t *pktp, uint16 maxlen);
 231 extern void pktpool_emptycb_disable(pktpool_t *pktp, bool disable);
 232 extern bool pktpool_emptycb_disabled(pktpool_t *pktp);
 233
 234 #define POOLPTR(pp)                     ((pktpool_t *)(pp))
 235 #define pktpool_len(pp)                 (POOLPTR(pp)->len - 1)
 236 #define pktpool_plen(pp)                (POOLPTR(pp)->plen)
 237 #define pktpool_maxlen(pp)              (POOLPTR(pp)->maxlen)
 238
 239 #ifdef BCMDBG_POOL
 240 extern int pktpool_dbg_register(pktpool_t *pktp, pktpool_cb_t cb, void *arg);
 241 extern int pktpool_start_trigger(pktpool_t *pktp, void *p);
 242 extern int pktpool_dbg_dump(pktpool_t *pktp);
 243 extern int pktpool_dbg_notify(pktpool_t *pktp);
 244 extern int pktpool_stats_dump(pktpool_t *pktp, pktpool_stats_t *stats);
 245 #endif
 246
 247
 248
 249 struct ether_addr;
 250
 251 extern int ether_isbcast(const void *ea);
 252 extern int ether_isnulladdr(const void *ea);
 253
 254
 255
 256 #define pktq_psetmax(pq, prec, _max)    ((pq)->q[prec].max = (_max))
 257 #define pktq_pmax(pq, prec)             ((pq)->q[prec].max)
 258 #define pktq_plen(pq, prec)             ((pq)->q[prec].len)
 259 #define pktq_pavail(pq, prec)           ((pq)->q[prec].max - (pq)->q[prec].len)
 260 #define pktq_pfull(pq, prec)            ((pq)->q[prec].len >= (pq)->q[prec].max)
 261 #define pktq_pempty(pq, prec)           ((pq)->q[prec].len == 0)
 262
 263 #define pktq_ppeek(pq, prec)            ((pq)->q[prec].head)
 264 #define pktq_ppeek_tail(pq, prec)       ((pq)->q[prec].tail)
 265
 266 extern void *pktq_penq(struct pktq *pq, int prec, void *p);
 267 extern void *pktq_penq_head(struct pktq *pq, int prec, void *p);
 268 extern void *pktq_pdeq(struct pktq *pq, int prec);
 269 extern void *pktq_pdeq_prev(struct pktq *pq, int prec, void *prev_p);
 270 extern void *pktq_pdeq_with_fn(struct pktq *pq, int prec, ifpkt_cb_t fn, int arg);
 271 extern void *pktq_pdeq_tail(struct pktq *pq, int prec);
 272
 273 extern void pktq_pflush(osl_t *osh, struct pktq *pq, int prec, bool dir,
 274         ifpkt_cb_t fn, int arg);
 275
 276 extern bool pktq_pdel(struct pktq *pq, void *p, int prec);
 277
 278
 279
 280 extern int pktq_mlen(struct pktq *pq, uint prec_bmp);
 281 extern void *pktq_mdeq(struct pktq *pq, uint prec_bmp, int *prec_out);
 282 extern void *pktq_mpeek(struct pktq *pq, uint prec_bmp, int *prec_out);
 283
 284
 285
 286 #define pktq_len(pq)            ((int)(pq)->len)
 287 #define pktq_max(pq)            ((int)(pq)->max)
 288 #define pktq_avail(pq)          ((int)((pq)->max - (pq)->len))
 289 #define pktq_full(pq)           ((pq)->len >= (pq)->max)
 290 #define pktq_empty(pq)          ((pq)->len == 0)
 291
 292
 293 #define pktenq(pq, p)           pktq_penq(((struct pktq *)(void *)pq), 0, (p))
 294 #define pktenq_head(pq, p)      pktq_penq_head(((struct pktq *)(void *)pq), 0, (p))
 295 #define pktdeq(pq)              pktq_pdeq(((struct pktq *)(void *)pq), 0)
 296 #define pktdeq_tail(pq)         pktq_pdeq_tail(((struct pktq *)(void *)pq), 0)
 297 #define pktqinit(pq, len)       pktq_init(((struct pktq *)(void *)pq), 1, len)
 298
 299 extern void pktq_init(struct pktq *pq, int num_prec, int max_len);
 300 extern void pktq_set_max_plen(struct pktq *pq, int prec, int max_len);
 301
 302
 303 extern void *pktq_deq(struct pktq *pq, int *prec_out);
 304 extern void *pktq_deq_tail(struct pktq *pq, int *prec_out);
 305 extern void *pktq_peek(struct pktq *pq, int *prec_out);
 306 extern void *pktq_peek_tail(struct pktq *pq, int *prec_out);
 307 extern void pktq_flush(osl_t *osh, struct pktq *pq, bool dir, ifpkt_cb_t fn, int arg);
 308
 309
 310
 311 extern uint pktcopy(osl_t *osh, void *p, uint offset, int len, uchar *buf);
 312 extern uint pktfrombuf(osl_t *osh, void *p, uint offset, int len, uchar *buf);
 313 extern uint pkttotlen(osl_t *osh, void *p);
 314 extern void *pktlast(osl_t *osh, void *p);
 315 extern uint pktsegcnt(osl_t *osh, void *p);
 316 extern uint pktsegcnt_war(osl_t *osh, void *p);
 317 extern uint8 *pktdataoffset(osl_t *osh, void *p,  uint offset);
 318 extern void *pktoffset(osl_t *osh, void *p,  uint offset);
 319
 320
 321 #define PKTPRIO_VDSCP   0x100
 322 #define PKTPRIO_VLAN    0x200
 323 #define PKTPRIO_UPD     0x400
 324 #define PKTPRIO_DSCP    0x800
 325
 326
 327
 328 #define DSCP_AF11       0x0A
 329 #define DSCP_AF12       0x0C
 330 #define DSCP_AF13       0x0E
 331
 332 #define DSCP_AF21       0x12
 333 #define DSCP_AF22       0x14
 334 #define DSCP_AF23       0x16
 335
 336 #define DSCP_AF31       0x1A
 337 #define DSCP_AF32       0x1C
 338 #define DSCP_AF33       0x1E
 339
 340 #define DSCP_EF         0x2E
 341
 342 extern uint pktsetprio(void *pkt, bool update_vtag);
 343
 344
 345 extern int bcm_atoi(const char *s);
 346 extern ulong bcm_strtoul(const char *cp, char **endp, uint base);
 347 extern char *bcmstrstr(const char *haystack, const char *needle);
 348 extern char *bcmstrcat(char *dest, const char *src);
 349 extern char *bcmstrncat(char *dest, const char *src, uint size);
 350 extern ulong wchar2ascii(char *abuf, ushort *wbuf, ushort wbuflen, ulong abuflen);
 351 char* bcmstrtok(char **string, const char *delimiters, char *tokdelim);
 352 int bcmstricmp(const char *s1, const char *s2);
 353 int bcmstrnicmp(const char* s1, const char* s2, int cnt);
 354
 355
 356
 357 extern char *bcm_ether_ntoa(const struct ether_addr *ea, char *buf);
 358 extern int bcm_ether_atoe(const char *p, struct ether_addr *ea);
 359
 360
 361 struct ipv4_addr;
 362 extern char *bcm_ip_ntoa(struct ipv4_addr *ia, char *buf);
 363
 364
 365 extern void bcm_mdelay(uint ms);
 366
 367 #define NVRAM_RECLAIM_CHECK(name)
 368
 369 extern char *getvar(char *vars, const char *name);
 370 extern int getintvar(char *vars, const char *name);
 371 extern int getintvararray(char *vars, const char *name, int index);
 372 extern int getintvararraysize(char *vars, const char *name);
 373 extern uint getgpiopin(char *vars, char *pin_name, uint def_pin);
 374 #define bcm_perf_enable()
 375 #define bcmstats(fmt)
 376 #define bcmlog(fmt, a1, a2)
 377 #define bcmdumplog(buf, size)   *buf = '\0'
 378 #define bcmdumplogent(buf, idx) -1
 379
 380 #define bcmtslog(tstamp, fmt, a1, a2)
 381 #define bcmprinttslogs()
 382 #define bcmprinttstamp(us)
 383 #define bcmdumptslog(buf, size)
 384
 385 extern char *bcm_nvram_vars(uint *length);
 386 extern int bcm_nvram_cache(void *sih);
 387
 388
 389
 390
 391 typedef struct bcm_iovar {
 392         const char *name;
 393         uint16 varid;
 394         uint16 flags;
 395         uint16 type;
 396         uint16 minlen;
 397 } bcm_iovar_t;
 398
 399
 400
 401
 402 #define IOV_GET 0
 403 #define IOV_SET 1
 404
 405
 406 #define IOV_GVAL(id)            ((id) * 2)
 407 #define IOV_SVAL(id)            ((id) * 2 + IOV_SET)
 408 #define IOV_ISSET(actionid)     ((actionid & IOV_SET) == IOV_SET)
 409 #define IOV_ID(actionid)        (actionid >> 1)
 410
 411
 412
 413 extern const bcm_iovar_t *bcm_iovar_lookup(const bcm_iovar_t *table, const char *name);
 414 extern int bcm_iovar_lencheck(const bcm_iovar_t *table, void *arg, int len, bool set);
 415 #if defined(WLTINYDUMP) || defined(WLMSG_INFORM) || defined(WLMSG_ASSOC) || \
 416         defined(WLMSG_PRPKT) || defined(WLMSG_WSEC)
 417 extern int bcm_format_ssid(char* buf, const uchar ssid[], uint ssid_len);
 418 #endif
 419 #endif
 420
 421
 422 #define IOVT_VOID       0
 423 #define IOVT_BOOL       1
 424 #define IOVT_INT8       2
 425 #define IOVT_UINT8      3
 426 #define IOVT_INT16      4
 427 #define IOVT_UINT16     5
 428 #define IOVT_INT32      6
 429 #define IOVT_UINT32     7
 430 #define IOVT_BUFFER     8
 431 #define BCM_IOVT_VALID(type) (((unsigned int)(type)) <= IOVT_BUFFER)
 432
 433
 434 #define BCM_IOV_TYPE_INIT { \
 435         "void", \
 436         "bool", \
 437         "int8", \
 438         "uint8", \
 439         "int16", \
 440         "uint16", \
 441         "int32", \
 442         "uint32", \
 443         "buffer", \
 444         "" }
 445
 446 #define BCM_IOVT_IS_INT(type) (\
 447         (type == IOVT_BOOL) || \
 448         (type == IOVT_INT8) || \
 449         (type == IOVT_UINT8) || \
 450         (type == IOVT_INT16) || \
 451         (type == IOVT_UINT16) || \
 452         (type == IOVT_INT32) || \
 453         (type == IOVT_UINT32))
 454
 455
 456
 457 #define BCME_STRLEN             64
 458 #define VALID_BCMERROR(e)  ((e <= 0) && (e >= BCME_LAST))
 459
 460
 461
 462
 463 #define BCME_OK                         0
 464 #define BCME_ERROR                      -1
 465 #define BCME_BADARG                     -2
 466 #define BCME_BADOPTION                  -3
 467 #define BCME_NOTUP                      -4
 468 #define BCME_NOTDOWN                    -5
 469 #define BCME_NOTAP                      -6
 470 #define BCME_NOTSTA                     -7
 471 #define BCME_BADKEYIDX                  -8
 472 #define BCME_RADIOOFF                   -9
 473 #define BCME_NOTBANDLOCKED              -10
 474 #define BCME_NOCLK                      -11
 475 #define BCME_BADRATESET                 -12
 476 #define BCME_BADBAND                    -13
 477 #define BCME_BUFTOOSHORT                -14
 478 #define BCME_BUFTOOLONG                 -15
 479 #define BCME_BUSY                       -16
 480 #define BCME_NOTASSOCIATED              -17
 481 #define BCME_BADSSIDLEN                 -18
 482 #define BCME_OUTOFRANGECHAN             -19
 483 #define BCME_BADCHAN                    -20
 484 #define BCME_BADADDR                    -21
 485 #define BCME_NORESOURCE                 -22
 486 #define BCME_UNSUPPORTED                -23
 487 #define BCME_BADLEN                     -24
 488 #define BCME_NOTREADY                   -25
 489 #define BCME_EPERM                      -26
 490 #define BCME_NOMEM                      -27
 491 #define BCME_ASSOCIATED                 -28
 492 #define BCME_RANGE                      -29
 493 #define BCME_NOTFOUND                   -30
 494 #define BCME_WME_NOT_ENABLED            -31
 495 #define BCME_TSPEC_NOTFOUND             -32
 496 #define BCME_ACM_NOTSUPPORTED           -33
 497 #define BCME_NOT_WME_ASSOCIATION        -34
 498 #define BCME_SDIO_ERROR                 -35
 499 #define BCME_DONGLE_DOWN                -36
 500 #define BCME_VERSION                    -37
 501 #define BCME_TXFAIL                     -38
 502 #define BCME_RXFAIL                     -39
 503 #define BCME_NODEVICE                   -40
 504 #define BCME_NMODE_DISABLED             -41
 505 #define BCME_NONRESIDENT                -42
 506 #define BCME_SCANREJECT                 -43
 507 #define BCME_USAGE_ERROR                -44
 508 #define BCME_IOCTL_ERROR                -45
 509 #define BCME_SERIAL_PORT_ERR            -46
 510 #define BCME_LAST                       BCME_SERIAL_PORT_ERR
 511
 512
 513 #define BCMERRSTRINGTABLE {             \
 514         "OK",                           \
 515         "Undefined error",              \
 516         "Bad Argument",                 \
 517         "Bad Option",                   \
 518         "Not up",                       \
 519         "Not down",                     \
 520         "Not AP",                       \
 521         "Not STA",                      \
 522         "Bad Key Index",                \
 523         "Radio Off",                    \
 524         "Not band locked",              \
 525         "No clock",                     \
 526         "Bad Rate valueset",            \
 527         "Bad Band",                     \
 528         "Buffer too short",             \
 529         "Buffer too long",              \
 530         "Busy",                         \
 531         "Not Associated",               \
 532         "Bad SSID len",                 \
 533         "Out of Range Channel",         \
 534         "Bad Channel",                  \
 535         "Bad Address",                  \
 536         "Not Enough Resources",         \
 537         "Unsupported",                  \
 538         "Bad length",                   \
 539         "Not Ready",                    \
 540         "Not Permitted",                \
 541         "No Memory",                    \
 542         "Associated",                   \
 543         "Not In Range",                 \
 544         "Not Found",                    \
 545         "WME Not Enabled",              \
 546         "TSPEC Not Found",              \
 547         "ACM Not Supported",            \
 548         "Not WME Association",          \
 549         "SDIO Bus Error",               \
 550         "Dongle Not Accessible",        \
 551         "Incorrect version",            \
 552         "TX Failure",                   \
 553         "RX Failure",                   \
 554         "Device Not Present",           \
 555         "NMODE Disabled",               \
 556         "Nonresident overlay access", \
 557         "Scan Rejected",                \
 558         "WLCMD usage error",            \
 559         "WLCMD ioctl error",            \
 560         "RWL serial port error",        \
 561 }
 562
 563 #ifndef ABS
 564 #define ABS(a)                  (((a) < 0) ? -(a) : (a))
 565 #endif
 566
 567 #ifndef MIN
 568 #define MIN(a, b)               (((a) < (b)) ? (a) : (b))
 569 #endif
 570
 571 #ifndef MAX
 572 #define MAX(a, b)               (((a) > (b)) ? (a) : (b))
 573 #endif
 574
 575
 576 #ifndef LIMIT_TO_RANGE
 577 #define LIMIT_TO_RANGE(x, min, max) \
 578         ((x) < (min) ? (min) : ((x) > (max) ? (max) : (x)))
 579 #endif
 580
 581
 582 #ifndef LIMIT_TO_MAX
 583 #define LIMIT_TO_MAX(x, max) \
 584         (((x) > (max) ? (max) : (x)))
 585 #endif
 586
 587
 588 #ifndef LIMIT_TO_MIN
 589 #define LIMIT_TO_MIN(x, min) \
 590         (((x) < (min) ? (min) : (x)))
 591 #endif
 592
 593 #define CEIL(x, y)              (((x) + ((y) - 1)) / (y))
 594 #define ROUNDUP(x, y)           ((((x) + ((y) - 1)) / (y)) * (y))
 595 #define ISALIGNED(a, x)         (((uintptr)(a) & ((x) - 1)) == 0)
 596 #define ALIGN_ADDR(addr, boundary) (void *)(((uintptr)(addr) + (boundary) - 1) \
 597                                                  & ~((boundary) - 1))
 598 #define ALIGN_SIZE(size, boundary) (((size) + (boundary) - 1) \
 599                                                  & ~((boundary) - 1))
 600 #define ISPOWEROF2(x)           ((((x) - 1) & (x)) == 0)
 601 #define VALID_MASK(mask)        !((mask) & ((mask) + 1))
 602
 603 #ifndef OFFSETOF
 604 #ifdef __ARMCC_VERSION
 605
 606 #include <stddef.h>
 607 #define OFFSETOF(type, member)  offsetof(type, member)
 608 #else
 609 #define OFFSETOF(type, member)  ((uint)(uintptr)&((type *)0)->member)
 610 #endif
 611 #endif
 612
 613 #ifndef ARRAYSIZE
 614 #define ARRAYSIZE(a)            (sizeof(a) / sizeof(a[0]))
 615 #endif
 616
 617 #ifndef ARRAYLAST
 618 #define ARRAYLAST(a)            (&a[ARRAYSIZE(a)-1])
 619 #endif
 620
 621
 622 extern void *_bcmutils_dummy_fn;
 623 #define REFERENCE_FUNCTION(f)   (_bcmutils_dummy_fn = (void *)(f))
 624
 625
 626 #ifndef setbit
 627 #ifndef NBBY
 628 #define NBBY    8
 629 #endif
 630 #ifdef BCMUTILS_BIT_MACROS_USE_FUNCS
 631 extern void setbit(void *array, uint bit);
 632 extern void clrbit(void *array, uint bit);
 633 extern bool isset(const void *array, uint bit);
 634 extern bool isclr(const void *array, uint bit);
 635 #else
 636 #define setbit(a, i)    (((uint8 *)a)[(i) / NBBY] |= 1 << ((i) % NBBY))
 637 #define clrbit(a, i)    (((uint8 *)a)[(i) / NBBY] &= ~(1 << ((i) % NBBY)))
 638 #define isset(a, i)     (((const uint8 *)a)[(i) / NBBY] & (1 << ((i) % NBBY)))
 639 #define isclr(a, i)     ((((const uint8 *)a)[(i) / NBBY] & (1 << ((i) % NBBY))) == 0)
 640 #endif
 641 #endif
 642
 643 #define isbitset(a, i)  (((a) & (1 << (i))) != 0)
 644
 645 #define NBITS(type)     (sizeof(type) * 8)
 646 #define NBITVAL(nbits)  (1 << (nbits))
 647 #define MAXBITVAL(nbits)        ((1 << (nbits)) - 1)
 648 #define NBITMASK(nbits) MAXBITVAL(nbits)
 649 #define MAXNBVAL(nbyte) MAXBITVAL((nbyte) * 8)
 650
 651
 652 #define MUX(pred, true, false) ((pred) ? (true) : (false))
 653
 654
 655 #define MODDEC(x, bound) MUX((x) == 0, (bound) - 1, (x) - 1)
 656 #define MODINC(x, bound) MUX((x) == (bound) - 1, 0, (x) + 1)
 657
 658
 659 #define MODDEC_POW2(x, bound) (((x) - 1) & ((bound) - 1))
 660 #define MODINC_POW2(x, bound) (((x) + 1) & ((bound) - 1))
 661
 662
 663 #define MODADD(x, y, bound) \
 664     MUX((x) + (y) >= (bound), (x) + (y) - (bound), (x) + (y))
 665 #define MODSUB(x, y, bound) \
 666     MUX(((int)(x)) - ((int)(y)) < 0, (x) - (y) + (bound), (x) - (y))
 667
 668
 669 #define MODADD_POW2(x, y, bound) (((x) + (y)) & ((bound) - 1))
 670 #define MODSUB_POW2(x, y, bound) (((x) - (y)) & ((bound) - 1))
 671
 672
 673 #define CRC8_INIT_VALUE  0xff
 674 #define CRC8_GOOD_VALUE  0x9f
 675 #define CRC16_INIT_VALUE 0xffff
 676 #define CRC16_GOOD_VALUE 0xf0b8
 677 #define CRC32_INIT_VALUE 0xffffffff
 678 #define CRC32_GOOD_VALUE 0xdebb20e3
 679
 680
 681 #define MACF                            "%02x:%02x:%02x:%02x:%02x:%02x"
 682 #define ETHERP_TO_MACF(ea)      ((struct ether_addr *) (ea))->octet[0], \
 683                                                         ((struct ether_addr *) (ea))->octet[1], \
 684                                                         ((struct ether_addr *) (ea))->octet[2], \
 685                                                         ((struct ether_addr *) (ea))->octet[3], \
 686                                                         ((struct ether_addr *) (ea))->octet[4], \
 687                                                         ((struct ether_addr *) (ea))->octet[5]
 688
 689 #define ETHER_TO_MACF(ea)       (ea).octet[0], \
 690                                                         (ea).octet[1], \
 691                                                         (ea).octet[2], \
 692                                                         (ea).octet[3], \
 693                                                         (ea).octet[4], \
 694                                                         (ea).octet[5]
 695 #if !defined(SIMPLE_MAC_PRINT)
 696 #define MACDBG "%02x:%02x:%02x:%02x:%02x:%02x"
 697 #define MAC2STRDBG(ea) (ea)[0], (ea)[1], (ea)[2], (ea)[3], (ea)[4], (ea)[5]
 698 #else
 699 #define MACDBG                          "%02x:%02x:%02x"
 700 #define MAC2STRDBG(ea) (ea)[0], (ea)[4], (ea)[5]
 701 #endif
 702
 703
 704 typedef struct bcm_bit_desc {
 705         uint32  bit;
 706         const char* name;
 707 } bcm_bit_desc_t;
 708
 709
 710 typedef struct bcm_bit_desc_ex {
 711         uint32 mask;
 712         const bcm_bit_desc_t *bitfield;
 713 } bcm_bit_desc_ex_t;
 714
 715
 716
 717 typedef struct bcm_tlv {
 718         uint8   id;
 719         uint8   len;
 720         uint8   data[1];
 721 } bcm_tlv_t;
 722
 723
 724 #define bcm_valid_tlv(elt, buflen) ((buflen) >= 2 && (int)(buflen) >= (int)(2 + (elt)->len))
 725
 726
 727 #define ETHER_ADDR_STR_LEN      18
 728
 729
 730
 731 static INLINE void
 732 xor_128bit_block(const uint8 *src1, const uint8 *src2, uint8 *dst)
 733 {
 734         if (
 735 #ifdef __i386__
 736             1 ||
 737 #endif
 738             (((uintptr)src1 | (uintptr)src2 | (uintptr)dst) & 3) == 0) {
 739
 740
 741                 ((uint32 *)dst)[0] = ((const uint32 *)src1)[0] ^ ((const uint32 *)src2)[0];
 742                 ((uint32 *)dst)[1] = ((const uint32 *)src1)[1] ^ ((const uint32 *)src2)[1];
 743                 ((uint32 *)dst)[2] = ((const uint32 *)src1)[2] ^ ((const uint32 *)src2)[2];
 744                 ((uint32 *)dst)[3] = ((const uint32 *)src1)[3] ^ ((const uint32 *)src2)[3];
 745         } else {
 746
 747                 int k;
 748                 for (k = 0; k < 16; k++)
 749                         dst[k] = src1[k] ^ src2[k];
 750         }
 751 }
 752
 753
 754
 755 extern uint8 hndcrc8(uint8 *p, uint nbytes, uint8 crc);
 756 extern uint16 hndcrc16(uint8 *p, uint nbytes, uint16 crc);
 757 extern uint32 hndcrc32(uint8 *p, uint nbytes, uint32 crc);
 758
 759
 760 #if defined(DHD_DEBUG) || defined(WLMSG_PRHDRS) || defined(WLMSG_PRPKT) || \
 761         defined(WLMSG_ASSOC)
 762
 763 extern int bcm_format_field(const bcm_bit_desc_ex_t *bd, uint32 field, char* buf, int len);
 764
 765 extern int bcm_format_flags(const bcm_bit_desc_t *bd, uint32 flags, char* buf, int len);
 766 #endif
 767
 768 #if defined(DHD_DEBUG) || defined(WLMSG_PRHDRS) || defined(WLMSG_PRPKT) || \
 769         defined(WLMSG_ASSOC) || defined(WLMEDIA_PEAKRATE)
 770 extern int bcm_format_hex(char *str, const void *bytes, int len);
 771 #endif
 772
 773 extern const char *bcm_crypto_algo_name(uint algo);
 774 extern char *bcm_chipname(uint chipid, char *buf, uint len);
 775 extern char *bcm_brev_str(uint32 brev, char *buf);
 776 extern void printbig(char *buf);
 777 extern void prhex(const char *msg, uchar *buf, uint len);
 778
 779
 780 extern bcm_tlv_t *bcm_next_tlv(bcm_tlv_t *elt, int *buflen);
 781 extern bcm_tlv_t *bcm_parse_tlvs(void *buf, int buflen, uint key);
 782 extern bcm_tlv_t *bcm_parse_ordered_tlvs(void *buf, int buflen, uint key);
 783
 784
 785 extern const char *bcmerrorstr(int bcmerror);
 786
 787
 788
 789 typedef uint32 mbool;
 790 #define mboolset(mb, bit)               ((mb) |= (bit))
 791 #define mboolclr(mb, bit)               ((mb) &= ~(bit))
 792 #define mboolisset(mb, bit)             (((mb) & (bit)) != 0)
 793 #define mboolmaskset(mb, mask, val)     ((mb) = (((mb) & ~(mask)) | (val)))
 794
 795
 796 struct fielddesc {
 797         const char *nameandfmt;
 798         uint32  offset;
 799         uint32  len;
 800 };
 801
 802 extern void bcm_binit(struct bcmstrbuf *b, char *buf, uint size);
 803 extern void bcm_bprhex(struct bcmstrbuf *b, const char *msg, bool newline, uint8 *buf, int len);
 804
 805 extern void bcm_inc_bytes(uchar *num, int num_bytes, uint8 amount);
 806 extern int bcm_cmp_bytes(const uchar *arg1, const uchar *arg2, uint8 nbytes);
 807 extern void bcm_print_bytes(const char *name, const uchar *cdata, int len);
 808
 809 typedef  uint32 (*bcmutl_rdreg_rtn)(void *arg0, uint arg1, uint32 offset);
 810 extern uint bcmdumpfields(bcmutl_rdreg_rtn func_ptr, void *arg0, uint arg1, struct fielddesc *str,
 811                           char *buf, uint32 bufsize);
 812 extern uint bcm_bitcount(uint8 *bitmap, uint bytelength);
 813
 814 extern int bcm_bprintf(struct bcmstrbuf *b, const char *fmt, ...);
 815
 816
 817 extern uint16 bcm_qdbm_to_mw(uint8 qdbm);
 818 extern uint8 bcm_mw_to_qdbm(uint16 mw);
 819 extern uint bcm_mkiovar(char *name, char *data, uint datalen, char *buf, uint len);
 820
 821 unsigned int process_nvram_vars(char *varbuf, unsigned int len);
 822 extern bcm_tlv_t *find_vendor_ie(void *tlvs, int tlvs_len,
 823         const char *voui, uint8 *type, int type_len);
 824
 825
 826 extern void bcm_uint64_multiple_add(uint32* r_high, uint32* r_low, uint32 a, uint32 b, uint32 c);
 827
 828 extern void bcm_uint64_divide(uint32* r, uint32 a_high, uint32 a_low, uint32 b);
 829
 830 #ifdef __cplusplus
 831         }
 832 #endif
 833
 834 #endif