2035e35dbbf04dde017c1887680662847b81506e
[~tnikolova/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 void init_compat_mmc_pm_flags(void);
28
29 #define netdev_mc_count(dev) ((dev)->mc_count)
30 #define netdev_mc_empty(dev) (netdev_mc_count(dev) == 0)
31
32 #define netdev_for_each_mc_addr(mclist, dev) \
33         for (mclist = dev->mc_list; mclist; mclist = mclist->next)
34 /* source: include/linux/netdevice.h */
35
36
37 /* Logging, debugging and troubleshooting/diagnostic helpers. */
38
39 /* netdev_printk helpers, similar to dev_printk */
40
41 #ifndef netdev_name
42 #define netdev_name(__dev) \
43         ((__dev->reg_state != NETREG_REGISTERED) ? \
44                 "(unregistered net_device)" : __dev->name)
45 #endif
46
47 #define netdev_printk(level, netdev, format, args...)           \
48         dev_printk(level, (netdev)->dev.parent,                 \
49                    "%s: " format,                               \
50                    netdev_name(netdev), ##args)
51
52 #define netdev_emerg(dev, format, args...)                      \
53         netdev_printk(KERN_EMERG, dev, format, ##args)
54 #define netdev_alert(dev, format, args...)                      \
55         netdev_printk(KERN_ALERT, dev, format, ##args)
56 #define netdev_crit(dev, format, args...)                       \
57         netdev_printk(KERN_CRIT, dev, format, ##args)
58 #define netdev_err(dev, format, args...)                        \
59         netdev_printk(KERN_ERR, dev, format, ##args)
60 #define netdev_warn(dev, format, args...)                       \
61         netdev_printk(KERN_WARNING, dev, format, ##args)
62 #define netdev_notice(dev, format, args...)                     \
63         netdev_printk(KERN_NOTICE, dev, format, ##args)
64 #define netdev_info(dev, format, args...)                       \
65         netdev_printk(KERN_INFO, dev, format, ##args)
66
67 /* mask netdev_dbg as RHEL6 backports this */
68 #if !defined(netdev_dbg)
69
70 #if defined(DEBUG)
71 #define netdev_dbg(__dev, format, args...)                      \
72         netdev_printk(KERN_DEBUG, __dev, format, ##args)
73 #elif defined(CONFIG_DYNAMIC_DEBUG)
74 #define netdev_dbg(__dev, format, args...)                      \
75 do {                                                            \
76         dynamic_dev_dbg((__dev)->dev.parent, "%s: " format,     \
77                         netdev_name(__dev), ##args);            \
78 } while (0)
79 #else
80 #define netdev_dbg(__dev, format, args...)                      \
81 ({                                                              \
82         if (0)                                                  \
83                 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
84         0;                                                      \
85 })
86 #endif
87
88 #endif
89
90 /* mask netdev_vdbg as RHEL6 backports this */
91 #if !defined(netdev_dbg)
92
93 #if defined(VERBOSE_DEBUG)
94 #define netdev_vdbg     netdev_dbg
95 #else
96
97 #define netdev_vdbg(dev, format, args...)                       \
98 ({                                                              \
99         if (0)                                                  \
100                 netdev_printk(KERN_DEBUG, dev, format, ##args); \
101         0;                                                      \
102 })
103 #endif
104
105 #endif
106
107 /*
108  * netdev_WARN() acts like dev_printk(), but with the key difference
109  * of using a WARN/WARN_ON to get the message out, including the
110  * file/line information and a backtrace.
111  */
112 #define netdev_WARN(dev, format, args...)                       \
113         WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args);
114
115 /* netif printk helpers, similar to netdev_printk */
116
117 #define netif_printk(priv, type, level, dev, fmt, args...)      \
118 do {                                                            \
119         if (netif_msg_##type(priv))                             \
120                 netdev_printk(level, (dev), fmt, ##args);       \
121 } while (0)
122
123 #define netif_emerg(priv, type, dev, fmt, args...)              \
124         netif_printk(priv, type, KERN_EMERG, dev, fmt, ##args)
125 #define netif_alert(priv, type, dev, fmt, args...)              \
126         netif_printk(priv, type, KERN_ALERT, dev, fmt, ##args)
127 #define netif_crit(priv, type, dev, fmt, args...)               \
128         netif_printk(priv, type, KERN_CRIT, dev, fmt, ##args)
129 #define netif_err(priv, type, dev, fmt, args...)                \
130         netif_printk(priv, type, KERN_ERR, dev, fmt, ##args)
131 #define netif_warn(priv, type, dev, fmt, args...)               \
132         netif_printk(priv, type, KERN_WARNING, dev, fmt, ##args)
133 #define netif_notice(priv, type, dev, fmt, args...)             \
134         netif_printk(priv, type, KERN_NOTICE, dev, fmt, ##args)
135 #define netif_info(priv, type, dev, fmt, args...)               \
136         netif_printk(priv, type, KERN_INFO, (dev), fmt, ##args)
137
138 /* mask netif_dbg as RHEL6 backports this */
139 #if !defined(netif_dbg)
140
141 #if defined(DEBUG)
142 #define netif_dbg(priv, type, dev, format, args...)             \
143         netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
144 #elif defined(CONFIG_DYNAMIC_DEBUG)
145 #define netif_dbg(priv, type, netdev, format, args...)          \
146 do {                                                            \
147         if (netif_msg_##type(priv))                             \
148                 dynamic_dev_dbg((netdev)->dev.parent,           \
149                                 "%s: " format,                  \
150                                 netdev_name(netdev), ##args);   \
151 } while (0)
152 #else
153 #define netif_dbg(priv, type, dev, format, args...)                     \
154 ({                                                                      \
155         if (0)                                                          \
156                 netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
157         0;                                                              \
158 })
159 #endif
160
161 #endif
162
163 /* mask netif_vdbg as RHEL6 backports this */
164 #if !defined(netif_vdbg)
165
166 #if defined(VERBOSE_DEBUG)
167 #define netif_vdbg      netdev_dbg
168 #else
169 #define netif_vdbg(priv, type, dev, format, args...)            \
170 ({                                                              \
171         if (0)                                                  \
172                 netif_printk(KERN_DEBUG, dev, format, ##args);  \
173         0;                                                      \
174 })
175 #endif
176 #endif
177 /* source: include/linux/netdevice.h */
178
179
180 static inline void device_lock(struct device *dev)
181 {
182 #if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP)
183         mutex_lock(&dev->mutex);
184 #else
185         down(&dev->sem);
186 #endif
187 }
188
189 static inline int device_trylock(struct device *dev)
190 {
191 #if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP)
192         return mutex_trylock(&dev->mutex);
193 #else
194         return down_trylock(&dev->sem);
195 #endif
196 }
197
198 static inline void device_unlock(struct device *dev)
199 {
200 #if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP)
201         mutex_unlock(&dev->mutex);
202 #else
203         up(&dev->sem);
204 #endif
205 }
206
207 #if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
208 #define PCMCIA_DEVICE_PROD_ID3(v3, vh3) { \
209         .match_flags = PCMCIA_DEV_ID_MATCH_PROD_ID3, \
210         .prod_id = { NULL, NULL, (v3), NULL },  \
211         .prod_id_hash = { 0, 0, (vh3), 0 }, }
212 #endif
213
214 #define rcu_dereference_check(p, c) rcu_dereference(p)
215
216 /**
217  *      sysfs_attr_init - initialize a dynamically allocated sysfs attribute
218  *      @attr: struct attribute to initialize
219  *
220  *      Initialize a dynamically allocated struct attribute so we can
221  *      make lockdep happy.  This is a new requirement for attributes
222  *      and initially this is only needed when lockdep is enabled.
223  *      Lockdep gives a nice error when your attribute is added to
224  *      sysfs if you don't have this.
225  */
226 #ifdef CONFIG_DEBUG_LOCK_ALLOC
227 #define sysfs_attr_init(attr)                           \
228 do {                                                    \
229         static struct lock_class_key __key;             \
230                                                         \
231         (attr)->key = &__key;                           \
232 } while(0)
233 #else
234 #define sysfs_attr_init(attr) do {} while(0)
235 #endif
236
237 /**
238  *      sysfs_bin_attr_init - initialize a dynamically allocated bin_attribute
239  *      @attr: struct bin_attribute to initialize
240  *
241  *      Initialize a dynamically allocated struct bin_attribute so we
242  *      can make lockdep happy.  This is a new requirement for
243  *      attributes and initially this is only needed when lockdep is
244  *      enabled.  Lockdep gives a nice error when your attribute is
245  *      added to sysfs if you don't have this.
246  */
247 #ifndef sysfs_bin_attr_init
248 #define sysfs_bin_attr_init(bin_attr) sysfs_attr_init(&(bin_attr)->attr)
249 #endif /* sysfs_bin_attr_init */
250
251 #define usb_alloc_coherent(dev, size, mem_flags, dma) usb_buffer_alloc(dev, size, mem_flags, dma)
252 #define usb_free_coherent(dev, size, addr, dma) usb_buffer_free(dev, size, addr, dma)
253
254 /* only include this if DEFINE_DMA_UNMAP_ADDR is not set as debian squeeze also backports this  */
255 #ifndef DEFINE_DMA_UNMAP_ADDR
256 #ifdef CONFIG_NEED_DMA_MAP_STATE
257 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)        dma_addr_t ADDR_NAME
258 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)          __u32 LEN_NAME
259 #define dma_unmap_addr(PTR, ADDR_NAME)           ((PTR)->ADDR_NAME)
260 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  (((PTR)->ADDR_NAME) = (VAL))
261 #define dma_unmap_len(PTR, LEN_NAME)             ((PTR)->LEN_NAME)
262 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    (((PTR)->LEN_NAME) = (VAL))
263 #else
264 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)
265 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)
266 #define dma_unmap_addr(PTR, ADDR_NAME)           (0)
267 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  do { } while (0)
268 #define dma_unmap_len(PTR, LEN_NAME)             (0)
269 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    do { } while (0)
270 #endif
271 #endif
272
273 /* mask dma_set_coherent_mask as debian squeeze also backports this */
274 #define dma_set_coherent_mask(a, b) compat_dma_set_coherent_mask(a, b)
275
276 static inline int dma_set_coherent_mask(struct device *dev, u64 mask)
277 {
278         if (!dma_supported(dev, mask))
279                 return -EIO;
280         dev->coherent_dma_mask = mask;
281         return 0;
282 }
283
284 /* USB autosuspend and autoresume */
285 static inline int usb_enable_autosuspend(struct usb_device *udev)
286 { return 0; }
287 static inline int usb_disable_autosuspend(struct usb_device *udev)
288 { return 0; }
289
290 #ifndef CONFIG_COMPAT_RHEL_6_4
291 #define rcu_dereference_protected(p, c) (p)
292 #define rcu_access_pointer(p)   ACCESS_ONCE(p)
293 #define rcu_dereference_raw(p)  rcu_dereference(p)
294 #endif /* CONFIG_COMPAT_RHEL_6_4 */
295
296 #define KEY_WPS_BUTTON          0x211   /* WiFi Protected Setup key */
297
298 /*
299  * This looks more complex than it should be. But we need to
300  * get the type for the ~ right in round_down (it needs to be
301  * as wide as the result!), and we want to evaluate the macro
302  * arguments just once each.
303  */
304 #define __round_mask(x, y) ((__typeof__(x))((y)-1))
305 #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
306 #define round_down(x, y) ((x) & ~__round_mask(x, y))
307
308 static inline int rcu_read_lock_held(void)
309 {
310         return 1;
311 }
312
313 #ifdef CONFIG_PROVE_LOCKING
314 /*
315  * Obviously, this is wrong.  But the base kernel will have rtnl_mutex
316  * declared static, with no way to access it.  I think this is the best
317  * we can do...
318  */
319 static inline int lockdep_rtnl_is_held(void)
320 {
321         return 1;
322 }
323 #endif /* #ifdef CONFIG_PROVE_LOCKING */
324
325 #else /* Kernels >= 2.6.34 */
326
327 static inline void init_compat_mmc_pm_flags(void)
328 {
329 }
330
331 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34)) */
332
333
334 #endif /* LINUX_26_34_COMPAT_H */