release/src-rt-6.x/include/linux_osl.h

   1 /*
   2  * Linux OS Independent Layer
   3  *
   4  * Copyright (C) 2011, 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: linux_osl.h 341165 2012-06-26 19:16:22Z $
  19  */
  20
  21 #ifndef _linux_osl_h_
  22 #define _linux_osl_h_
  23
  24 #include <typedefs.h>
  25
  26 /* Linux Kernel: File Operations: start */
  27 extern void * osl_os_open_image(char * filename);
  28 extern int osl_os_get_image_block(char * buf, int len, void * image);
  29 extern void osl_os_close_image(void * image);
  30 extern int osl_os_image_size(void *image);
  31 /* Linux Kernel: File Operations: end */
  32
  33 #ifdef BCMDRIVER
  34
  35 /* OSL initialization */
  36 extern osl_t *osl_attach(void *pdev, uint bustype, bool pkttag);
  37 extern void osl_detach(osl_t *osh);
  38
  39 /* Global ASSERT type */
  40 extern uint32 g_assert_type;
  41
  42 /* ASSERT */
  43         #ifdef __GNUC__
  44                 #define GCC_VERSION \
  45                         (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
  46                 #if GCC_VERSION > 30100
  47                         #define ASSERT(exp)     do {} while (0)
  48                 #else
  49                         /* ASSERT could cause segmentation fault on GCC3.1, use empty instead */
  50                         #define ASSERT(exp)
  51                 #endif /* GCC_VERSION > 30100 */
  52         #endif /* __GNUC__ */
  53
  54 /* microsecond delay */
  55 #define OSL_DELAY(usec)         osl_delay(usec)
  56 extern void osl_delay(uint usec);
  57
  58 #define OSL_PCMCIA_READ_ATTR(osh, offset, buf, size) \
  59         osl_pcmcia_read_attr((osh), (offset), (buf), (size))
  60 #define OSL_PCMCIA_WRITE_ATTR(osh, offset, buf, size) \
  61         osl_pcmcia_write_attr((osh), (offset), (buf), (size))
  62 extern void osl_pcmcia_read_attr(osl_t *osh, uint offset, void *buf, int size);
  63 extern void osl_pcmcia_write_attr(osl_t *osh, uint offset, void *buf, int size);
  64
  65 /* PCI configuration space access macros */
  66 #define OSL_PCI_READ_CONFIG(osh, offset, size) \
  67         osl_pci_read_config((osh), (offset), (size))
  68 #define OSL_PCI_WRITE_CONFIG(osh, offset, size, val) \
  69         osl_pci_write_config((osh), (offset), (size), (val))
  70 extern uint32 osl_pci_read_config(osl_t *osh, uint offset, uint size);
  71 extern void osl_pci_write_config(osl_t *osh, uint offset, uint size, uint val);
  72
  73 /* PCI device bus # and slot # */
  74 #define OSL_PCI_BUS(osh)        osl_pci_bus(osh)
  75 #define OSL_PCI_SLOT(osh)       osl_pci_slot(osh)
  76 extern uint osl_pci_bus(osl_t *osh);
  77 extern uint osl_pci_slot(osl_t *osh);
  78 extern struct pci_dev *osl_pci_device(osl_t *osh);
  79
  80 /* Pkttag flag should be part of public information */
  81 typedef struct {
  82         bool pkttag;
  83         bool mmbus;             /* Bus supports memory-mapped register accesses */
  84         pktfree_cb_fn_t tx_fn;  /* Callback function for PKTFREE */
  85         void *tx_ctx;           /* Context to the callback function */
  86 #ifdef OSLREGOPS
  87         osl_rreg_fn_t rreg_fn;  /* Read Register function */
  88         osl_wreg_fn_t wreg_fn;  /* Write Register function */
  89         void *reg_ctx;          /* Context to the reg callback functions */
  90 #else
  91         void    *unused[3];
  92 #endif
  93 } osl_pubinfo_t;
  94
  95 #define PKTFREESETCB(osh, _tx_fn, _tx_ctx)              \
  96         do {                                            \
  97            ((osl_pubinfo_t*)osh)->tx_fn = _tx_fn;       \
  98            ((osl_pubinfo_t*)osh)->tx_ctx = _tx_ctx;     \
  99         } while (0)
 100
 101 #ifdef OSLREGOPS
 102 #define REGOPSSET(osh, rreg, wreg, ctx)                 \
 103         do {                                            \
 104            ((osl_pubinfo_t*)osh)->rreg_fn = rreg;       \
 105            ((osl_pubinfo_t*)osh)->wreg_fn = wreg;       \
 106            ((osl_pubinfo_t*)osh)->reg_ctx = ctx;        \
 107         } while (0)
 108 #endif /* OSLREGOPS */
 109
 110 /* host/bus architecture-specific byte swap */
 111 #define BUS_SWAP32(v)           (v)
 112
 113         #define MALLOC(osh, size)       osl_malloc((osh), (size))
 114         #define MFREE(osh, addr, size)  osl_mfree((osh), (addr), (size))
 115         #define MALLOCED(osh)           osl_malloced((osh))
 116         extern void *osl_malloc(osl_t *osh, uint size);
 117         extern void osl_mfree(osl_t *osh, void *addr, uint size);
 118         extern uint osl_malloced(osl_t *osh);
 119
 120 #define NATIVE_MALLOC(osh, size)                kmalloc(size, GFP_ATOMIC)
 121 #define NATIVE_MFREE(osh, addr, size)   kfree(addr)
 122 #ifdef USBAP
 123 #include <linux/vmalloc.h>
 124 #define VMALLOC(osh, size)      vmalloc(size)
 125 #define VFREE(osh, addr, size)  vfree(addr)
 126 #endif /* USBAP */
 127
 128 #define MALLOC_FAILED(osh)      osl_malloc_failed((osh))
 129 extern uint osl_malloc_failed(osl_t *osh);
 130
 131 /* allocate/free shared (dma-able) consistent memory */
 132 #define DMA_CONSISTENT_ALIGN    osl_dma_consistent_align()
 133 #define DMA_ALLOC_CONSISTENT(osh, size, align, tot, pap, dmah) \
 134         osl_dma_alloc_consistent((osh), (size), (align), (tot), (pap))
 135 #define DMA_FREE_CONSISTENT(osh, va, size, pa, dmah) \
 136         osl_dma_free_consistent((osh), (void*)(va), (size), (pa))
 137 extern uint osl_dma_consistent_align(void);
 138 extern void *osl_dma_alloc_consistent(osl_t *osh, uint size, uint16 align, uint *tot, ulong *pap);
 139 extern void osl_dma_free_consistent(osl_t *osh, void *va, uint size, ulong pa);
 140
 141 /* map/unmap direction */
 142 #define DMA_TX  1       /* TX direction for DMA */
 143 #define DMA_RX  2       /* RX direction for DMA */
 144
 145 /* map/unmap shared (dma-able) memory */
 146 #define DMA_UNMAP(osh, pa, size, direction, p, dmah) \
 147         osl_dma_unmap((osh), (pa), (size), (direction))
 148 extern uint osl_dma_map(osl_t *osh, void *va, uint size, int direction);
 149 extern void osl_dma_unmap(osl_t *osh, uint pa, uint size, int direction);
 150
 151 /* API for DMA addressing capability */
 152 #define OSL_DMADDRWIDTH(osh, addrwidth) do {} while (0)
 153
 154 /* register access macros */
 155 #if defined(BCMJTAG)
 156         #include <bcmjtag.h>
 157         #define OSL_WRITE_REG(osh, r, v) (bcmjtag_write(NULL, (uintptr)(r), (v), sizeof(*(r))))
 158         #define OSL_READ_REG(osh, r) (bcmjtag_read(NULL, (uintptr)(r), sizeof(*(r))))
 159 #endif
 160
 161 #if defined(BCMJTAG)
 162         #define SELECT_BUS_WRITE(osh, mmap_op, bus_op) if (((osl_pubinfo_t*)(osh))->mmbus) \
 163                 mmap_op else bus_op
 164         #define SELECT_BUS_READ(osh, mmap_op, bus_op) (((osl_pubinfo_t*)(osh))->mmbus) ? \
 165                 mmap_op : bus_op
 166 #else
 167         #define SELECT_BUS_WRITE(osh, mmap_op, bus_op) mmap_op
 168         #define SELECT_BUS_READ(osh, mmap_op, bus_op) mmap_op
 169 #endif
 170
 171 #define OSL_ERROR(bcmerror)     osl_error(bcmerror)
 172 extern int osl_error(int bcmerror);
 173
 174 /* the largest reasonable packet buffer driver uses for ethernet MTU in bytes */
 175 #define PKTBUFSZ        2048   /* largest reasonable packet buffer, driver uses for ethernet MTU */
 176
 177 /*
 178  * BINOSL selects the slightly slower function-call-based binary compatible osl.
 179  * Macros expand to calls to functions defined in linux_osl.c .
 180  */
 181 #ifndef BINOSL
 182 #include <linuxver.h>           /* use current 2.4.x calling conventions */
 183 #include <linux/kernel.h>       /* for vsn/printf's */
 184 #include <linux/string.h>       /* for mem*, str* */
 185
 186 #define OSL_SYSUPTIME()         ((uint32)jiffies * (1000 / HZ))
 187 #define printf(fmt, args...)    printk(fmt , ## args)
 188 #include <linux/kernel.h>       /* for vsn/printf's */
 189 #include <linux/string.h>       /* for mem*, str* */
 190 /* bcopy's: Linux kernel doesn't provide these (anymore) */
 191 #define bcopy(src, dst, len)    memcpy((dst), (src), (len))
 192 #define bcmp(b1, b2, len)       memcmp((b1), (b2), (len))
 193 #define bzero(b, len)           memset((b), '\0', (len))
 194
 195 /* register access macros */
 196 #if defined(OSLREGOPS)
 197 #define R_REG(osh, r) (\
 198         sizeof(*(r)) == sizeof(uint8) ? osl_readb((osh), (volatile uint8*)(r)) : \
 199         sizeof(*(r)) == sizeof(uint16) ? osl_readw((osh), (volatile uint16*)(r)) : \
 200         osl_readl((osh), (volatile uint32*)(r)) \
 201 )
 202 #define W_REG(osh, r, v) do { \
 203         switch (sizeof(*(r))) { \
 204         case sizeof(uint8):     osl_writeb((osh), (volatile uint8*)(r), (uint8)(v)); break; \
 205         case sizeof(uint16):    osl_writew((osh), (volatile uint16*)(r), (uint16)(v)); break; \
 206         case sizeof(uint32):    osl_writel((osh), (volatile uint32*)(r), (uint32)(v)); break; \
 207         } \
 208 } while (0)
 209
 210 extern uint8 osl_readb(osl_t *osh, volatile uint8 *r);
 211 extern uint16 osl_readw(osl_t *osh, volatile uint16 *r);
 212 extern uint32 osl_readl(osl_t *osh, volatile uint32 *r);
 213 extern void osl_writeb(osl_t *osh, volatile uint8 *r, uint8 v);
 214 extern void osl_writew(osl_t *osh, volatile uint16 *r, uint16 v);
 215 extern void osl_writel(osl_t *osh, volatile uint32 *r, uint32 v);
 216
 217 #else /* OSLREGOPS */
 218
 219 #ifndef IL_BIGENDIAN
 220 #ifndef __mips__
 221 #define R_REG(osh, r) (\
 222         SELECT_BUS_READ(osh, \
 223                 ({ \
 224                         __typeof(*(r)) __osl_v; \
 225                         BCM_REFERENCE(osh);     \
 226                         switch (sizeof(*(r))) { \
 227                                 case sizeof(uint8):     __osl_v = \
 228                                         readb((volatile uint8*)(r)); break; \
 229                                 case sizeof(uint16):    __osl_v = \
 230                                         readw((volatile uint16*)(r)); break; \
 231                                 case sizeof(uint32):    __osl_v = \
 232                                         readl((volatile uint32*)(r)); break; \
 233                         } \
 234                         __osl_v; \
 235                 }), \
 236                 OSL_READ_REG(osh, r)) \
 237 )
 238 #else /* __mips__ */
 239 #define R_REG(osh, r) (\
 240         SELECT_BUS_READ(osh, \
 241                 ({ \
 242                         __typeof(*(r)) __osl_v; \
 243                         BCM_REFERENCE(osh);     \
 244                         __asm__ __volatile__("sync"); \
 245                         switch (sizeof(*(r))) { \
 246                                 case sizeof(uint8):     __osl_v = \
 247                                         readb((volatile uint8*)(r)); break; \
 248                                 case sizeof(uint16):    __osl_v = \
 249                                         readw((volatile uint16*)(r)); break; \
 250                                 case sizeof(uint32):    __osl_v = \
 251                                         readl((volatile uint32*)(r)); break; \
 252                         } \
 253                         __asm__ __volatile__("sync"); \
 254                         __osl_v; \
 255                 }), \
 256                 ({ \
 257                         __typeof(*(r)) __osl_v; \
 258                         __asm__ __volatile__("sync"); \
 259                         __osl_v = OSL_READ_REG(osh, r); \
 260                         __asm__ __volatile__("sync"); \
 261                         __osl_v; \
 262                 })) \
 263 )
 264 #endif /* __mips__ */
 265
 266 #define W_REG(osh, r, v) do { \
 267         BCM_REFERENCE(osh);   \
 268         SELECT_BUS_WRITE(osh, \
 269                 switch (sizeof(*(r))) { \
 270                         case sizeof(uint8):     writeb((uint8)(v), (volatile uint8*)(r)); break; \
 271                         case sizeof(uint16):    writew((uint16)(v), (volatile uint16*)(r)); break; \
 272                         case sizeof(uint32):    writel((uint32)(v), (volatile uint32*)(r)); break; \
 273                 }, \
 274                 (OSL_WRITE_REG(osh, r, v))); \
 275         } while (0)
 276 #else   /* IL_BIGENDIAN */
 277 #define R_REG(osh, r) (\
 278         SELECT_BUS_READ(osh, \
 279                 ({ \
 280                         __typeof(*(r)) __osl_v; \
 281                         BCM_REFERENCE(osh);     \
 282                         switch (sizeof(*(r))) { \
 283                                 case sizeof(uint8):     __osl_v = \
 284                                         readb((volatile uint8*)((uintptr)(r)^3)); break; \
 285                                 case sizeof(uint16):    __osl_v = \
 286                                         readw((volatile uint16*)((uintptr)(r)^2)); break; \
 287                                 case sizeof(uint32):    __osl_v = \
 288                                         readl((volatile uint32*)(r)); break; \
 289                         } \
 290                         __osl_v; \
 291                 }), \
 292                 OSL_READ_REG(osh, r)) \
 293 )
 294 #define W_REG(osh, r, v) do { \
 295         BCM_REFERENCE(osh);   \
 296         SELECT_BUS_WRITE(osh, \
 297                 switch (sizeof(*(r))) { \
 298                         case sizeof(uint8):     writeb((uint8)(v), \
 299                                         (volatile uint8*)((uintptr)(r)^3)); break; \
 300                         case sizeof(uint16):    writew((uint16)(v), \
 301                                         (volatile uint16*)((uintptr)(r)^2)); break; \
 302                         case sizeof(uint32):    writel((uint32)(v), \
 303                                         (volatile uint32*)(r)); break; \
 304                 }, \
 305                 (OSL_WRITE_REG(osh, r, v))); \
 306         } while (0)
 307 #endif /* IL_BIGENDIAN */
 308
 309 #endif /* OSLREGOPS */
 310
 311 #define AND_REG(osh, r, v)              W_REG(osh, (r), R_REG(osh, r) & (v))
 312 #define OR_REG(osh, r, v)               W_REG(osh, (r), R_REG(osh, r) | (v))
 313
 314 /* bcopy, bcmp, and bzero functions */
 315 #define bcopy(src, dst, len)    memcpy((dst), (src), (len))
 316 #define bcmp(b1, b2, len)       memcmp((b1), (b2), (len))
 317 #define bzero(b, len)           memset((b), '\0', (len))
 318
 319 /* uncached/cached virtual address */
 320 #ifdef __mips__
 321 #include <asm/addrspace.h>
 322 #define OSL_UNCACHED(va)        ((void *)KSEG1ADDR((va)))
 323 #define OSL_CACHED(va)          ((void *)KSEG0ADDR((va)))
 324 #else
 325 #define OSL_UNCACHED(va)        ((void *)va)
 326 #define OSL_CACHED(va)          ((void *)va)
 327 #endif /* mips */
 328
 329 #ifdef __mips__
 330 #define OSL_PREF_RANGE_LD(va, sz) prefetch_range_PREF_LOAD_RETAINED(va, sz)
 331 #define OSL_PREF_RANGE_ST(va, sz) prefetch_range_PREF_STORE_RETAINED(va, sz)
 332 #else /* __mips__ */
 333 #define OSL_PREF_RANGE_LD(va, sz)
 334 #define OSL_PREF_RANGE_ST(va, sz)
 335 #endif /* __mips__ */
 336
 337 /* get processor cycle count */
 338 #if defined(mips)
 339 #define OSL_GETCYCLES(x)        ((x) = read_c0_count() * 2)
 340 #elif defined(__i386__)
 341 #define OSL_GETCYCLES(x)        rdtscl((x))
 342 #else
 343 #define OSL_GETCYCLES(x)        ((x) = 0)
 344 #endif /* defined(mips) */
 345
 346 /* dereference an address that may cause a bus exception */
 347 #ifdef mips
 348 #if defined(MODULE) && (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 17))
 349 #define BUSPROBE(val, addr)     panic("get_dbe() will not fixup a bus exception when compiled into"\
 350                                         " a module")
 351 #else
 352 #define BUSPROBE(val, addr)     get_dbe((val), (addr))
 353 #include <asm/paccess.h>
 354 #endif /* defined(MODULE) && (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 17)) */
 355 #else
 356 #define BUSPROBE(val, addr)     ({ (val) = R_REG(NULL, (addr)); 0; })
 357 #endif /* mips */
 358
 359 /* map/unmap physical to virtual I/O */
 360 #if !defined(CONFIG_MMC_MSM7X00A)
 361 #define REG_MAP(pa, size)       ioremap_nocache((unsigned long)(pa), (unsigned long)(size))
 362 #else
 363 #define REG_MAP(pa, size)       (void *)(0)
 364 #endif /* !defined(CONFIG_MMC_MSM7X00A */
 365 #define REG_UNMAP(va)           iounmap((va))
 366
 367 /* shared (dma-able) memory access macros */
 368 #define R_SM(r)                 *(r)
 369 #define W_SM(r, v)              (*(r) = (v))
 370 #define BZERO_SM(r, len)        memset((r), '\0', (len))
 371
 372 /* Because the non BINOSL implemenation of the PKT OSL routines are macros (for
 373  * performance reasons),  we need the Linux headers.
 374  */
 375 #include <linuxver.h>           /* use current 2.4.x calling conventions */
 376
 377 /* packet primitives */
 378 #define PKTGET(osh, len, send)          osl_pktget((osh), (len))
 379 #define PKTDUP(osh, skb)                osl_pktdup((osh), (skb))
 380 #define PKTLIST_DUMP(osh, buf)
 381 #define PKTDBG_TRACE(osh, pkt, bit)
 382 #define PKTFREE(osh, skb, send)         osl_pktfree((osh), (skb), (send))
 383 #ifdef DHD_USE_STATIC_BUF
 384 #define PKTGET_STATIC(osh, len, send)           osl_pktget_static((osh), (len))
 385 #define PKTFREE_STATIC(osh, skb, send)          osl_pktfree_static((osh), (skb), (send))
 386 #endif /* DHD_USE_STATIC_BUF */
 387 #define PKTDATA(osh, skb)               (((struct sk_buff*)(skb))->data)
 388 #define PKTLEN(osh, skb)                (((struct sk_buff*)(skb))->len)
 389 #define PKTHEADROOM(osh, skb)           (PKTDATA(osh, skb)-(((struct sk_buff*)(skb))->head))
 390 #define PKTTAILROOM(osh, skb) ((((struct sk_buff*)(skb))->end)-(((struct sk_buff*)(skb))->tail))
 391 #define PKTNEXT(osh, skb)               (((struct sk_buff*)(skb))->next)
 392 #define PKTSETNEXT(osh, skb, x)         (((struct sk_buff*)(skb))->next = (struct sk_buff*)(x))
 393 #define PKTSETLEN(osh, skb, len)        __skb_trim((struct sk_buff*)(skb), (len))
 394 #define PKTPUSH(osh, skb, bytes)        skb_push((struct sk_buff*)(skb), (bytes))
 395 #define PKTPULL(osh, skb, bytes)        skb_pull((struct sk_buff*)(skb), (bytes))
 396 #define PKTTAG(skb)                     ((void*)(((struct sk_buff*)(skb))->cb))
 397 #define PKTSETPOOL(osh, skb, x, y)      do {} while (0)
 398 #define PKTPOOL(osh, skb)               FALSE
 399 #define PKTSHRINK(osh, m)               (m)
 400
 401 #ifdef CTFPOOL
 402 #define CTFPOOL_REFILL_THRESH   3
 403 typedef struct ctfpool {
 404         void            *head;
 405         spinlock_t      lock;
 406         uint            max_obj;
 407         uint            curr_obj;
 408         uint            obj_size;
 409         uint            refills;
 410         uint            fast_allocs;
 411         uint            fast_frees;
 412         uint            slow_allocs;
 413 } ctfpool_t;
 414 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)
 415 #define FASTBUF (1 << 4)
 416 #define CTFBUF  (1 << 5)
 417 #define PKTSETFAST(osh, skb)    ((((struct sk_buff*)(skb))->ctf_mac_len) |= FASTBUF)
 418 #define PKTCLRFAST(osh, skb)    ((((struct sk_buff*)(skb))->ctf_mac_len) &= (~FASTBUF))
 419 #define PKTSETCTF(osh, skb)     ((((struct sk_buff*)(skb))->ctf_mac_len) |= CTFBUF)
 420 #define PKTCLRCTF(osh, skb)     ((((struct sk_buff*)(skb))->ctf_mac_len) &= (~CTFBUF))
 421 #define PKTISFAST(osh, skb)     ((((struct sk_buff*)(skb))->ctf_mac_len) & FASTBUF)
 422 #define PKTISCTF(osh, skb)      ((((struct sk_buff*)(skb))->ctf_mac_len) & CTFBUF)
 423 #define PKTFAST(osh, skb)       (((struct sk_buff*)(skb))->ctf_mac_len)
 424 #else
 425 #define FASTBUF (1 << 0)
 426 #define CTFBUF  (1 << 1)
 427 #define PKTSETFAST(osh, skb)    ((((struct sk_buff*)(skb))->__unused) |= FASTBUF)
 428 #define PKTCLRFAST(osh, skb)    ((((struct sk_buff*)(skb))->__unused) &= (~FASTBUF))
 429 #define PKTSETCTF(osh, skb)     ((((struct sk_buff*)(skb))->__unused) |= CTFBUF)
 430 #define PKTCLRCTF(osh, skb)     ((((struct sk_buff*)(skb))->__unused) &= (~CTFBUF))
 431 #define PKTISFAST(osh, skb)     ((((struct sk_buff*)(skb))->__unused) & FASTBUF)
 432 #define PKTISCTF(osh, skb)      ((((struct sk_buff*)(skb))->__unused) & CTFBUF)
 433 #define PKTFAST(osh, skb)       (((struct sk_buff*)(skb))->__unused)
 434 #endif /* 2.6.22 */
 435
 436 #define CTFPOOLPTR(osh, skb)    (((struct sk_buff*)(skb))->sk)
 437 #define CTFPOOLHEAD(osh, skb)   (((ctfpool_t *)((struct sk_buff*)(skb))->sk)->head)
 438
 439 extern void *osl_ctfpool_add(osl_t *osh);
 440 extern void osl_ctfpool_replenish(osl_t *osh, uint thresh);
 441 extern int32 osl_ctfpool_init(osl_t *osh, uint numobj, uint size);
 442 extern void osl_ctfpool_cleanup(osl_t *osh);
 443 extern void osl_ctfpool_stats(osl_t *osh, void *b);
 444 #endif /* CTFPOOL */
 445
 446 #ifdef CTFMAP
 447 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
 448 #define CTFMAPPTR(osh, skb)     (((struct sk_buff*)(skb))->sp)
 449 #else /* 2.6.14 */
 450 #define CTFMAPPTR(osh, skb)     (((struct sk_buff*)(skb))->list)
 451 #endif /* 2.6.14 */
 452
 453 #define PKTCTFMAP(osh, p) \
 454 do { \
 455         if (PKTISCTF(osh, p)) { \
 456                 int32 sz; \
 457                 sz = (uint32)(((struct sk_buff *)p)->end) - \
 458                      (uint32)CTFMAPPTR(osh, p); \
 459                 /* map the remaining unmapped area */ \
 460                 if (sz > 0) { \
 461                         _DMA_MAP(osh, (void *)CTFMAPPTR(osh, p), \
 462                                  sz, DMA_RX, p, NULL); \
 463                 } \
 464                 /* clear ctf buf flag */ \
 465                 PKTCLRCTF(osh, p); \
 466                 CTFMAPPTR(osh, p) = NULL; \
 467         } \
 468 } while (0)
 469 #endif /* CTFMAP */
 470
 471 #ifdef HNDCTF
 472 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)
 473 #define SKIPCT  (1 << 6)
 474 #define CHAINED (1 << 7)
 475 #define PKTSETSKIPCT(osh, skb)  (((struct sk_buff*)(skb))->ctf_mac_len |= SKIPCT)
 476 #define PKTCLRSKIPCT(osh, skb)  (((struct sk_buff*)(skb))->ctf_mac_len &= (~SKIPCT))
 477 #define PKTSKIPCT(osh, skb)     (((struct sk_buff*)(skb))->ctf_mac_len & SKIPCT)
 478 #define PKTSETCHAINED(osh, skb) (((struct sk_buff*)(skb))->mac_len |= CHAINED)
 479 #define PKTCLRCHAINED(osh, skb) (((struct sk_buff*)(skb))->mac_len &= (~CHAINED))
 480 #define PKTISCHAINED(skb)       (((struct sk_buff*)(skb))->mac_len & CHAINED)
 481 #else /* 2.6.22 */
 482 #define SKIPCT  (1 << 2)
 483 #define CHAINED (1 << 3)
 484 #define PKTSETSKIPCT(osh, skb)  (((struct sk_buff*)(skb))->__unused |= SKIPCT)
 485 #define PKTCLRSKIPCT(osh, skb)  (((struct sk_buff*)(skb))->__unused &= (~SKIPCT))
 486 #define PKTSKIPCT(osh, skb)     (((struct sk_buff*)(skb))->__unused & SKIPCT)
 487 #define PKTSETCHAINED(osh, skb) (((struct sk_buff*)(skb))->__unused |= CHAINED)
 488 #define PKTCLRCHAINED(osh, skb) (((struct sk_buff*)(skb))->__unused &= (~CHAINED))
 489 #define PKTISCHAINED(skb)       (((struct sk_buff*)(skb))->__unused & CHAINED)
 490 #endif /* 2.6.22 */
 491 #else /* HNDCTF */
 492 #define PKTSETSKIPCT(osh, skb)
 493 #define PKTCLRSKIPCT(osh, skb)
 494 #define PKTSKIPCT(osh, skb)
 495 #endif /* HNDCTF */
 496
 497 extern void osl_pktfree(osl_t *osh, void *skb, bool send);
 498 extern void *osl_pktget_static(osl_t *osh, uint len);
 499 extern void osl_pktfree_static(osl_t *osh, void *skb, bool send);
 500
 501 extern void *osl_pkt_frmnative(osl_t *osh, void *skb);
 502 extern void *osl_pktget(osl_t *osh, uint len);
 503 extern void *osl_pktdup(osl_t *osh, void *skb);
 504 extern struct sk_buff *osl_pkt_tonative(osl_t *osh, void *pkt);
 505 #define PKTFRMNATIVE(osh, skb)  osl_pkt_frmnative(((osl_t *)osh), (struct sk_buff*)(skb))
 506 #define PKTTONATIVE(osh, pkt)           osl_pkt_tonative((osl_t *)(osh), (pkt))
 507
 508 #define PKTLINK(skb)                    (((struct sk_buff*)(skb))->prev)
 509 #define PKTSETLINK(skb, x)              (((struct sk_buff*)(skb))->prev = (struct sk_buff*)(x))
 510 #define PKTPRIO(skb)                    (((struct sk_buff*)(skb))->priority)
 511 #define PKTSETPRIO(skb, x)              (((struct sk_buff*)(skb))->priority = (x))
 512 #define PKTSUMNEEDED(skb)               (((struct sk_buff*)(skb))->ip_summed == CHECKSUM_HW)
 513 #define PKTSETSUMGOOD(skb, x)           (((struct sk_buff*)(skb))->ip_summed = \
 514                                                 ((x) ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE))
 515 /* PKTSETSUMNEEDED and PKTSUMGOOD are not possible because skb->ip_summed is overloaded */
 516 #define PKTSHARED(skb)                  (((struct sk_buff*)(skb))->cloned)
 517
 518 #else   /* BINOSL */
 519
 520 /* Where to get the declarations for mem, str, printf, bcopy's? Two basic approaches.
 521  *
 522  * First, use the Linux header files and the C standard library replacmenent versions
 523  * built-in to the kernel.  Use this approach when compiling non hybrid code or compling
 524  * the OS port files.  The second approach is to use our own defines/prototypes and
 525  * functions we have provided in the Linux OSL, i.e. linux_osl.c.  Use this approach when
 526  * compiling the files that make up the hybrid binary.  We are ensuring we
 527  * don't directly link to the kernel replacement routines from the hybrid binary.
 528  *
 529  * NOTE: The issue we are trying to avoid is any questioning of whether the
 530  * hybrid binary is derived from Linux.  The wireless common code (wlc) is designed
 531  * to be OS independent through the use of the OSL API and thus the hybrid binary doesn't
 532  * derive from the Linux kernel at all.  But since we defined our OSL API to include
 533  * a small collection of standard C library routines and these routines are provided in
 534  * the kernel we want to avoid even the appearance of deriving at all even though clearly
 535  * usage of a C standard library API doesn't represent a derivation from Linux.  Lastly
 536  * note at the time of this checkin 4 references to memcpy/memset could not be eliminated
 537  * from the binary because they are created internally by GCC as part of things like
 538  * structure assignment.  I don't think the compiler should be doing this but there is
 539  * no options to disable it on Intel architectures (there is for MIPS so somebody must
 540  * agree with me).  I may be able to even remove these references eventually with
 541  * a GNU binutil such as objcopy via a symbol rename (i.e. memcpy to osl_memcpy).
 542  */
 543 #if !defined(LINUX_HYBRID) || defined(LINUX_PORT)
 544         #define printf(fmt, args...)    printk(fmt , ## args)
 545         #include <linux/kernel.h>       /* for vsn/printf's */
 546         #include <linux/string.h>       /* for mem*, str* */
 547         /* bcopy's: Linux kernel doesn't provide these (anymore) */
 548         #define bcopy(src, dst, len)    memcpy((dst), (src), (len))
 549         #define bcmp(b1, b2, len)       memcmp((b1), (b2), (len))
 550         #define bzero(b, len)           memset((b), '\0', (len))
 551
 552         /* These are provided only because when compiling linux_osl.c there
 553          * must be an explicit prototype (separate from the definition) because
 554          * we are compiling with GCC option -Wstrict-prototypes.  Conversely
 555          * these could be placed directly in linux_osl.c.
 556          */
 557         extern int osl_printf(const char *format, ...);
 558         extern int osl_sprintf(char *buf, const char *format, ...);
 559         extern int osl_snprintf(char *buf, size_t n, const char *format, ...);
 560         extern int osl_vsprintf(char *buf, const char *format, va_list ap);
 561         extern int osl_vsnprintf(char *buf, size_t n, const char *format, va_list ap);
 562         extern int osl_strcmp(const char *s1, const char *s2);
 563         extern int osl_strncmp(const char *s1, const char *s2, uint n);
 564         extern int osl_strlen(const char *s);
 565         extern char* osl_strcpy(char *d, const char *s);
 566         extern char* osl_strncpy(char *d, const char *s, uint n);
 567         extern char* osl_strchr(const char *s, int c);
 568         extern char* osl_strrchr(const char *s, int c);
 569         extern void *osl_memset(void *d, int c, size_t n);
 570         extern void *osl_memcpy(void *d, const void *s, size_t n);
 571         extern void *osl_memmove(void *d, const void *s, size_t n);
 572         extern int osl_memcmp(const void *s1, const void *s2, size_t n);
 573 #else
 574
 575         /* In the below defines we undefine the macro first in case it is
 576          * defined.  This shouldn't happen because we are not using Linux
 577          * header files but because our Linux 2.4 make includes modversions.h
 578          * through a GCC -include compile option, they get defined to point
 579          * at the appropriate versioned symbol name.  Note this doesn't
 580          * happen with our Linux 2.6 makes.
 581          */
 582
 583         /* *printf functions */
 584         #include <stdarg.h>                     /* va_list needed for v*printf */
 585         #include <stddef.h>                     /* size_t needed for *nprintf */
 586         #undef printf
 587         #undef sprintf
 588         #undef snprintf
 589         #undef vsprintf
 590         #undef vsnprintf
 591         #define printf(fmt, args...)            osl_printf((fmt) , ## args)
 592         #define sprintf(buf, fmt, args...)      osl_sprintf((buf), (fmt) , ## args)
 593         #define snprintf(buf, n, fmt, args...)  osl_snprintf((buf), (n), (fmt) , ## args)
 594         #define vsprintf(buf, fmt, ap)          osl_vsprintf((buf), (fmt), (ap))
 595         #define vsnprintf(buf, n, fmt, ap)      osl_vsnprintf((buf), (n), (fmt), (ap))
 596         extern int osl_printf(const char *format, ...);
 597         extern int osl_sprintf(char *buf, const char *format, ...);
 598         extern int osl_snprintf(char *buf, size_t n, const char *format, ...);
 599         extern int osl_vsprintf(char *buf, const char *format, va_list ap);
 600         extern int osl_vsnprintf(char *buf, size_t n, const char *format, va_list ap);
 601
 602         /* str* functions */
 603         #undef strcmp
 604         #undef strncmp
 605         #undef strlen
 606         #undef strcpy
 607         #undef strncpy
 608         #undef strchr
 609         #undef strrchr
 610         #define strcmp(s1, s2)                  osl_strcmp((s1), (s2))
 611         #define strncmp(s1, s2, n)              osl_strncmp((s1), (s2), (n))
 612         #define strlen(s)                       osl_strlen((s))
 613         #define strcpy(d, s)                    osl_strcpy((d), (s))
 614         #define strncpy(d, s, n)                osl_strncpy((d), (s), (n))
 615         #define strchr(s, c)                    osl_strchr((s), (c))
 616         #define strrchr(s, c)                   osl_strrchr((s), (c))
 617         extern int osl_strcmp(const char *s1, const char *s2);
 618         extern int osl_strncmp(const char *s1, const char *s2, uint n);
 619         extern int osl_strlen(const char *s);
 620         extern char* osl_strcpy(char *d, const char *s);
 621         extern char* osl_strncpy(char *d, const char *s, uint n);
 622         extern char* osl_strchr(const char *s, int c);
 623         extern char* osl_strrchr(const char *s, int c);
 624
 625         /* mem* functions */
 626         #undef memset
 627         #undef memcpy
 628         #undef memcmp
 629         #define memset(d, c, n)         osl_memset((d), (c), (n))
 630         #define memcpy(d, s, n)         osl_memcpy((d), (s), (n))
 631         #define memmove(d, s, n)        osl_memmove((d), (s), (n))
 632         #define memcmp(s1, s2, n)       osl_memcmp((s1), (s2), (n))
 633         extern void *osl_memset(void *d, int c, size_t n);
 634         extern void *osl_memcpy(void *d, const void *s, size_t n);
 635         extern void *osl_memmove(void *d, const void *s, size_t n);
 636         extern int osl_memcmp(const void *s1, const void *s2, size_t n);
 637
 638         /* bcopy, bcmp, and bzero functions */
 639         #undef bcopy
 640         #undef bcmp
 641         #undef bzero
 642         #define bcopy(src, dst, len)    osl_memcpy((dst), (src), (len))
 643         #define bcmp(b1, b2, len)       osl_memcmp((b1), (b2), (len))
 644         #define bzero(b, len)           osl_memset((b), '\0', (len))
 645 #endif /* !defined(LINUX_HYBRID) || defined(LINUX_PORT) */
 646
 647 /* register access macros */
 648 #if !defined(BCMJTAG)
 649 #define R_REG(osh, r) (\
 650         sizeof(*(r)) == sizeof(uint8) ? osl_readb((volatile uint8*)(r)) : \
 651         sizeof(*(r)) == sizeof(uint16) ? osl_readw((volatile uint16*)(r)) : \
 652         osl_readl((volatile uint32*)(r)) \
 653 )
 654 #define W_REG(osh, r, v) do { \
 655         switch (sizeof(*(r))) { \
 656         case sizeof(uint8):     osl_writeb((uint8)(v), (volatile uint8*)(r)); break; \
 657         case sizeof(uint16):    osl_writew((uint16)(v), (volatile uint16*)(r)); break; \
 658         case sizeof(uint32):    osl_writel((uint32)(v), (volatile uint32*)(r)); break; \
 659         } \
 660 } while (0)
 661
 662 /* else added by johnvb to make sdio and jtag work with BINOSL, at least compile ... UNTESTED */
 663 #else
 664 #define R_REG(osh, r) OSL_READ_REG(osh, r)
 665 #define W_REG(osh, r, v) do { OSL_WRITE_REG(osh, r, v); } while (0)
 666 #endif
 667
 668 #define AND_REG(osh, r, v)              W_REG(osh, (r), R_REG(osh, r) & (v))
 669 #define OR_REG(osh, r, v)               W_REG(osh, (r), R_REG(osh, r) | (v))
 670 extern uint8 osl_readb(volatile uint8 *r);
 671 extern uint16 osl_readw(volatile uint16 *r);
 672 extern uint32 osl_readl(volatile uint32 *r);
 673 extern void osl_writeb(uint8 v, volatile uint8 *r);
 674 extern void osl_writew(uint16 v, volatile uint16 *r);
 675 extern void osl_writel(uint32 v, volatile uint32 *r);
 676
 677 /* system up time in ms */
 678 #define OSL_SYSUPTIME()         osl_sysuptime()
 679 extern uint32 osl_sysuptime(void);
 680
 681 /* uncached/cached virtual address */
 682 #define OSL_UNCACHED(va)        osl_uncached((va))
 683 extern void *osl_uncached(void *va);
 684 #define OSL_CACHED(va)          osl_cached((va))
 685 extern void *osl_cached(void *va);
 686
 687 #define OSL_PREF_RANGE_LD(va, sz)
 688 #define OSL_PREF_RANGE_ST(va, sz)
 689
 690 /* get processor cycle count */
 691 #define OSL_GETCYCLES(x)        ((x) = osl_getcycles())
 692 extern uint osl_getcycles(void);
 693
 694 /* dereference an address that may target abort */
 695 #define BUSPROBE(val, addr)     osl_busprobe(&(val), (addr))
 696 extern int osl_busprobe(uint32 *val, uint32 addr);
 697
 698 /* map/unmap physical to virtual */
 699 #define REG_MAP(pa, size)       osl_reg_map((pa), (size))
 700 #define REG_UNMAP(va)           osl_reg_unmap((va))
 701 extern void *osl_reg_map(uint32 pa, uint size);
 702 extern void osl_reg_unmap(void *va);
 703
 704 /* shared (dma-able) memory access macros */
 705 #define R_SM(r)                 *(r)
 706 #define W_SM(r, v)              (*(r) = (v))
 707 #define BZERO_SM(r, len)        bzero((r), (len))
 708
 709 /* packet primitives */
 710 #define PKTGET(osh, len, send)          osl_pktget((osh), (len))
 711 #define PKTDUP(osh, skb)                osl_pktdup((osh), (skb))
 712 #define PKTFRMNATIVE(osh, skb)          osl_pkt_frmnative((osh), (skb))
 713 #define PKTLIST_DUMP(osh, buf)
 714 #define PKTDBG_TRACE(osh, pkt, bit)
 715 #define PKTFREE(osh, skb, send)         osl_pktfree((osh), (skb), (send))
 716 #define PKTDATA(osh, skb)               osl_pktdata((osh), (skb))
 717 #define PKTLEN(osh, skb)                osl_pktlen((osh), (skb))
 718 #define PKTHEADROOM(osh, skb)           osl_pktheadroom((osh), (skb))
 719 #define PKTTAILROOM(osh, skb)           osl_pkttailroom((osh), (skb))
 720 #define PKTNEXT(osh, skb)               osl_pktnext((osh), (skb))
 721 #define PKTSETNEXT(osh, skb, x)         osl_pktsetnext((skb), (x))
 722 #define PKTSETLEN(osh, skb, len)        osl_pktsetlen((osh), (skb), (len))
 723 #define PKTPUSH(osh, skb, bytes)        osl_pktpush((osh), (skb), (bytes))
 724 #define PKTPULL(osh, skb, bytes)        osl_pktpull((osh), (skb), (bytes))
 725 #define PKTTAG(skb)                     osl_pkttag((skb))
 726 #define PKTTONATIVE(osh, pkt)           osl_pkt_tonative((osh), (pkt))
 727 #define PKTLINK(skb)                    osl_pktlink((skb))
 728 #define PKTSETLINK(skb, x)              osl_pktsetlink((skb), (x))
 729 #define PKTPRIO(skb)                    osl_pktprio((skb))
 730 #define PKTSETPRIO(skb, x)              osl_pktsetprio((skb), (x))
 731 #define PKTSHARED(skb)                  osl_pktshared((skb))
 732 #define PKTSETPOOL(osh, skb, x, y)      do {} while (0)
 733 #define PKTPOOL(osh, skb)               FALSE
 734
 735 extern void *osl_pktget(osl_t *osh, uint len);
 736 extern void *osl_pktdup(osl_t *osh, void *skb);
 737 extern void *osl_pkt_frmnative(osl_t *osh, void *skb);
 738 extern void osl_pktfree(osl_t *osh, void *skb, bool send);
 739 extern uchar *osl_pktdata(osl_t *osh, void *skb);
 740 extern uint osl_pktlen(osl_t *osh, void *skb);
 741 extern uint osl_pktheadroom(osl_t *osh, void *skb);
 742 extern uint osl_pkttailroom(osl_t *osh, void *skb);
 743 extern void *osl_pktnext(osl_t *osh, void *skb);
 744 extern void osl_pktsetnext(void *skb, void *x);
 745 extern void osl_pktsetlen(osl_t *osh, void *skb, uint len);
 746 extern uchar *osl_pktpush(osl_t *osh, void *skb, int bytes);
 747 extern uchar *osl_pktpull(osl_t *osh, void *skb, int bytes);
 748 extern void *osl_pkttag(void *skb);
 749 extern void *osl_pktlink(void *skb);
 750 extern void osl_pktsetlink(void *skb, void *x);
 751 extern uint osl_pktprio(void *skb);
 752 extern void osl_pktsetprio(void *skb, uint x);
 753 extern struct sk_buff *osl_pkt_tonative(osl_t *osh, void *pkt);
 754 extern bool osl_pktshared(void *skb);
 755
 756
 757 #endif  /* BINOSL */
 758
 759 #define PKTALLOCED(osh)         osl_pktalloced(osh)
 760 extern uint osl_pktalloced(osl_t *osh);
 761
 762 #ifdef CTFMAP
 763 #include <ctf/hndctf.h>
 764 #define CTFMAPSZ        320
 765 #define DMA_MAP(osh, va, size, direction, p, dmah) \
 766 ({ \
 767         typeof(size) sz = (size); \
 768         if (PKTISCTF((osh), (p))) { \
 769                 sz = CTFMAPSZ; \
 770                 CTFMAPPTR((osh), (p)) = (void *)(((uint8 *)(va)) + CTFMAPSZ); \
 771         } \
 772         osl_dma_map((osh), (va), sz, (direction)); \
 773 })
 774 #define _DMA_MAP(osh, va, size, direction, p, dmah) \
 775         dma_cache_inv((uint)(va), (size))
 776 #else /* CTFMAP */
 777 #define DMA_MAP(osh, va, size, direction, p, dmah) \
 778         osl_dma_map((osh), (va), (size), (direction))
 779 #endif /* CTFMAP */
 780
 781 #ifdef PKTC
 782 /* Use 8 bytes of skb tstamp field to store below info */
 783 struct chain_node {
 784         struct sk_buff  *link;
 785         unsigned int    flags:3, pkts:9, bytes:20;
 786 };
 787
 788 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
 789 #define CHAIN_NODE(skb)         ((struct chain_node*)&(((struct sk_buff*)skb)->tstamp))
 790 #else
 791 #define CHAIN_NODE(skb)         ((struct chain_node*)&(((struct sk_buff*)skb)->stamp))
 792 #endif
 793
 794 #define PKTCSETATTR(s, f, p, b) ({CHAIN_NODE(s)->flags = (f); CHAIN_NODE(s)->pkts = (p); \
 795                                  CHAIN_NODE(s)->bytes = (b);})
 796 #define PKTCCLRATTR(s)          ({CHAIN_NODE(s)->flags = CHAIN_NODE(s)->pkts = \
 797                                  CHAIN_NODE(s)->bytes = 0;})
 798 #define PKTCGETATTR(s)          (CHAIN_NODE(s)->flags << 29 | CHAIN_NODE(s)->pkts << 20 | \
 799                                  CHAIN_NODE(s)->bytes)
 800 #define PKTCCNT(skb)            (CHAIN_NODE(skb)->pkts)
 801 #define PKTCLEN(skb)            (CHAIN_NODE(skb)->bytes)
 802 #define PKTCFLAGS(skb)          (CHAIN_NODE(skb)->flags)
 803 #define PKTCSETCNT(skb, c)      (CHAIN_NODE(skb)->pkts = (c))
 804 #define PKTCINCRCNT(skb)        (CHAIN_NODE(skb)->pkts++)
 805 #define PKTCADDCNT(skb, c)      (CHAIN_NODE(skb)->pkts += (c))
 806 #define PKTCSETLEN(skb, l)      (CHAIN_NODE(skb)->bytes = (l))
 807 #define PKTCADDLEN(skb, l)      (CHAIN_NODE(skb)->bytes += (l))
 808 #define PKTCSETFLAG(skb, fb)    (CHAIN_NODE(skb)->flags |= (fb))
 809 #define PKTCCLRFLAG(skb, fb)    (CHAIN_NODE(skb)->flags &= ~(fb))
 810 #define PKTCLINK(skb)           (CHAIN_NODE(skb)->link)
 811 #define PKTSETCLINK(skb, x)     (CHAIN_NODE(skb)->link = (struct sk_buff*)(x))
 812 #define FOREACH_CHAINED_PKT(skb, nskb) \
 813         for (; (skb) != NULL; (skb) = (nskb)) \
 814                 if ((nskb) = (PKTISCHAINED(skb) ? PKTCLINK(skb) : NULL), \
 815                     PKTSETCLINK((skb), NULL), 1)
 816 #define PKTCFREE(osh, skb, send) \
 817 do { \
 818         void *nskb; \
 819         ASSERT((skb) != NULL); \
 820         FOREACH_CHAINED_PKT((skb), nskb) { \
 821                 PKTCLRCHAINED((osh), (skb)); \
 822                 PKTFREE((osh), (skb), (send)); \
 823         } \
 824 } while (0)
 825 #define PKTCENQTAIL(h, t, p) \
 826 do { \
 827         if ((t) == NULL) { \
 828                 (h) = (t) = (p); \
 829         } else { \
 830                 PKTSETCLINK((t), (p)); \
 831                 (t) = (p); \
 832         } \
 833 } while (0)
 834 #endif /* PKTC */
 835
 836 #else /* ! BCMDRIVER */
 837
 838
 839 /* ASSERT */
 840         #define ASSERT(exp)     do {} while (0)
 841
 842 /* MALLOC and MFREE */
 843 #define MALLOC(o, l) malloc(l)
 844 #define MFREE(o, p, l) free(p)
 845 #include <stdlib.h>
 846
 847 /* str* and mem* functions */
 848 #include <string.h>
 849
 850 /* *printf functions */
 851 #include <stdio.h>
 852
 853 /* bcopy, bcmp, and bzero */
 854 extern void bcopy(const void *src, void *dst, size_t len);
 855 extern int bcmp(const void *b1, const void *b2, size_t len);
 856 extern void bzero(void *b, size_t len);
 857 #endif /* ! BCMDRIVER */
 858
 859 #endif  /* _linux_osl_h_ */