include/linux/compat-2.6.34.h

   1 #ifndef LINUX_26_34_COMPAT_H
   2 #define LINUX_26_34_COMPAT_H
   3
   4 #include <linux/version.h>
   5
   6 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34))
   7
   8 #include <linux/netdevice.h>
   9 #include <linux/usb.h>
  10
  11 #define netdev_mc_count(dev) ((dev)->mc_count)
  12 #define netdev_mc_empty(dev) (netdev_mc_count(dev) == 0)
  13
  14 #define netdev_for_each_mc_addr(mclist, dev) \
  15         for (mclist = dev->mc_list; mclist; mclist = mclist->next)
  16 /* source: include/linux/netdevice.h */
  17
  18
  19 /* Logging, debugging and troubleshooting/diagnostic helpers. */
  20
  21 /* netdev_printk helpers, similar to dev_printk */
  22
  23 #ifndef netdev_name
  24 #define netdev_name(__dev) \
  25         ((__dev->reg_state != NETREG_REGISTERED) ? \
  26                 "(unregistered net_device)" : __dev->name)
  27 #endif
  28
  29 #define netdev_printk(level, netdev, format, args...)           \
  30         dev_printk(level, (netdev)->dev.parent,                 \
  31                    "%s: " format,                               \
  32                    netdev_name(netdev), ##args)
  33
  34 #define netdev_emerg(dev, format, args...)                      \
  35         netdev_printk(KERN_EMERG, dev, format, ##args)
  36 #define netdev_alert(dev, format, args...)                      \
  37         netdev_printk(KERN_ALERT, dev, format, ##args)
  38 #define netdev_crit(dev, format, args...)                       \
  39         netdev_printk(KERN_CRIT, dev, format, ##args)
  40 #define netdev_err(dev, format, args...)                        \
  41         netdev_printk(KERN_ERR, dev, format, ##args)
  42 #define netdev_warn(dev, format, args...)                       \
  43         netdev_printk(KERN_WARNING, dev, format, ##args)
  44 #define netdev_notice(dev, format, args...)                     \
  45         netdev_printk(KERN_NOTICE, dev, format, ##args)
  46 #define netdev_info(dev, format, args...)                       \
  47         netdev_printk(KERN_INFO, dev, format, ##args)
  48
  49 #if defined(DEBUG)
  50 #define netdev_dbg(__dev, format, args...)                      \
  51         netdev_printk(KERN_DEBUG, __dev, format, ##args)
  52 #elif defined(CONFIG_DYNAMIC_DEBUG)
  53 #define netdev_dbg(__dev, format, args...)                      \
  54 do {                                                            \
  55         dynamic_dev_dbg((__dev)->dev.parent, "%s: " format,     \
  56                         netdev_name(__dev), ##args);            \
  57 } while (0)
  58 #else
  59 #define netdev_dbg(__dev, format, args...)                      \
  60 ({                                                              \
  61         if (0)                                                  \
  62                 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
  63         0;                                                      \
  64 })
  65 #endif
  66
  67 #if defined(VERBOSE_DEBUG)
  68 #define netdev_vdbg     netdev_dbg
  69 #else
  70
  71 #define netdev_vdbg(dev, format, args...)                       \
  72 ({                                                              \
  73         if (0)                                                  \
  74                 netdev_printk(KERN_DEBUG, dev, format, ##args); \
  75         0;                                                      \
  76 })
  77 #endif
  78
  79 /*
  80  * netdev_WARN() acts like dev_printk(), but with the key difference
  81  * of using a WARN/WARN_ON to get the message out, including the
  82  * file/line information and a backtrace.
  83  */
  84 #define netdev_WARN(dev, format, args...)                       \
  85         WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args);
  86
  87 /* netif printk helpers, similar to netdev_printk */
  88
  89 #define netif_printk(priv, type, level, dev, fmt, args...)      \
  90 do {                                                            \
  91         if (netif_msg_##type(priv))                             \
  92                 netdev_printk(level, (dev), fmt, ##args);       \
  93 } while (0)
  94
  95 #define netif_emerg(priv, type, dev, fmt, args...)              \
  96         netif_printk(priv, type, KERN_EMERG, dev, fmt, ##args)
  97 #define netif_alert(priv, type, dev, fmt, args...)              \
  98         netif_printk(priv, type, KERN_ALERT, dev, fmt, ##args)
  99 #define netif_crit(priv, type, dev, fmt, args...)               \
 100         netif_printk(priv, type, KERN_CRIT, dev, fmt, ##args)
 101 #define netif_err(priv, type, dev, fmt, args...)                \
 102         netif_printk(priv, type, KERN_ERR, dev, fmt, ##args)
 103 #define netif_warn(priv, type, dev, fmt, args...)               \
 104         netif_printk(priv, type, KERN_WARNING, dev, fmt, ##args)
 105 #define netif_notice(priv, type, dev, fmt, args...)             \
 106         netif_printk(priv, type, KERN_NOTICE, dev, fmt, ##args)
 107 #define netif_info(priv, type, dev, fmt, args...)               \
 108         netif_printk(priv, type, KERN_INFO, (dev), fmt, ##args)
 109
 110 #if defined(DEBUG)
 111 #define netif_dbg(priv, type, dev, format, args...)             \
 112         netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
 113 #elif defined(CONFIG_DYNAMIC_DEBUG)
 114 #define netif_dbg(priv, type, netdev, format, args...)          \
 115 do {                                                            \
 116         if (netif_msg_##type(priv))                             \
 117                 dynamic_dev_dbg((netdev)->dev.parent,           \
 118                                 "%s: " format,                  \
 119                                 netdev_name(netdev), ##args);   \
 120 } while (0)
 121 #else
 122 #define netif_dbg(priv, type, dev, format, args...)                     \
 123 ({                                                                      \
 124         if (0)                                                          \
 125                 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
 126         0;                                                              \
 127 })
 128 #endif
 129
 130 #if defined(VERBOSE_DEBUG)
 131 #define netif_vdbg      netdev_dbg
 132 #else
 133 #define netif_vdbg(priv, type, dev, format, args...)            \
 134 ({                                                              \
 135         if (0)                                                  \
 136                 netif_printk(KERN_DEBUG, dev, format, ##args);  \
 137         0;                                                      \
 138 })
 139 #endif
 140 /* source: include/linux/netdevice.h */
 141
 142
 143 static inline void device_lock(struct device *dev)
 144 {
 145 #if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP)
 146         mutex_lock(&dev->mutex);
 147 #else
 148         down(&dev->sem);
 149 #endif
 150 }
 151
 152 static inline int device_trylock(struct device *dev)
 153 {
 154 #if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP)
 155         return mutex_trylock(&dev->mutex);
 156 #else
 157         return down_trylock(&dev->sem);
 158 #endif
 159 }
 160
 161 static inline void device_unlock(struct device *dev)
 162 {
 163 #if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP)
 164         mutex_unlock(&dev->mutex);
 165 #else
 166         up(&dev->sem);
 167 #endif
 168 }
 169
 170 #if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
 171 #define PCMCIA_DEVICE_PROD_ID3(v3, vh3) { \
 172         .match_flags = PCMCIA_DEV_ID_MATCH_PROD_ID3, \
 173         .prod_id = { NULL, NULL, (v3), NULL },  \
 174         .prod_id_hash = { 0, 0, (vh3), 0 }, }
 175 #endif
 176
 177 #define rcu_dereference_check(p, c) rcu_dereference(p)
 178
 179 /**
 180  *      sysfs_attr_init - initialize a dynamically allocated sysfs attribute
 181  *      @attr: struct attribute to initialize
 182  *
 183  *      Initialize a dynamically allocated struct attribute so we can
 184  *      make lockdep happy.  This is a new requirement for attributes
 185  *      and initially this is only needed when lockdep is enabled.
 186  *      Lockdep gives a nice error when your attribute is added to
 187  *      sysfs if you don't have this.
 188  */
 189 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 190 #define sysfs_attr_init(attr)                           \
 191 do {                                                    \
 192         static struct lock_class_key __key;             \
 193                                                         \
 194         (attr)->key = &__key;                           \
 195 } while(0)
 196 #else
 197 #define sysfs_attr_init(attr) do {} while(0)
 198 #endif
 199
 200 /**
 201  *      sysfs_bin_attr_init - initialize a dynamically allocated bin_attribute
 202  *      @attr: struct bin_attribute to initialize
 203  *
 204  *      Initialize a dynamically allocated struct bin_attribute so we
 205  *      can make lockdep happy.  This is a new requirement for
 206  *      attributes and initially this is only needed when lockdep is
 207  *      enabled.  Lockdep gives a nice error when your attribute is
 208  *      added to sysfs if you don't have this.
 209  */
 210 #define sysfs_bin_attr_init(bin_attr) sysfs_attr_init(&(bin_attr)->attr)
 211
 212 #define usb_alloc_coherent(dev, size, mem_flags, dma) usb_buffer_alloc(dev, size, mem_flags, dma)
 213 #define usb_free_coherent(dev, size, addr, dma) usb_buffer_free(dev, size, addr, dma)
 214
 215 #ifdef CONFIG_NEED_DMA_MAP_STATE
 216 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)        dma_addr_t ADDR_NAME
 217 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)          __u32 LEN_NAME
 218 #define dma_unmap_addr(PTR, ADDR_NAME)           ((PTR)->ADDR_NAME)
 219 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  (((PTR)->ADDR_NAME) = (VAL))
 220 #define dma_unmap_len(PTR, LEN_NAME)             ((PTR)->LEN_NAME)
 221 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    (((PTR)->LEN_NAME) = (VAL))
 222 #else
 223 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)
 224 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)
 225 #define dma_unmap_addr(PTR, ADDR_NAME)           (0)
 226 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  do { } while (0)
 227 #define dma_unmap_len(PTR, LEN_NAME)             (0)
 228 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    do { } while (0)
 229 #endif
 230
 231 static inline int dma_set_coherent_mask(struct device *dev, u64 mask)
 232 {
 233         if (!dma_supported(dev, mask))
 234                 return -EIO;
 235         dev->coherent_dma_mask = mask;
 236         return 0;
 237 }
 238
 239 /* USB autosuspend and autoresume */
 240 static inline int usb_enable_autosuspend(struct usb_device *udev)
 241 { return 0; }
 242 static inline int usb_disable_autosuspend(struct usb_device *udev)
 243 { return 0; }
 244
 245 #define MMC_PM_KEEP_POWER       (1 << 0)        /* preserve card power during suspend */
 246 #define sdio_set_host_pm_flags(a, b) 0
 247
 248 #define rcu_dereference_protected(p, c) (p)
 249 #define rcu_access_pointer(p)   ACCESS_ONCE(p)
 250
 251 #define rcu_dereference_raw(p)  rcu_dereference(p)
 252
 253 #define KEY_WPS_BUTTON          0x211   /* WiFi Protected Setup key */
 254
 255 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34)) */
 256
 257 #endif /* LINUX_26_34_COMPAT_H */