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

   1 /*
   2  * Linux OS Independent Layer
   3  *
   4  * Copyright (C) 2014, 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 419467 2013-08-21 09:19:48Z $
  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
 138 #define DMA_ALLOC_CONSISTENT_FORCE32(osh, size, align, tot, pap, dmah) \
 139         osl_dma_alloc_consistent((osh), (size), (align), (tot), (pap))
 140 #define DMA_FREE_CONSISTENT_FORCE32(osh, va, size, pa, dmah) \
 141         osl_dma_free_consistent((osh), (void*)(va), (size), (pa))
 142
 143 extern uint osl_dma_consistent_align(void);
 144 extern void *osl_dma_alloc_consistent(osl_t *osh, uint size, uint16 align, uint *tot, ulong *pap);
 145 extern void osl_dma_free_consistent(osl_t *osh, void *va, uint size, ulong pa);
 146
 147 /* map/unmap direction */
 148 #define DMA_TX  1       /* TX direction for DMA */
 149 #define DMA_RX  2       /* RX direction for DMA */
 150
 151 /* map/unmap shared (dma-able) memory */
 152 #define DMA_UNMAP(osh, pa, size, direction, p, dmah) \
 153         osl_dma_unmap((osh), (pa), (size), (direction))
 154 extern uint osl_dma_map(osl_t *osh, void *va, uint size, int direction, void *p,
 155         hnddma_seg_map_t *txp_dmah);
 156 extern void osl_dma_unmap(osl_t *osh, uint pa, uint size, int direction);
 157
 158 /* API for DMA addressing capability */
 159 #define OSL_DMADDRWIDTH(osh, addrwidth) do {} while (0)
 160
 161 /* register access macros */
 162 #if defined(BCMJTAG)
 163         #include <bcmjtag.h>
 164         #define OSL_WRITE_REG(osh, r, v) (bcmjtag_write(NULL, (uintptr)(r), (v), sizeof(*(r))))
 165         #define OSL_READ_REG(osh, r) (bcmjtag_read(NULL, (uintptr)(r), sizeof(*(r))))
 166 #endif
 167
 168 #if defined(BCMJTAG)
 169         #define SELECT_BUS_WRITE(osh, mmap_op, bus_op) if (((osl_pubinfo_t*)(osh))->mmbus) \
 170                 mmap_op else bus_op
 171         #define SELECT_BUS_READ(osh, mmap_op, bus_op) (((osl_pubinfo_t*)(osh))->mmbus) ? \
 172                 mmap_op : bus_op
 173 #else
 174         #define SELECT_BUS_WRITE(osh, mmap_op, bus_op) mmap_op
 175         #define SELECT_BUS_READ(osh, mmap_op, bus_op) mmap_op
 176 #endif
 177
 178 #define OSL_ERROR(bcmerror)     osl_error(bcmerror)
 179 extern int osl_error(int bcmerror);
 180
 181 /* the largest reasonable packet buffer driver uses for ethernet MTU in bytes */
 182 #define PKTBUFSZ        2048   /* largest reasonable packet buffer, driver uses for ethernet MTU */
 183
 184 /*
 185  * BINOSL selects the slightly slower function-call-based binary compatible osl.
 186  * Macros expand to calls to functions defined in linux_osl.c .
 187  */
 188 #ifndef BINOSL
 189 #include <linuxver.h>           /* use current 2.4.x calling conventions */
 190 #include <linux/kernel.h>       /* for vsn/printf's */
 191 #include <linux/string.h>       /* for mem*, str* */
 192
 193 #define OSL_SYSUPTIME()         ((uint32)jiffies * (1000 / HZ))
 194 #define printf(fmt, args...)    printk(fmt , ## args)
 195 #include <linux/kernel.h>       /* for vsn/printf's */
 196 #include <linux/string.h>       /* for mem*, str* */
 197 /* bcopy's: Linux kernel doesn't provide these (anymore) */
 198 #define bcopy(src, dst, len)    memcpy((dst), (src), (len))
 199 #define bcmp(b1, b2, len)       memcmp((b1), (b2), (len))
 200 #define bzero(b, len)           memset((b), '\0', (len))
 201
 202 /* register access macros */
 203 #if defined(OSLREGOPS)
 204 #define R_REG(osh, r) (\
 205         sizeof(*(r)) == sizeof(uint8) ? osl_readb((osh), (volatile uint8*)(r)) : \
 206         sizeof(*(r)) == sizeof(uint16) ? osl_readw((osh), (volatile uint16*)(r)) : \
 207         osl_readl((osh), (volatile uint32*)(r)) \
 208 )
 209 #define W_REG(osh, r, v) do { \
 210         switch (sizeof(*(r))) { \
 211         case sizeof(uint8):     osl_writeb((osh), (volatile uint8*)(r), (uint8)(v)); break; \
 212         case sizeof(uint16):    osl_writew((osh), (volatile uint16*)(r), (uint16)(v)); break; \
 213         case sizeof(uint32):    osl_writel((osh), (volatile uint32*)(r), (uint32)(v)); break; \
 214         } \
 215 } while (0)
 216
 217 extern uint8 osl_readb(osl_t *osh, volatile uint8 *r);
 218 extern uint16 osl_readw(osl_t *osh, volatile uint16 *r);
 219 extern uint32 osl_readl(osl_t *osh, volatile uint32 *r);
 220 extern void osl_writeb(osl_t *osh, volatile uint8 *r, uint8 v);
 221 extern void osl_writew(osl_t *osh, volatile uint16 *r, uint16 v);
 222 extern void osl_writel(osl_t *osh, volatile uint32 *r, uint32 v);
 223
 224 #else /* OSLREGOPS */
 225
 226 #ifndef IL_BIGENDIAN
 227 #ifndef __mips__
 228 #define R_REG(osh, r) (\
 229         SELECT_BUS_READ(osh, \
 230                 ({ \
 231                         __typeof(*(r)) __osl_v; \
 232                         BCM_REFERENCE(osh);     \
 233                         switch (sizeof(*(r))) { \
 234                                 case sizeof(uint8):     __osl_v = \
 235                                         readb((volatile uint8*)(r)); break; \
 236                                 case sizeof(uint16):    __osl_v = \
 237                                         readw((volatile uint16*)(r)); break; \
 238                                 case sizeof(uint32):    __osl_v = \
 239                                         readl((volatile uint32*)(r)); break; \
 240                         } \
 241                         __osl_v; \
 242                 }), \
 243                 OSL_READ_REG(osh, r)) \
 244 )
 245 #else /* __mips__ */
 246 #define R_REG(osh, r) (\
 247         SELECT_BUS_READ(osh, \
 248                 ({ \
 249                         __typeof(*(r)) __osl_v; \
 250                         BCM_REFERENCE(osh);     \
 251                         __asm__ __volatile__("sync"); \
 252                         switch (sizeof(*(r))) { \
 253                                 case sizeof(uint8):     __osl_v = \
 254                                         readb((volatile uint8*)(r)); break; \
 255                                 case sizeof(uint16):    __osl_v = \
 256                                         readw((volatile uint16*)(r)); break; \
 257                                 case sizeof(uint32):    __osl_v = \
 258                                         readl((volatile uint32*)(r)); break; \
 259                         } \
 260                         __asm__ __volatile__("sync"); \
 261                         __osl_v; \
 262                 }), \
 263                 ({ \
 264                         __typeof(*(r)) __osl_v; \
 265                         __asm__ __volatile__("sync"); \
 266                         __osl_v = OSL_READ_REG(osh, r); \
 267                         __asm__ __volatile__("sync"); \
 268                         __osl_v; \
 269                 })) \
 270 )
 271 #endif /* __mips__ */
 272
 273 #define W_REG(osh, r, v) do { \
 274         BCM_REFERENCE(osh);   \
 275         SELECT_BUS_WRITE(osh, \
 276                 switch (sizeof(*(r))) { \
 277                         case sizeof(uint8):     writeb((uint8)(v), (volatile uint8*)(r)); break; \
 278                         case sizeof(uint16):    writew((uint16)(v), (volatile uint16*)(r)); break; \
 279                         case sizeof(uint32):    writel((uint32)(v), (volatile uint32*)(r)); break; \
 280                 }, \
 281                 (OSL_WRITE_REG(osh, r, v))); \
 282         } while (0)
 283 #else   /* IL_BIGENDIAN */
 284 #define R_REG(osh, r) (\
 285         SELECT_BUS_READ(osh, \
 286                 ({ \
 287                         __typeof(*(r)) __osl_v; \
 288                         BCM_REFERENCE(osh);     \
 289                         switch (sizeof(*(r))) { \
 290                                 case sizeof(uint8):     __osl_v = \
 291                                         readb((volatile uint8*)((uintptr)(r)^3)); break; \
 292                                 case sizeof(uint16):    __osl_v = \
 293                                         readw((volatile uint16*)((uintptr)(r)^2)); break; \
 294                                 case sizeof(uint32):    __osl_v = \
 295                                         readl((volatile uint32*)(r)); break; \
 296                         } \
 297                         __osl_v; \
 298                 }), \
 299                 OSL_READ_REG(osh, r)) \
 300 )
 301 #define W_REG(osh, r, v) do { \
 302         BCM_REFERENCE(osh);   \
 303         SELECT_BUS_WRITE(osh, \
 304                 switch (sizeof(*(r))) { \
 305                         case sizeof(uint8):     writeb((uint8)(v), \
 306                                         (volatile uint8*)((uintptr)(r)^3)); break; \
 307                         case sizeof(uint16):    writew((uint16)(v), \
 308                                         (volatile uint16*)((uintptr)(r)^2)); break; \
 309                         case sizeof(uint32):    writel((uint32)(v), \
 310                                         (volatile uint32*)(r)); break; \
 311                 }, \
 312                 (OSL_WRITE_REG(osh, r, v))); \
 313         } while (0)
 314 #endif /* IL_BIGENDIAN */
 315
 316 #endif /* OSLREGOPS */
 317
 318 #define AND_REG(osh, r, v)              W_REG(osh, (r), R_REG(osh, r) & (v))
 319 #define OR_REG(osh, r, v)               W_REG(osh, (r), R_REG(osh, r) | (v))
 320
 321 /* bcopy, bcmp, and bzero functions */
 322 #define bcopy(src, dst, len)    memcpy((dst), (src), (len))
 323 #define bcmp(b1, b2, len)       memcmp((b1), (b2), (len))
 324 #define bzero(b, len)           memset((b), '\0', (len))
 325
 326 /* uncached/cached virtual address */
 327 #ifdef __mips__
 328 #include <asm/addrspace.h>
 329 #define OSL_UNCACHED(va)        ((void *)KSEG1ADDR((va)))
 330 #define OSL_CACHED(va)          ((void *)KSEG0ADDR((va)))
 331 #else
 332 #define OSL_UNCACHED(va)        ((void *)va)
 333 #define OSL_CACHED(va)          ((void *)va)
 334
 335 /* ARM NorthStar */
 336 #define OSL_CACHE_FLUSH(va, len)
 337
 338 #endif /* mips */
 339
 340 #ifdef __mips__
 341 #define OSL_PREF_RANGE_LD(va, sz) prefetch_range_PREF_LOAD_RETAINED(va, sz)
 342 #define OSL_PREF_RANGE_ST(va, sz) prefetch_range_PREF_STORE_RETAINED(va, sz)
 343 #else /* __mips__ */
 344 #define OSL_PREF_RANGE_LD(va, sz)
 345 #define OSL_PREF_RANGE_ST(va, sz)
 346 #endif /* __mips__ */
 347
 348 /* get processor cycle count */
 349 #if defined(mips)
 350 #define OSL_GETCYCLES(x)        ((x) = read_c0_count() * 2)
 351 #elif defined(__i386__)
 352 #define OSL_GETCYCLES(x)        rdtscl((x))
 353 #else
 354 #define OSL_GETCYCLES(x)        ((x) = 0)
 355 #endif /* defined(mips) */
 356
 357 /* dereference an address that may cause a bus exception */
 358 #ifdef mips
 359 #if defined(MODULE) && (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 17))
 360 #define BUSPROBE(val, addr)     panic("get_dbe() will not fixup a bus exception when compiled into"\
 361                                         " a module")
 362 #else
 363 #define BUSPROBE(val, addr)     get_dbe((val), (addr))
 364 #include <asm/paccess.h>
 365 #endif /* defined(MODULE) && (LINUX_VERSION_CODE < KERNEL_VERSION(2, 4, 17)) */
 366 #else
 367 #define BUSPROBE(val, addr)     ({ (val) = R_REG(NULL, (addr)); 0; })
 368 #endif /* mips */
 369
 370 /* map/unmap physical to virtual I/O */
 371 #if !defined(CONFIG_MMC_MSM7X00A)
 372 #define REG_MAP(pa, size)       ioremap_nocache((unsigned long)(pa), (unsigned long)(size))
 373 #else
 374 #define REG_MAP(pa, size)       (void *)(0)
 375 #endif /* !defined(CONFIG_MMC_MSM7X00A */
 376 #define REG_UNMAP(va)           iounmap((va))
 377
 378 /* shared (dma-able) memory access macros */
 379 #define R_SM(r)                 *(r)
 380 #define W_SM(r, v)              (*(r) = (v))
 381 #define BZERO_SM(r, len)        memset((r), '\0', (len))
 382
 383 /* Because the non BINOSL implemenation of the PKT OSL routines are macros (for
 384  * performance reasons),  we need the Linux headers.
 385  */
 386 #include <linuxver.h>           /* use current 2.4.x calling conventions */
 387
 388 /* packet primitives */
 389 #ifdef BCMDBG_CTRACE
 390 #define PKTGET(osh, len, send)          osl_pktget((osh), (len), __LINE__, __FILE__)
 391 #define PKTDUP(osh, skb)                osl_pktdup((osh), (skb), __LINE__, __FILE__)
 392 #else
 393 #define PKTGET(osh, len, send)          osl_pktget((osh), (len))
 394 #define PKTDUP(osh, skb)                osl_pktdup((osh), (skb))
 395 #endif /* BCMDBG_CTRACE */
 396 #define PKTLIST_DUMP(osh, buf)
 397 #define PKTDBG_TRACE(osh, pkt, bit)
 398 #define PKTFREE(osh, skb, send)         osl_pktfree((osh), (skb), (send))
 399 #ifdef DHD_USE_STATIC_BUF
 400 #define PKTGET_STATIC(osh, len, send)           osl_pktget_static((osh), (len))
 401 #define PKTFREE_STATIC(osh, skb, send)          osl_pktfree_static((osh), (skb), (send))
 402 #endif /* DHD_USE_STATIC_BUF */
 403 #define PKTDATA(osh, skb)               (((struct sk_buff*)(skb))->data)
 404 #define PKTLEN(osh, skb)                (((struct sk_buff*)(skb))->len)
 405 #define PKTHEADROOM(osh, skb)           (PKTDATA(osh, skb)-(((struct sk_buff*)(skb))->head))
 406 #define PKTEXPHEADROOM(osh, skb, b)     skb_realloc_headroom((struct sk_buff*)(skb), (b))
 407 #define PKTTAILROOM(osh, skb)           skb_tailroom((struct sk_buff*)(skb))
 408 #define PKTNEXT(osh, skb)               (((struct sk_buff*)(skb))->next)
 409 #define PKTSETNEXT(osh, skb, x)         (((struct sk_buff*)(skb))->next = (struct sk_buff*)(x))
 410 #define PKTSETLEN(osh, skb, len)        __skb_trim((struct sk_buff*)(skb), (len))
 411 #define PKTPUSH(osh, skb, bytes)        skb_push((struct sk_buff*)(skb), (bytes))
 412 #define PKTPULL(osh, skb, bytes)        skb_pull((struct sk_buff*)(skb), (bytes))
 413 #define PKTTAG(skb)                     ((void*)(((struct sk_buff*)(skb))->cb))
 414 #define PKTSETPOOL(osh, skb, x, y)      do {} while (0)
 415 #define PKTPOOL(osh, skb)               FALSE
 416 #define PKTSHRINK(osh, m)               (m)
 417
 418 #ifdef BCMDBG_CTRACE
 419 #define DEL_CTRACE(zosh, zskb) { \
 420         unsigned long zflags; \
 421         spin_lock_irqsave(&(zosh)->ctrace_lock, zflags); \
 422         list_del(&(zskb)->ctrace_list); \
 423         (zosh)->ctrace_num--; \
 424         (zskb)->ctrace_start = 0; \
 425         (zskb)->ctrace_count = 0; \
 426         spin_unlock_irqrestore(&(zosh)->ctrace_lock, zflags); \
 427 }
 428
 429 #define UPDATE_CTRACE(zskb, zfile, zline) { \
 430         struct sk_buff *_zskb = (struct sk_buff *)(zskb); \
 431         if (_zskb->ctrace_count < CTRACE_NUM) { \
 432                 _zskb->func[_zskb->ctrace_count] = zfile; \
 433                 _zskb->line[_zskb->ctrace_count] = zline; \
 434                 _zskb->ctrace_count++; \
 435         } \
 436         else { \
 437                 _zskb->func[_zskb->ctrace_start] = zfile; \
 438                 _zskb->line[_zskb->ctrace_start] = zline; \
 439                 _zskb->ctrace_start++; \
 440                 if (_zskb->ctrace_start >= CTRACE_NUM) \
 441                         _zskb->ctrace_start = 0; \
 442         } \
 443 }
 444
 445 #define ADD_CTRACE(zosh, zskb, zfile, zline) { \
 446         unsigned long zflags; \
 447         spin_lock_irqsave(&(zosh)->ctrace_lock, zflags); \
 448         list_add(&(zskb)->ctrace_list, &(zosh)->ctrace_list); \
 449         (zosh)->ctrace_num++; \
 450         UPDATE_CTRACE(zskb, zfile, zline); \
 451         spin_unlock_irqrestore(&(zosh)->ctrace_lock, zflags); \
 452 }
 453
 454 #define PKTCALLER(zskb) UPDATE_CTRACE((struct sk_buff *)zskb, (char *)__FUNCTION__, __LINE__)
 455 #endif /* BCMDBG_CTRACE */
 456
 457 #ifdef CTFPOOL
 458 #define CTFPOOL_REFILL_THRESH   3
 459 typedef struct ctfpool {
 460         void            *head;
 461         spinlock_t      lock;
 462         uint            max_obj;
 463         uint            curr_obj;
 464         uint            obj_size;
 465         uint            refills;
 466         uint            fast_allocs;
 467         uint            fast_frees;
 468         uint            slow_allocs;
 469 } ctfpool_t;
 470 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)
 471
 472 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
 473 #define FASTBUF (1 << 0)
 474 #define CTFBUF  (1 << 1)
 475 #define PKTSETFAST(osh, skb)    ((((struct sk_buff*)(skb))->pktc_flags) |= FASTBUF)
 476 #define PKTCLRFAST(osh, skb)    ((((struct sk_buff*)(skb))->pktc_flags) &= (~FASTBUF))
 477 #define PKTSETCTF(osh, skb)     ((((struct sk_buff*)(skb))->pktc_flags) |= CTFBUF)
 478 #define PKTCLRCTF(osh, skb)     ((((struct sk_buff*)(skb))->pktc_flags) &= (~CTFBUF))
 479 #define PKTISFAST(osh, skb)     ((((struct sk_buff*)(skb))->pktc_flags) & FASTBUF)
 480 #define PKTISCTF(osh, skb)      ((((struct sk_buff*)(skb))->pktc_flags) & CTFBUF)
 481 #define PKTFAST(osh, skb)       (((struct sk_buff*)(skb))->pktc_flags)
 482 #else
 483 #define FASTBUF (1 << 16)
 484 #define CTFBUF  (1 << 17)
 485 #define PKTSETFAST(osh, skb)    ((((struct sk_buff*)(skb))->mac_len) |= FASTBUF)
 486 #define PKTCLRFAST(osh, skb)    ((((struct sk_buff*)(skb))->mac_len) &= (~FASTBUF))
 487 #define PKTSETCTF(osh, skb)     ((((struct sk_buff*)(skb))->mac_len) |= CTFBUF)
 488 #define PKTCLRCTF(osh, skb)     ((((struct sk_buff*)(skb))->mac_len) &= (~CTFBUF))
 489 #define PKTISFAST(osh, skb)     ((((struct sk_buff*)(skb))->mac_len) & FASTBUF)
 490 #define PKTISCTF(osh, skb)      ((((struct sk_buff*)(skb))->mac_len) & CTFBUF)
 491 #define PKTFAST(osh, skb)       (((struct sk_buff*)(skb))->mac_len)
 492 #endif /* 2.6.36 */
 493 #else
 494 #define FASTBUF (1 << 0)
 495 #define CTFBUF  (1 << 1)
 496 #define PKTSETFAST(osh, skb)    ((((struct sk_buff*)(skb))->__unused) |= FASTBUF)
 497 #define PKTCLRFAST(osh, skb)    ((((struct sk_buff*)(skb))->__unused) &= (~FASTBUF))
 498 #define PKTSETCTF(osh, skb)     ((((struct sk_buff*)(skb))->__unused) |= CTFBUF)
 499 #define PKTCLRCTF(osh, skb)     ((((struct sk_buff*)(skb))->__unused) &= (~CTFBUF))
 500 #define PKTISFAST(osh, skb)     ((((struct sk_buff*)(skb))->__unused) & FASTBUF)
 501 #define PKTISCTF(osh, skb)      ((((struct sk_buff*)(skb))->__unused) & CTFBUF)
 502 #define PKTFAST(osh, skb)       (((struct sk_buff*)(skb))->__unused)
 503 #endif /* 2.6.22 */
 504
 505 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
 506 #define CTFPOOLPTR(osh, skb)    (((struct sk_buff*)(skb))->ctfpool)
 507 #define CTFPOOLHEAD(osh, skb)   (((ctfpool_t *)((struct sk_buff*)(skb))->ctfpool)->head)
 508 #else
 509 #define CTFPOOLPTR(osh, skb)    (((struct sk_buff*)(skb))->sk)
 510 #define CTFPOOLHEAD(osh, skb)   (((ctfpool_t *)((struct sk_buff*)(skb))->sk)->head)
 511 #endif
 512
 513 extern void *osl_ctfpool_add(osl_t *osh);
 514 extern void osl_ctfpool_replenish(osl_t *osh, uint thresh);
 515 extern int32 osl_ctfpool_init(osl_t *osh, uint numobj, uint size);
 516 extern void osl_ctfpool_cleanup(osl_t *osh);
 517 extern void osl_ctfpool_stats(osl_t *osh, void *b);
 518 #endif /* CTFPOOL */
 519
 520 #ifdef CTFMAP
 521
 522 #if defined(__mips__)
 523 #define CACHE_LINE_SIZE         32
 524 #elif defined(__ARM_ARCH_7A__)
 525 #define CACHE_LINE_SIZE         32
 526 #else
 527 #error "CACHE_LINE_SIZE define needed!"
 528 #endif
 529
 530 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 14)
 531 #define CTFMAPPTR(osh, skb)     (((struct sk_buff*)(skb))->sp)
 532 #else /* 2.6.14 */
 533 #define CTFMAPPTR(osh, skb)     (((struct sk_buff*)(skb))->list)
 534 #endif /* 2.6.14 */
 535
 536 #define PKTCTFMAP(osh, p) \
 537 do { \
 538         if (PKTISCTF(osh, p)) { \
 539                 int32 sz; \
 540                 sz = (uint32)(((struct sk_buff *)p)->end) - \
 541                      (uint32)CTFMAPPTR(osh, p); \
 542                 /* map the remaining unmapped area */ \
 543                 if (sz > 0) { \
 544                         sz = (sz + CACHE_LINE_SIZE - 1) & ~(CACHE_LINE_SIZE - 1); \
 545                         _DMA_MAP(osh, (void *)CTFMAPPTR(osh, p), \
 546                                  sz, DMA_RX, p, NULL); \
 547                 } \
 548                 /* clear ctf buf flag */ \
 549                 PKTCLRCTF(osh, p); \
 550                 CTFMAPPTR(osh, p) = NULL; \
 551         } \
 552 } while (0)
 553 #endif /* CTFMAP */
 554
 555 #ifdef HNDCTF
 556 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)
 557
 558 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
 559 #define SKIPCT  (1 << 2)
 560 #define CHAINED (1 << 3)
 561 #define PKTSETSKIPCT(osh, skb)  (((struct sk_buff*)(skb))->pktc_flags |= SKIPCT)
 562 #define PKTCLRSKIPCT(osh, skb)  (((struct sk_buff*)(skb))->pktc_flags &= (~SKIPCT))
 563 #define PKTSKIPCT(osh, skb)     (((struct sk_buff*)(skb))->pktc_flags & SKIPCT)
 564 #define PKTSETCHAINED(osh, skb) (((struct sk_buff*)(skb))->pktc_flags |= CHAINED)
 565 #define PKTCLRCHAINED(osh, skb) (((struct sk_buff*)(skb))->pktc_flags &= (~CHAINED))
 566 #define PKTISCHAINED(skb)       (((struct sk_buff*)(skb))->pktc_flags & CHAINED)
 567 #else
 568 #define SKIPCT  (1 << 18)
 569 #define CHAINED (1 << 19)
 570 #define PKTSETSKIPCT(osh, skb)  (((struct sk_buff*)(skb))->mac_len |= SKIPCT)
 571 #define PKTCLRSKIPCT(osh, skb)  (((struct sk_buff*)(skb))->mac_len &= (~SKIPCT))
 572 #define PKTSKIPCT(osh, skb)     (((struct sk_buff*)(skb))->mac_len & SKIPCT)
 573 #define PKTSETCHAINED(osh, skb) (((struct sk_buff*)(skb))->mac_len |= CHAINED)
 574 #define PKTCLRCHAINED(osh, skb) (((struct sk_buff*)(skb))->mac_len &= (~CHAINED))
 575 #define PKTISCHAINED(skb)       (((struct sk_buff*)(skb))->mac_len & CHAINED)
 576 #endif /* 2.6.36 */
 577 #else /* 2.6.22 */
 578 #define SKIPCT  (1 << 2)
 579 #define CHAINED (1 << 3)
 580 #define PKTSETSKIPCT(osh, skb)  (((struct sk_buff*)(skb))->__unused |= SKIPCT)
 581 #define PKTCLRSKIPCT(osh, skb)  (((struct sk_buff*)(skb))->__unused &= (~SKIPCT))
 582 #define PKTSKIPCT(osh, skb)     (((struct sk_buff*)(skb))->__unused & SKIPCT)
 583 #define PKTSETCHAINED(osh, skb) (((struct sk_buff*)(skb))->__unused |= CHAINED)
 584 #define PKTCLRCHAINED(osh, skb) (((struct sk_buff*)(skb))->__unused &= (~CHAINED))
 585 #define PKTISCHAINED(skb)       (((struct sk_buff*)(skb))->__unused & CHAINED)
 586 #endif /* 2.6.22 */
 587 typedef struct ctf_mark {
 588         uint32  value;
 589 }       ctf_mark_t;
 590 #define CTF_MARK(m)                             (m.value)
 591 #else /* HNDCTF */
 592 #define PKTSETSKIPCT(osh, skb)
 593 #define PKTCLRSKIPCT(osh, skb)
 594 #define PKTSKIPCT(osh, skb)
 595 #define CTF_MARK(m)                             0
 596 #endif /* HNDCTF */
 597
 598 #ifdef BCMFA
 599 #ifdef BCMFA_HW_HASH
 600 #define PKTSETFAHIDX(skb, idx)  (((struct sk_buff*)(skb))->napt_idx = idx)
 601 #else
 602 #define PKTSETFAHIDX(skb, idx)
 603 #endif /* BCMFA_SW_HASH */
 604 #define PKTGETFAHIDX(skb)       (((struct sk_buff*)(skb))->napt_idx)
 605 #define PKTSETFADEV(skb, imp)   (((struct sk_buff*)(skb))->dev = imp)
 606 #define PKTSETRXDEV(skb)        (((struct sk_buff*)(skb))->rxdev = ((struct sk_buff*)(skb))->dev)
 607
 608 #define AUX_TCP_FIN_RST (1 << 0)
 609 #define AUX_FREED       (1 << 1)
 610 #define PKTSETFAAUX(skb)        (((struct sk_buff*)(skb))->napt_flags |= AUX_TCP_FIN_RST)
 611 #define PKTCLRFAAUX(skb)        (((struct sk_buff*)(skb))->napt_flags &= (~AUX_TCP_FIN_RST))
 612 #define PKTISFAAUX(skb)         (((struct sk_buff*)(skb))->napt_flags & AUX_TCP_FIN_RST)
 613 #define PKTSETFAFREED(skb)      (((struct sk_buff*)(skb))->napt_flags |= AUX_FREED)
 614 #define PKTCLRFAFREED(skb)      (((struct sk_buff*)(skb))->napt_flags &= (~AUX_FREED))
 615 #define PKTISFAFREED(skb)       (((struct sk_buff*)(skb))->napt_flags & AUX_FREED)
 616 #define PKTISFABRIDGED(skb)     PKTISFAAUX(skb)
 617 #else
 618 #define PKTISFAAUX(skb)         (FALSE)
 619 #define PKTISFABRIDGED(skb)     (FALSE)
 620 #define PKTISFAFREED(skb)       (FALSE)
 621
 622 #define PKTCLRFAAUX(skb)
 623 #define PKTSETFAFREED(skb)
 624 #define PKTCLRFAFREED(skb)
 625 #endif /* BCMFA */
 626
 627 extern void osl_pktfree(osl_t *osh, void *skb, bool send);
 628 extern void *osl_pktget_static(osl_t *osh, uint len);
 629 extern void osl_pktfree_static(osl_t *osh, void *skb, bool send);
 630
 631 #ifdef BCMDBG_CTRACE
 632 #define PKT_CTRACE_DUMP(osh, b) osl_ctrace_dump((osh), (b))
 633 extern void *osl_pktget(osl_t *osh, uint len, int line, char *file);
 634 extern void *osl_pkt_frmnative(osl_t *osh, void *skb, int line, char *file);
 635 extern int osl_pkt_is_frmnative(osl_t *osh, struct sk_buff *pkt);
 636 extern void *osl_pktdup(osl_t *osh, void *skb, int line, char *file);
 637 struct bcmstrbuf;
 638 extern void osl_ctrace_dump(osl_t *osh, struct bcmstrbuf *b);
 639 #else
 640 extern void *osl_pkt_frmnative(osl_t *osh, void *skb);
 641 extern void *osl_pktget(osl_t *osh, uint len);
 642 extern void *osl_pktdup(osl_t *osh, void *skb);
 643 #endif /* BCMDBG_CTRACE */
 644 extern struct sk_buff *osl_pkt_tonative(osl_t *osh, void *pkt);
 645 #ifdef BCMDBG_CTRACE
 646 #define PKTFRMNATIVE(osh, skb)  osl_pkt_frmnative(((osl_t *)osh), \
 647                                 (struct sk_buff*)(skb), __LINE__, __FILE__)
 648 #define PKTISFRMNATIVE(osh, skb) osl_pkt_is_frmnative((osl_t *)(osh), (struct sk_buff *)(skb))
 649 #else
 650 #define PKTFRMNATIVE(osh, skb)  osl_pkt_frmnative(((osl_t *)osh), (struct sk_buff*)(skb))
 651 #endif /* BCMDBG_CTRACE */
 652 #define PKTTONATIVE(osh, pkt)           osl_pkt_tonative((osl_t *)(osh), (pkt))
 653
 654 #define PKTLINK(skb)                    (((struct sk_buff*)(skb))->prev)
 655 #define PKTSETLINK(skb, x)              (((struct sk_buff*)(skb))->prev = (struct sk_buff*)(x))
 656 #define PKTPRIO(skb)                    (((struct sk_buff*)(skb))->priority)
 657 #define PKTSETPRIO(skb, x)              (((struct sk_buff*)(skb))->priority = (x))
 658 #define PKTSUMNEEDED(skb)               (((struct sk_buff*)(skb))->ip_summed == CHECKSUM_HW)
 659 #define PKTSETSUMGOOD(skb, x)           (((struct sk_buff*)(skb))->ip_summed = \
 660                                                 ((x) ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE))
 661 /* PKTSETSUMNEEDED and PKTSUMGOOD are not possible because skb->ip_summed is overloaded */
 662 #define PKTSHARED(skb)                  (((struct sk_buff*)(skb))->cloned)
 663
 664 #ifdef CONFIG_NF_CONNTRACK_MARK
 665 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0))
 666 #define PKTMARK(p)                     (((struct sk_buff *)(p))->mark)
 667 #define PKTSETMARK(p, m)               ((struct sk_buff *)(p))->mark = (m)
 668 #else /* !2.6.0 */
 669 #define PKTMARK(p)                     (((struct sk_buff *)(p))->nfmark)
 670 #define PKTSETMARK(p, m)               ((struct sk_buff *)(p))->nfmark = (m)
 671 #endif /* 2.6.0 */
 672 #else /* CONFIG_NF_CONNTRACK_MARK */
 673 #define PKTMARK(p)                     0
 674 #define PKTSETMARK(p, m)
 675 #endif /* CONFIG_NF_CONNTRACK_MARK */
 676
 677 #else   /* BINOSL */
 678
 679 /* Where to get the declarations for mem, str, printf, bcopy's? Two basic approaches.
 680  *
 681  * First, use the Linux header files and the C standard library replacmenent versions
 682  * built-in to the kernel.  Use this approach when compiling non hybrid code or compling
 683  * the OS port files.  The second approach is to use our own defines/prototypes and
 684  * functions we have provided in the Linux OSL, i.e. linux_osl.c.  Use this approach when
 685  * compiling the files that make up the hybrid binary.  We are ensuring we
 686  * don't directly link to the kernel replacement routines from the hybrid binary.
 687  *
 688  * NOTE: The issue we are trying to avoid is any questioning of whether the
 689  * hybrid binary is derived from Linux.  The wireless common code (wlc) is designed
 690  * to be OS independent through the use of the OSL API and thus the hybrid binary doesn't
 691  * derive from the Linux kernel at all.  But since we defined our OSL API to include
 692  * a small collection of standard C library routines and these routines are provided in
 693  * the kernel we want to avoid even the appearance of deriving at all even though clearly
 694  * usage of a C standard library API doesn't represent a derivation from Linux.  Lastly
 695  * note at the time of this checkin 4 references to memcpy/memset could not be eliminated
 696  * from the binary because they are created internally by GCC as part of things like
 697  * structure assignment.  I don't think the compiler should be doing this but there is
 698  * no options to disable it on Intel architectures (there is for MIPS so somebody must
 699  * agree with me).  I may be able to even remove these references eventually with
 700  * a GNU binutil such as objcopy via a symbol rename (i.e. memcpy to osl_memcpy).
 701  */
 702 #if !defined(LINUX_HYBRID) || defined(LINUX_PORT)
 703         #define printf(fmt, args...)    printk(fmt , ## args)
 704         #include <linux/kernel.h>       /* for vsn/printf's */
 705         #include <linux/string.h>       /* for mem*, str* */
 706         /* bcopy's: Linux kernel doesn't provide these (anymore) */
 707         #define bcopy(src, dst, len)    memcpy((dst), (src), (len))
 708         #define bcmp(b1, b2, len)       memcmp((b1), (b2), (len))
 709         #define bzero(b, len)           memset((b), '\0', (len))
 710
 711         /* These are provided only because when compiling linux_osl.c there
 712          * must be an explicit prototype (separate from the definition) because
 713          * we are compiling with GCC option -Wstrict-prototypes.  Conversely
 714          * these could be placed directly in linux_osl.c.
 715          */
 716         extern int osl_printf(const char *format, ...);
 717         extern int osl_sprintf(char *buf, const char *format, ...);
 718         extern int osl_snprintf(char *buf, size_t n, const char *format, ...);
 719         extern int osl_vsprintf(char *buf, const char *format, va_list ap);
 720         extern int osl_vsnprintf(char *buf, size_t n, const char *format, va_list ap);
 721         extern int osl_strcmp(const char *s1, const char *s2);
 722         extern int osl_strncmp(const char *s1, const char *s2, uint n);
 723         extern int osl_strlen(const char *s);
 724         extern char* osl_strcpy(char *d, const char *s);
 725         extern char* osl_strncpy(char *d, const char *s, uint n);
 726         extern char* osl_strchr(const char *s, int c);
 727         extern char* osl_strrchr(const char *s, int c);
 728         extern void *osl_memset(void *d, int c, size_t n);
 729         extern void *osl_memcpy(void *d, const void *s, size_t n);
 730         extern void *osl_memmove(void *d, const void *s, size_t n);
 731         extern int osl_memcmp(const void *s1, const void *s2, size_t n);
 732 #else
 733
 734         /* In the below defines we undefine the macro first in case it is
 735          * defined.  This shouldn't happen because we are not using Linux
 736          * header files but because our Linux 2.4 make includes modversions.h
 737          * through a GCC -include compile option, they get defined to point
 738          * at the appropriate versioned symbol name.  Note this doesn't
 739          * happen with our Linux 2.6 makes.
 740          */
 741
 742         /* *printf functions */
 743         #include <stdarg.h>                     /* va_list needed for v*printf */
 744         #include <stddef.h>                     /* size_t needed for *nprintf */
 745         #undef printf
 746         #undef sprintf
 747         #undef snprintf
 748         #undef vsprintf
 749         #undef vsnprintf
 750         #define printf(fmt, args...)            osl_printf((fmt) , ## args)
 751         #define sprintf(buf, fmt, args...)      osl_sprintf((buf), (fmt) , ## args)
 752         #define snprintf(buf, n, fmt, args...)  osl_snprintf((buf), (n), (fmt) , ## args)
 753         #define vsprintf(buf, fmt, ap)          osl_vsprintf((buf), (fmt), (ap))
 754         #define vsnprintf(buf, n, fmt, ap)      osl_vsnprintf((buf), (n), (fmt), (ap))
 755         extern int osl_printf(const char *format, ...);
 756         extern int osl_sprintf(char *buf, const char *format, ...);
 757         extern int osl_snprintf(char *buf, size_t n, const char *format, ...);
 758         extern int osl_vsprintf(char *buf, const char *format, va_list ap);
 759         extern int osl_vsnprintf(char *buf, size_t n, const char *format, va_list ap);
 760
 761         /* str* functions */
 762         #undef strcmp
 763         #undef strncmp
 764         #undef strlen
 765         #undef strcpy
 766         #undef strncpy
 767         #undef strchr
 768         #undef strrchr
 769         #define strcmp(s1, s2)                  osl_strcmp((s1), (s2))
 770         #define strncmp(s1, s2, n)              osl_strncmp((s1), (s2), (n))
 771         #define strlen(s)                       osl_strlen((s))
 772         #define strcpy(d, s)                    osl_strcpy((d), (s))
 773         #define strncpy(d, s, n)                osl_strncpy((d), (s), (n))
 774         #define strchr(s, c)                    osl_strchr((s), (c))
 775         #define strrchr(s, c)                   osl_strrchr((s), (c))
 776         extern int osl_strcmp(const char *s1, const char *s2);
 777         extern int osl_strncmp(const char *s1, const char *s2, uint n);
 778         extern int osl_strlen(const char *s);
 779         extern char* osl_strcpy(char *d, const char *s);
 780         extern char* osl_strncpy(char *d, const char *s, uint n);
 781         extern char* osl_strchr(const char *s, int c);
 782         extern char* osl_strrchr(const char *s, int c);
 783
 784         /* mem* functions */
 785         #undef memset
 786         #undef memcpy
 787         #undef memcmp
 788         #define memset(d, c, n)         osl_memset((d), (c), (n))
 789         #define memcpy(d, s, n)         osl_memcpy((d), (s), (n))
 790         #define memmove(d, s, n)        osl_memmove((d), (s), (n))
 791         #define memcmp(s1, s2, n)       osl_memcmp((s1), (s2), (n))
 792         extern void *osl_memset(void *d, int c, size_t n);
 793         extern void *osl_memcpy(void *d, const void *s, size_t n);
 794         extern void *osl_memmove(void *d, const void *s, size_t n);
 795         extern int osl_memcmp(const void *s1, const void *s2, size_t n);
 796
 797         /* bcopy, bcmp, and bzero functions */
 798         #undef bcopy
 799         #undef bcmp
 800         #undef bzero
 801         #define bcopy(src, dst, len)    osl_memcpy((dst), (src), (len))
 802         #define bcmp(b1, b2, len)       osl_memcmp((b1), (b2), (len))
 803         #define bzero(b, len)           osl_memset((b), '\0', (len))
 804 #endif /* !defined(LINUX_HYBRID) || defined(LINUX_PORT) */
 805
 806 /* register access macros */
 807 #if !defined(BCMJTAG)
 808 #define R_REG(osh, r) (\
 809         sizeof(*(r)) == sizeof(uint8) ? osl_readb((volatile uint8*)(r)) : \
 810         sizeof(*(r)) == sizeof(uint16) ? osl_readw((volatile uint16*)(r)) : \
 811         osl_readl((volatile uint32*)(r)) \
 812 )
 813 #define W_REG(osh, r, v) do { \
 814         switch (sizeof(*(r))) { \
 815         case sizeof(uint8):     osl_writeb((uint8)(v), (volatile uint8*)(r)); break; \
 816         case sizeof(uint16):    osl_writew((uint16)(v), (volatile uint16*)(r)); break; \
 817         case sizeof(uint32):    osl_writel((uint32)(v), (volatile uint32*)(r)); break; \
 818         } \
 819 } while (0)
 820
 821 /* else added by johnvb to make sdio and jtag work with BINOSL, at least compile ... UNTESTED */
 822 #else
 823 #define R_REG(osh, r) OSL_READ_REG(osh, r)
 824 #define W_REG(osh, r, v) do { OSL_WRITE_REG(osh, r, v); } while (0)
 825 #endif
 826
 827 #define AND_REG(osh, r, v)              W_REG(osh, (r), R_REG(osh, r) & (v))
 828 #define OR_REG(osh, r, v)               W_REG(osh, (r), R_REG(osh, r) | (v))
 829 extern uint8 osl_readb(volatile uint8 *r);
 830 extern uint16 osl_readw(volatile uint16 *r);
 831 extern uint32 osl_readl(volatile uint32 *r);
 832 extern void osl_writeb(uint8 v, volatile uint8 *r);
 833 extern void osl_writew(uint16 v, volatile uint16 *r);
 834 extern void osl_writel(uint32 v, volatile uint32 *r);
 835
 836 /* system up time in ms */
 837 #define OSL_SYSUPTIME()         osl_sysuptime()
 838 extern uint32 osl_sysuptime(void);
 839
 840 /* uncached/cached virtual address */
 841 #define OSL_UNCACHED(va)        osl_uncached((va))
 842 extern void *osl_uncached(void *va);
 843 #define OSL_CACHED(va)          osl_cached((va))
 844 extern void *osl_cached(void *va);
 845
 846 #define OSL_PREF_RANGE_LD(va, sz)
 847 #define OSL_PREF_RANGE_ST(va, sz)
 848
 849 /* get processor cycle count */
 850 #define OSL_GETCYCLES(x)        ((x) = osl_getcycles())
 851 extern uint osl_getcycles(void);
 852
 853 /* dereference an address that may target abort */
 854 #define BUSPROBE(val, addr)     osl_busprobe(&(val), (addr))
 855 extern int osl_busprobe(uint32 *val, uint32 addr);
 856
 857 /* map/unmap physical to virtual */
 858 #define REG_MAP(pa, size)       osl_reg_map((pa), (size))
 859 #define REG_UNMAP(va)           osl_reg_unmap((va))
 860 extern void *osl_reg_map(uint32 pa, uint size);
 861 extern void osl_reg_unmap(void *va);
 862
 863 /* shared (dma-able) memory access macros */
 864 #define R_SM(r)                 *(r)
 865 #define W_SM(r, v)              (*(r) = (v))
 866 #define BZERO_SM(r, len)        bzero((r), (len))
 867
 868 /* packet primitives */
 869 #ifdef BCMDBG_CTRACE
 870 #define PKTGET(osh, len, send)          osl_pktget((osh), (len), __LINE__, __FILE__)
 871 #define PKTDUP(osh, skb)                osl_pktdup((osh), (skb), __LINE__, __FILE__)
 872 #define PKTFRMNATIVE(osh, skb)          osl_pkt_frmnative((osh), (skb), __LINE__, __FILE__)
 873 #else
 874 #define PKTGET(osh, len, send)          osl_pktget((osh), (len))
 875 #define PKTDUP(osh, skb)                osl_pktdup((osh), (skb))
 876 #define PKTFRMNATIVE(osh, skb)          osl_pkt_frmnative((osh), (skb))
 877 #endif /* BCMDBG_CTRACE */
 878 #define PKTLIST_DUMP(osh, buf)
 879 #define PKTDBG_TRACE(osh, pkt, bit)
 880 #define PKTFREE(osh, skb, send)         osl_pktfree((osh), (skb), (send))
 881 #define PKTDATA(osh, skb)               osl_pktdata((osh), (skb))
 882 #define PKTLEN(osh, skb)                osl_pktlen((osh), (skb))
 883 #define PKTHEADROOM(osh, skb)           osl_pktheadroom((osh), (skb))
 884 #define PKTTAILROOM(osh, skb)           osl_pkttailroom((osh), (skb))
 885 #define PKTNEXT(osh, skb)               osl_pktnext((osh), (skb))
 886 #define PKTSETNEXT(osh, skb, x)         osl_pktsetnext((skb), (x))
 887 #define PKTSETLEN(osh, skb, len)        osl_pktsetlen((osh), (skb), (len))
 888 #define PKTPUSH(osh, skb, bytes)        osl_pktpush((osh), (skb), (bytes))
 889 #define PKTPULL(osh, skb, bytes)        osl_pktpull((osh), (skb), (bytes))
 890 #define PKTTAG(skb)                     osl_pkttag((skb))
 891 #define PKTTONATIVE(osh, pkt)           osl_pkt_tonative((osh), (pkt))
 892 #define PKTLINK(skb)                    osl_pktlink((skb))
 893 #define PKTSETLINK(skb, x)              osl_pktsetlink((skb), (x))
 894 #define PKTPRIO(skb)                    osl_pktprio((skb))
 895 #define PKTSETPRIO(skb, x)              osl_pktsetprio((skb), (x))
 896 #define PKTSHARED(skb)                  osl_pktshared((skb))
 897 #define PKTSETPOOL(osh, skb, x, y)      do {} while (0)
 898 #define PKTPOOL(osh, skb)               FALSE
 899
 900 extern void *osl_pktget(osl_t *osh, uint len);
 901 extern void *osl_pktdup(osl_t *osh, void *skb);
 902 extern void *osl_pkt_frmnative(osl_t *osh, void *skb);
 903 extern void osl_pktfree(osl_t *osh, void *skb, bool send);
 904 extern uchar *osl_pktdata(osl_t *osh, void *skb);
 905 extern uint osl_pktlen(osl_t *osh, void *skb);
 906 extern uint osl_pktheadroom(osl_t *osh, void *skb);
 907 extern uint osl_pkttailroom(osl_t *osh, void *skb);
 908 extern void *osl_pktnext(osl_t *osh, void *skb);
 909 extern void osl_pktsetnext(void *skb, void *x);
 910 extern void osl_pktsetlen(osl_t *osh, void *skb, uint len);
 911 extern uchar *osl_pktpush(osl_t *osh, void *skb, int bytes);
 912 extern uchar *osl_pktpull(osl_t *osh, void *skb, int bytes);
 913 extern void *osl_pkttag(void *skb);
 914 extern void *osl_pktlink(void *skb);
 915 extern void osl_pktsetlink(void *skb, void *x);
 916 extern uint osl_pktprio(void *skb);
 917 extern void osl_pktsetprio(void *skb, uint x);
 918 extern struct sk_buff *osl_pkt_tonative(osl_t *osh, void *pkt);
 919 extern bool osl_pktshared(void *skb);
 920
 921
 922 #endif  /* BINOSL */
 923
 924 #define PKTALLOCED(osh)         osl_pktalloced(osh)
 925 extern uint osl_pktalloced(osl_t *osh);
 926
 927 #ifdef CTFMAP
 928 #include <ctf/hndctf.h>
 929 #define CTFMAPSZ        320
 930 #define DMA_MAP(osh, va, size, direction, p, dmah) \
 931 ({ \
 932         typeof(size) sz = (size); \
 933         if (p && PKTISCTF((osh), (p))) { \
 934                 sz = CTFMAPSZ; \
 935                 CTFMAPPTR((osh), (p)) = (void *)(((uint8 *)(va)) + CTFMAPSZ); \
 936         } \
 937         osl_dma_map((osh), (va), sz, (direction), (p), (dmah)); \
 938 })
 939 #if defined(__mips__)
 940 #define _DMA_MAP(osh, va, size, direction, p, dmah) \
 941         dma_cache_inv((uint)(va), (size))
 942 #elif defined(__ARM_ARCH_7A__)
 943 #include <asm/cacheflush.h>
 944 #define _DMA_MAP(osh, va, size, direction, p, dmah) \
 945         osl_dma_map((osh), (va), (size), (direction), (p), (dmah))
 946 #else
 947 #define _DMA_MAP(osh, va, size, direction, p, dmah)
 948 #endif
 949
 950 #else /* CTFMAP */
 951 #define DMA_MAP(osh, va, size, direction, p, dmah) \
 952         osl_dma_map((osh), (va), (size), (direction), (p), (dmah))
 953 #endif /* CTFMAP */
 954
 955 #ifdef PKTC
 956 /* Use 8 bytes of skb tstamp field to store below info */
 957 struct chain_node {
 958         struct sk_buff  *link;
 959         unsigned int    flags:3, pkts:9, bytes:20;
 960 };
 961
 962 #define CHAIN_NODE(skb)         ((struct chain_node*)(((struct sk_buff*)skb)->pktc_cb))
 963
 964 #define PKTCSETATTR(s, f, p, b) ({CHAIN_NODE(s)->flags = (f); CHAIN_NODE(s)->pkts = (p); \
 965                                  CHAIN_NODE(s)->bytes = (b);})
 966 #define PKTCCLRATTR(s)          ({CHAIN_NODE(s)->flags = CHAIN_NODE(s)->pkts = \
 967                                  CHAIN_NODE(s)->bytes = 0;})
 968 #define PKTCGETATTR(s)          (CHAIN_NODE(s)->flags << 29 | CHAIN_NODE(s)->pkts << 20 | \
 969                                  CHAIN_NODE(s)->bytes)
 970 #define PKTCCNT(skb)            (CHAIN_NODE(skb)->pkts)
 971 #define PKTCLEN(skb)            (CHAIN_NODE(skb)->bytes)
 972 #define PKTCGETFLAGS(skb)       (CHAIN_NODE(skb)->flags)
 973 #define PKTCSETFLAGS(skb, f)    (CHAIN_NODE(skb)->flags = (f))
 974 #define PKTCCLRFLAGS(skb)       (CHAIN_NODE(skb)->flags = 0)
 975 #define PKTCFLAGS(skb)          (CHAIN_NODE(skb)->flags)
 976 #define PKTCSETCNT(skb, c)      (CHAIN_NODE(skb)->pkts = (c))
 977 #define PKTCINCRCNT(skb)        (CHAIN_NODE(skb)->pkts++)
 978 #define PKTCADDCNT(skb, c)      (CHAIN_NODE(skb)->pkts += (c))
 979 #define PKTCSETLEN(skb, l)      (CHAIN_NODE(skb)->bytes = (l))
 980 #define PKTCADDLEN(skb, l)      (CHAIN_NODE(skb)->bytes += (l))
 981 #define PKTCSETFLAG(skb, fb)    (CHAIN_NODE(skb)->flags |= (fb))
 982 #define PKTCCLRFLAG(skb, fb)    (CHAIN_NODE(skb)->flags &= ~(fb))
 983 #define PKTCLINK(skb)           (CHAIN_NODE(skb)->link)
 984 #define PKTSETCLINK(skb, x)     (CHAIN_NODE(skb)->link = (struct sk_buff*)(x))
 985 #define FOREACH_CHAINED_PKT(skb, nskb) \
 986         for (; (skb) != NULL; (skb) = (nskb)) \
 987                 if ((nskb) = (PKTISCHAINED(skb) ? PKTCLINK(skb) : NULL), \
 988                     PKTSETCLINK((skb), NULL), 1)
 989 #define PKTCFREE(osh, skb, send) \
 990 do { \
 991         void *nskb; \
 992         ASSERT((skb) != NULL); \
 993         FOREACH_CHAINED_PKT((skb), nskb) { \
 994                 PKTCLRCHAINED((osh), (skb)); \
 995                 PKTCCLRFLAGS((skb)); \
 996                 PKTFREE((osh), (skb), (send)); \
 997         } \
 998 } while (0)
 999 #define PKTCENQTAIL(h, t, p) \
1000 do { \
1001         if ((t) == NULL) { \
1002                 (h) = (t) = (p); \
1003         } else { \
1004                 PKTSETCLINK((t), (p)); \
1005                 (t) = (p); \
1006         } \
1007 } while (0)
1008 #endif /* PKTC */
1009
1010 #else /* ! BCMDRIVER */
1011
1012
1013 /* ASSERT */
1014         #define ASSERT(exp)     do {} while (0)
1015
1016 /* MALLOC and MFREE */
1017 #define MALLOC(o, l) malloc(l)
1018 #define MFREE(o, p, l) free(p)
1019 #include <stdlib.h>
1020
1021 /* str* and mem* functions */
1022 #include <string.h>
1023
1024 /* *printf functions */
1025 #include <stdio.h>
1026
1027 /* bcopy, bcmp, and bzero */
1028 extern void bcopy(const void *src, void *dst, size_t len);
1029 extern int bcmp(const void *b1, const void *b2, size_t len);
1030 extern void bzero(void *b, size_t len);
1031 #endif /* ! BCMDRIVER */
1032
1033 #endif  /* _linux_osl_h_ */