Added support for RHEL6.5
[compat-rdma/compat.git] / 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 #include <linux/mmc/sdio_func.h>
11
12 /*
13  * Backports da68c4eb25
14  * sdio: introduce API for special power management features
15  *
16  * We wimply carry around the data structures and flags, and
17  * make the host return no flags set by the driver.
18  */
19 typedef unsigned int mmc_pm_flag_t;
20
21 #define MMC_PM_KEEP_POWER      (1 << 0)        /* preserve card power during suspend */
22 #define MMC_PM_WAKE_SDIO_IRQ   (1 << 1)        /* wake up host system on SDIO IRQ assertion */
23
24 extern mmc_pm_flag_t sdio_get_host_pm_caps(struct sdio_func *func);
25 extern int sdio_set_host_pm_flags(struct sdio_func *func, mmc_pm_flag_t flags);
26
27 #define netdev_uc_count(dev) ((dev)->uc.count)
28 #define netdev_uc_empty(dev) ((dev)->uc.count == 0)
29 #define netdev_for_each_uc_addr(ha, dev) \
30         list_for_each_entry(ha, &dev->uc.list, list)
31
32 #define netdev_mc_count(dev) ((dev)->mc_count)
33 #define netdev_mc_empty(dev) (netdev_mc_count(dev) == 0)
34
35 #define netdev_for_each_mc_addr(mclist, dev) \
36         for (mclist = dev->mc_list; mclist; mclist = mclist->next)
37 /* source: include/linux/netdevice.h */
38
39
40 /* Logging, debugging and troubleshooting/diagnostic helpers. */
41
42 /* netdev_printk helpers, similar to dev_printk */
43
44 #ifndef netdev_name
45 #define netdev_name(__dev) \
46         ((__dev->reg_state != NETREG_REGISTERED) ? \
47                 "(unregistered net_device)" : __dev->name)
48 #endif
49
50 #define netdev_printk(level, netdev, format, args...)           \
51         dev_printk(level, (netdev)->dev.parent,                 \
52                    "%s: " format,                               \
53                    netdev_name(netdev), ##args)
54
55 #define netdev_emerg(dev, format, args...)                      \
56         netdev_printk(KERN_EMERG, dev, format, ##args)
57 #define netdev_alert(dev, format, args...)                      \
58         netdev_printk(KERN_ALERT, dev, format, ##args)
59 #define netdev_crit(dev, format, args...)                       \
60         netdev_printk(KERN_CRIT, dev, format, ##args)
61 #define netdev_err(dev, format, args...)                        \
62         netdev_printk(KERN_ERR, dev, format, ##args)
63 #define netdev_warn(dev, format, args...)                       \
64         netdev_printk(KERN_WARNING, dev, format, ##args)
65 #define netdev_notice(dev, format, args...)                     \
66         netdev_printk(KERN_NOTICE, dev, format, ##args)
67 #define netdev_info(dev, format, args...)                       \
68         netdev_printk(KERN_INFO, dev, format, ##args)
69
70 /* mask netdev_dbg as RHEL6 backports this */
71 #if !defined(netdev_dbg)
72
73 #if defined(DEBUG)
74 #define netdev_dbg(__dev, format, args...)                      \
75         netdev_printk(KERN_DEBUG, __dev, format, ##args)
76 #elif defined(CONFIG_DYNAMIC_DEBUG)
77 #define netdev_dbg(__dev, format, args...)                      \
78 do {                                                            \
79         dynamic_dev_dbg((__dev)->dev.parent, "%s: " format,     \
80                         netdev_name(__dev), ##args);            \
81 } while (0)
82 #else
83 #define netdev_dbg(__dev, format, args...)                      \
84 ({                                                              \
85         if (0)                                                  \
86                 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
87         0;                                                      \
88 })
89 #endif
90
91 #endif
92
93 /* mask netdev_vdbg as RHEL6 backports this */
94 #if !defined(netdev_dbg)
95
96 #if defined(VERBOSE_DEBUG)
97 #define netdev_vdbg     netdev_dbg
98 #else
99
100 #define netdev_vdbg(dev, format, args...)                       \
101 ({                                                              \
102         if (0)                                                  \
103                 netdev_printk(KERN_DEBUG, dev, format, ##args); \
104         0;                                                      \
105 })
106 #endif
107
108 #endif
109
110 /*
111  * netdev_WARN() acts like dev_printk(), but with the key difference
112  * of using a WARN/WARN_ON to get the message out, including the
113  * file/line information and a backtrace.
114  */
115 #define netdev_WARN(dev, format, args...)                       \
116         WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args);
117
118 /* netif printk helpers, similar to netdev_printk */
119
120 #define netif_printk(priv, type, level, dev, fmt, args...)      \
121 do {                                                            \
122         if (netif_msg_##type(priv))                             \
123                 netdev_printk(level, (dev), fmt, ##args);       \
124 } while (0)
125
126 #define netif_emerg(priv, type, dev, fmt, args...)              \
127         netif_printk(priv, type, KERN_EMERG, dev, fmt, ##args)
128 #define netif_alert(priv, type, dev, fmt, args...)              \
129         netif_printk(priv, type, KERN_ALERT, dev, fmt, ##args)
130 #define netif_crit(priv, type, dev, fmt, args...)               \
131         netif_printk(priv, type, KERN_CRIT, dev, fmt, ##args)
132 #define netif_err(priv, type, dev, fmt, args...)                \
133         netif_printk(priv, type, KERN_ERR, dev, fmt, ##args)
134 #define netif_warn(priv, type, dev, fmt, args...)               \
135         netif_printk(priv, type, KERN_WARNING, dev, fmt, ##args)
136 #define netif_notice(priv, type, dev, fmt, args...)             \
137         netif_printk(priv, type, KERN_NOTICE, dev, fmt, ##args)
138 #define netif_info(priv, type, dev, fmt, args...)               \
139         netif_printk(priv, type, KERN_INFO, (dev), fmt, ##args)
140
141 /* mask netif_dbg as RHEL6 backports this */
142 #if !defined(netif_dbg)
143
144 #if defined(DEBUG)
145 #define netif_dbg(priv, type, dev, format, args...)             \
146         netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
147 #elif defined(CONFIG_DYNAMIC_DEBUG)
148 #define netif_dbg(priv, type, netdev, format, args...)          \
149 do {                                                            \
150         if (netif_msg_##type(priv))                             \
151                 dynamic_dev_dbg((netdev)->dev.parent,           \
152                                 "%s: " format,                  \
153                                 netdev_name(netdev), ##args);   \
154 } while (0)
155 #else
156 #define netif_dbg(priv, type, dev, format, args...)                     \
157 ({                                                                      \
158         if (0)                                                          \
159                 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
160         0;                                                              \
161 })
162 #endif
163
164 #endif
165
166 /* mask netif_vdbg as RHEL6 backports this */
167 #if !defined(netif_vdbg)
168
169 #if defined(VERBOSE_DEBUG)
170 #define netif_vdbg      netdev_dbg
171 #else
172 #define netif_vdbg(priv, type, dev, format, args...)            \
173 ({                                                              \
174         if (0)                                                  \
175                 netif_printk(KERN_DEBUG, dev, format, ##args);  \
176         0;                                                      \
177 })
178 #endif
179 #endif
180 /* source: include/linux/netdevice.h */
181
182
183 #define device_lock LINUX_BACKPORT(device_lock)
184 static inline void device_lock(struct device *dev)
185 {
186 #if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP)
187         mutex_lock(&dev->mutex);
188 #else
189         down(&dev->sem);
190 #endif
191 }
192
193 #define device_trylock LINUX_BACKPORT(device_trylock)
194 static inline int device_trylock(struct device *dev)
195 {
196 #if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP)
197         return mutex_trylock(&dev->mutex);
198 #else
199         return down_trylock(&dev->sem);
200 #endif
201 }
202
203 #define device_unlock LINUX_BACKPORT(device_unlock)
204 static inline void device_unlock(struct device *dev)
205 {
206 #if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP)
207         mutex_unlock(&dev->mutex);
208 #else
209         up(&dev->sem);
210 #endif
211 }
212
213 #if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
214 #define PCMCIA_DEVICE_PROD_ID3(v3, vh3) { \
215         .match_flags = PCMCIA_DEV_ID_MATCH_PROD_ID3, \
216         .prod_id = { NULL, NULL, (v3), NULL },  \
217         .prod_id_hash = { 0, 0, (vh3), 0 }, }
218 #endif
219
220 #define rcu_dereference_check(p, c) rcu_dereference(p)
221
222 #ifndef sysfs_attr_init
223 /**
224  *      sysfs_attr_init - initialize a dynamically allocated sysfs attribute
225  *      @attr: struct attribute to initialize
226  */
227 #define sysfs_attr_init(attr) do {} while(0)
228 #endif /* sysfs_attr_init */
229
230 /**
231  *      sysfs_bin_attr_init - initialize a dynamically allocated bin_attribute
232  *      @attr: struct bin_attribute to initialize
233  *
234  *      Initialize a dynamically allocated struct bin_attribute so we
235  *      can make lockdep happy.  This is a new requirement for
236  *      attributes and initially this is only needed when lockdep is
237  *      enabled.  Lockdep gives a nice error when your attribute is
238  *      added to sysfs if you don't have this.
239  */
240 #ifndef sysfs_bin_attr_init
241 #define sysfs_bin_attr_init(bin_attr) sysfs_attr_init(&(bin_attr)->attr)
242 #endif /* sysfs_bin_attr_init */
243
244 #define usb_alloc_coherent(dev, size, mem_flags, dma) usb_buffer_alloc(dev, size, mem_flags, dma)
245 #define usb_free_coherent(dev, size, addr, dma) usb_buffer_free(dev, size, addr, dma)
246
247 /* only include this if DEFINE_DMA_UNMAP_ADDR is not set as debian squeeze also backports this  */
248 #ifndef DEFINE_DMA_UNMAP_ADDR
249 #ifdef CONFIG_NEED_DMA_MAP_STATE
250 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)        dma_addr_t ADDR_NAME
251 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)          __u32 LEN_NAME
252 #define dma_unmap_addr(PTR, ADDR_NAME)           ((PTR)->ADDR_NAME)
253 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  (((PTR)->ADDR_NAME) = (VAL))
254 #define dma_unmap_len(PTR, LEN_NAME)             ((PTR)->LEN_NAME)
255 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    (((PTR)->LEN_NAME) = (VAL))
256 #else
257 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)
258 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)
259 #define dma_unmap_addr(PTR, ADDR_NAME)           (0)
260 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  do { } while (0)
261 #define dma_unmap_len(PTR, LEN_NAME)             (0)
262 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    do { } while (0)
263 #endif
264 #endif
265
266 /* mask dma_set_coherent_mask as debian squeeze also backports this */
267 #define dma_set_coherent_mask(a, b) compat_dma_set_coherent_mask(a, b)
268
269 static inline int dma_set_coherent_mask(struct device *dev, u64 mask)
270 {
271         if (!dma_supported(dev, mask))
272                 return -EIO;
273         dev->coherent_dma_mask = mask;
274         return 0;
275 }
276
277 /* USB autosuspend and autoresume */
278 static inline int usb_enable_autosuspend(struct usb_device *udev)
279 { return 0; }
280 static inline int usb_disable_autosuspend(struct usb_device *udev)
281 { return 0; }
282
283 #ifndef rcu_dereference_protected
284 #define rcu_dereference_protected(p, c) (p)
285 #endif
286
287 #define rcu_access_pointer(p)   ACCESS_ONCE(p)
288
289 #define rcu_dereference_raw(p)  rcu_dereference(p)
290
291 #define KEY_WPS_BUTTON          0x211   /* WiFi Protected Setup key */
292
293 /*
294  * This looks more complex than it should be. But we need to
295  * get the type for the ~ right in round_down (it needs to be
296  * as wide as the result!), and we want to evaluate the macro
297  * arguments just once each.
298  */
299 #define __round_mask(x, y) ((__typeof__(x))((y)-1))
300 #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
301 #define round_down(x, y) ((x) & ~__round_mask(x, y))
302
303 #ifdef CONFIG_PROVE_LOCKING
304 /*
305  * Obviously, this is wrong.  But the base kernel will have rtnl_mutex
306  * declared static, with no way to access it.  I think this is the best
307  * we can do...
308  */
309 static inline int lockdep_rtnl_is_held(void)
310 {
311         return 1;
312 }
313 #endif /* #ifdef CONFIG_PROVE_LOCKING */
314
315 #ifndef NETIF_F_NTUPLE
316 #define NETIF_F_NTUPLE          (1 << 27) /* N-tuple filters supported */
317 #endif
318
319
320 #ifndef PCI_VPD_LRDT
321 #define PCI_VPD_LRDT                    0x80    /* Large Resource Data Type */
322 #define PCI_VPD_LRDT_ID(x)              (x | PCI_VPD_LRDT)
323
324 /* Large Resource Data Type Tag Item Names */
325 #define PCI_VPD_LTIN_ID_STRING          0x02    /* Identifier String */
326 #define PCI_VPD_LTIN_RO_DATA            0x10    /* Read-Only Data */
327 #define PCI_VPD_LTIN_RW_DATA            0x11    /* Read-Write Data */
328
329 #define PCI_VPD_LRDT_ID_STRING          PCI_VPD_LRDT_ID(PCI_VPD_LTIN_ID_STRING)
330 #define PCI_VPD_LRDT_RO_DATA            PCI_VPD_LRDT_ID(PCI_VPD_LTIN_RO_DATA)
331 #define PCI_VPD_LRDT_RW_DATA            PCI_VPD_LRDT_ID(PCI_VPD_LTIN_RW_DATA)
332 #define PCI_VPD_LRDT_TAG_SIZE           3
333 #define PCI_VPD_SRDT_TAG_SIZE           1
334
335 #define PCI_VPD_INFO_FLD_HDR_SIZE       3
336
337 /* Small Resource Data Type Tag Item Names */
338 #define PCI_VPD_STIN_END                0x78    /* End */
339
340 #define PCI_VPD_SRDT_END                PCI_VPD_STIN_END
341
342 #define PCI_VPD_SRDT_TIN_MASK           0x78
343 #define PCI_VPD_SRDT_LEN_MASK           0x07
344 #endif /* PCI_VPD_LRDT */
345
346 /**
347  * pci_vpd_info_field_size - Extracts the information field length
348  * @lrdt: Pointer to the beginning of an information field header
349  *
350  * Returns the extracted information field length.
351  */
352 #define pci_vpd_info_field_size LINUX_BACKPORT(pci_vpd_info_field_size)
353 static inline u8 pci_vpd_info_field_size(const u8 *info_field)
354 {
355         return info_field[2];
356 }
357
358 /**
359  * pci_vpd_lrdt_size - Extracts the Large Resource Data Type length
360  * @lrdt: Pointer to the beginning of the Large Resource Data Type tag
361  *
362  * Returns the extracted Large Resource Data Type length.
363  */
364 #define pci_vpd_lrdt_size LINUX_BACKPORT(pci_vpd_lrdt_size)
365 static inline u16 pci_vpd_lrdt_size(const u8 *lrdt)
366 {
367         return (u16)lrdt[1] + ((u16)lrdt[2] << 8);
368 }
369
370 /**
371  * pci_vpd_find_info_keyword - Locates an information field keyword in the VPD
372  * @buf: Pointer to buffered vpd data
373  * @off: The offset into the buffer at which to begin the search
374  * @len: The length of the buffer area, relative to off, in which to search
375  * @kw: The keyword to search for
376  *
377  * Returns the index where the information field keyword was found or
378  * -ENOENT otherwise.
379  */
380 #define pci_vpd_find_info_keyword LINUX_BACKPORT(pci_vpd_find_info_keyword)
381 int pci_vpd_find_info_keyword(const u8 *buf, unsigned int off,
382                               unsigned int len, const char *kw);
383
384 /**
385  * pci_vpd_find_tag - Locates the Resource Data Type tag provided
386  * @buf: Pointer to buffered vpd data
387  * @off: The offset into the buffer at which to begin the search
388  * @len: The length of the vpd buffer
389  * @rdt: The Resource Data Type to search for
390  *
391  * Returns the index where the Resource Data Type was found or
392  * -ENOENT otherwise.
393  */
394 #define pci_vpd_find_tag LINUX_BACKPORT(pci_vpd_find_tag)
395 int pci_vpd_find_tag(const u8 *buf, unsigned int off, unsigned int len, u8 rdt);
396
397 /**
398  * pci_vpd_srdt_size - Extracts the Small Resource Data Type length
399  * @lrdt: Pointer to the beginning of the Small Resource Data Type tag
400  *
401  * Returns the extracted Small Resource Data Type length.
402  */
403 #define pci_vpd_srdt_size LINUX_BACKPORT(pci_vpd_srdt_size)
404 static inline u8 pci_vpd_srdt_size(const u8 *srdt)
405 {
406         return (*srdt) & PCI_VPD_SRDT_LEN_MASK;
407 }
408
409 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34)) */
410
411
412 #endif /* LINUX_26_34_COMPAT_H */