drivers/staging/brcm80211/include/osl.h

   1 /*
   2  * Copyright (c) 2010 Broadcom Corporation
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #ifndef _osl_h_
  18 #define _osl_h_
  19
  20 /* osl handle type forward declaration */
  21 struct osl_info {
  22         uint pktalloced;        /* Number of allocated packet buffers */
  23         bool mmbus;             /* Bus supports memory-mapped registers */
  24         uint magic;
  25         void *pdev;
  26         uint bustype;
  27 };
  28
  29 typedef struct osl_dmainfo osldma_t;
  30
  31
  32 extern struct osl_info *osl_attach(void *pdev, uint bustype);
  33 extern void osl_detach(struct osl_info *osh);
  34
  35 extern u32 g_assert_type;
  36
  37 #if defined(BCMDBG_ASSERT)
  38 #define ASSERT(exp) \
  39           do { if (!(exp)) osl_assert(#exp, __FILE__, __LINE__); } while (0)
  40 extern void osl_assert(char *exp, char *file, int line);
  41 #else
  42 #define ASSERT(exp)     do {} while (0)
  43 #endif  /* defined(BCMDBG_ASSERT) */
  44
  45 /* PCI device bus # and slot # */
  46 #define OSL_PCI_BUS(osh)        osl_pci_bus(osh)
  47 #define OSL_PCI_SLOT(osh)       osl_pci_slot(osh)
  48 extern uint osl_pci_bus(struct osl_info *osh);
  49 extern uint osl_pci_slot(struct osl_info *osh);
  50
  51 #define BUS_SWAP32(v)           (v)
  52
  53 /* map/unmap direction */
  54 #define DMA_TX  1               /* TX direction for DMA */
  55 #define DMA_RX  2               /* RX direction for DMA */
  56
  57 /* register access macros */
  58 #if defined(BCMSDIO)
  59 #ifdef BRCM_FULLMAC
  60 #include <bcmsdh.h>
  61 #endif
  62 #define OSL_WRITE_REG(r, v) \
  63                 (bcmsdh_reg_write(NULL, (unsigned long)(r), sizeof(*(r)), (v)))
  64 #define OSL_READ_REG(r) \
  65                 (bcmsdh_reg_read(NULL, (unsigned long)(r), sizeof(*(r))))
  66 #endif
  67
  68 #if defined(BCMSDIO)
  69 #define SELECT_BUS_WRITE(mmap_op, bus_op) bus_op
  70 #define SELECT_BUS_READ(mmap_op, bus_op) bus_op
  71 #else
  72 #define SELECT_BUS_WRITE(mmap_op, bus_op) mmap_op
  73 #define SELECT_BUS_READ(mmap_op, bus_op) mmap_op
  74 #endif
  75
  76 /* the largest reasonable packet buffer driver uses for ethernet MTU in bytes */
  77 #define PKTBUFSZ        2048
  78
  79 #define OSL_SYSUPTIME()         ((u32)jiffies * (1000 / HZ))
  80 #ifdef BRCM_FULLMAC
  81 #include <linux/kernel.h>       /* for vsn/printf's */
  82 #include <linux/string.h>       /* for mem*, str* */
  83 #endif
  84
  85 /* register access macros */
  86 #ifndef IL_BIGENDIAN
  87 #ifndef __mips__
  88 #define R_REG(r) (\
  89         SELECT_BUS_READ(sizeof(*(r)) == sizeof(u8) ? \
  90         readb((volatile u8*)(r)) : \
  91         sizeof(*(r)) == sizeof(u16) ? readw((volatile u16*)(r)) : \
  92         readl((volatile u32*)(r)), OSL_READ_REG(r)) \
  93 )
  94 #else                           /* __mips__ */
  95 #define R_REG(r) (\
  96         SELECT_BUS_READ( \
  97                 ({ \
  98                         __typeof(*(r)) __osl_v; \
  99                         __asm__ __volatile__("sync"); \
 100                         switch (sizeof(*(r))) { \
 101                         case sizeof(u8): \
 102                                 __osl_v = readb((volatile u8*)(r)); \
 103                                 break; \
 104                         case sizeof(u16): \
 105                                 __osl_v = readw((volatile u16*)(r)); \
 106                                 break; \
 107                         case sizeof(u32): \
 108                                 __osl_v = \
 109                                 readl((volatile u32*)(r)); \
 110                                 break; \
 111                         } \
 112                         __asm__ __volatile__("sync"); \
 113                         __osl_v; \
 114                 }), \
 115                 ({ \
 116                         __typeof(*(r)) __osl_v; \
 117                         __asm__ __volatile__("sync"); \
 118                         __osl_v = OSL_READ_REG(r); \
 119                         __asm__ __volatile__("sync"); \
 120                         __osl_v; \
 121                 })) \
 122 )
 123 #endif                          /* __mips__ */
 124
 125 #define W_REG(r, v) do { \
 126         SELECT_BUS_WRITE( \
 127                 switch (sizeof(*(r))) { \
 128                 case sizeof(u8): \
 129                         writeb((u8)(v), (volatile u8*)(r)); break; \
 130                 case sizeof(u16): \
 131                         writew((u16)(v), (volatile u16*)(r)); break; \
 132                 case sizeof(u32): \
 133                         writel((u32)(v), (volatile u32*)(r)); break; \
 134                 }, \
 135                 (OSL_WRITE_REG(r, v))); \
 136         } while (0)
 137 #else                           /* IL_BIGENDIAN */
 138 #define R_REG(r) (\
 139         SELECT_BUS_READ( \
 140                 ({ \
 141                         __typeof(*(r)) __osl_v; \
 142                         switch (sizeof(*(r))) { \
 143                         case sizeof(u8): \
 144                                 __osl_v = \
 145                                 readb((volatile u8*)((r)^3)); \
 146                                 break; \
 147                         case sizeof(u16): \
 148                                 __osl_v = \
 149                                 readw((volatile u16*)((r)^2)); \
 150                                 break; \
 151                         case sizeof(u32): \
 152                                 __osl_v = readl((volatile u32*)(r)); \
 153                                 break; \
 154                         } \
 155                         __osl_v; \
 156                 }), \
 157                 OSL_READ_REG(r)) \
 158 )
 159 #define W_REG(r, v) do { \
 160         SELECT_BUS_WRITE( \
 161                 switch (sizeof(*(r))) { \
 162                 case sizeof(u8):        \
 163                         writeb((u8)(v), \
 164                         (volatile u8*)((r)^3)); break; \
 165                 case sizeof(u16):       \
 166                         writew((u16)(v), \
 167                         (volatile u16*)((r)^2)); break; \
 168                 case sizeof(u32):       \
 169                         writel((u32)(v), \
 170                         (volatile u32*)(r)); break; \
 171                 }, \
 172                 (OSL_WRITE_REG(r, v))); \
 173         } while (0)
 174 #endif                          /* IL_BIGENDIAN */
 175
 176
 177 #endif /* _osl_h_ */