ece825de1437ae0140850ca675b0890bb0effb7e
[compat-rdma/compat.git] / include / linux / compat-2.6.27.h
1 #ifndef LINUX_26_27_COMPAT_H
2 #define LINUX_26_27_COMPAT_H
3
4 #include <linux/version.h>
5
6 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27))
7
8 #include <linux/debugfs.h>
9 #include <linux/list.h>
10 #include <linux/pci.h>
11 #include <linux/dma-mapping.h>
12 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
13 #include <linux/mmc/sdio.h>
14 #include <linux/mmc/sdio_func.h>
15 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */
16 #include <linux/netdevice.h>
17 #include <linux/workqueue.h>
18 #include <net/iw_handler.h>
19 #include <asm-generic/bug.h>
20 #include <linux/wireless.h>
21 #include <linux/skbuff.h>
22 #include <net/sch_generic.h>
23 #include <linux/ethtool.h>
24
25 static inline struct net_device *qdisc_dev(const struct Qdisc *qdisc)
26 {
27         return qdisc->dev;
28 }
29
30 /*
31  * Backports 378a2f09 and c27f339a
32  * This may need a bit more work.
33  */
34 enum net_xmit_qdisc_t {
35         __NET_XMIT_STOLEN = 0x00010000,
36         __NET_XMIT_BYPASS = 0x00020000,
37 };
38
39 struct qdisc_skb_cb {
40         unsigned int            pkt_len;
41         char                    data[];
42 };
43
44 static inline struct qdisc_skb_cb *qdisc_skb_cb(struct sk_buff *skb)
45 {
46         return (struct qdisc_skb_cb *)skb->cb;
47 }
48
49 static inline unsigned int qdisc_pkt_len(struct sk_buff *skb)
50 {
51         return qdisc_skb_cb(skb)->pkt_len;
52 }
53
54 #define PCI_PM_CAP_PME_SHIFT    11
55
56 /* I can't find a more suitable replacement... */
57 #define flush_work(work) cancel_work_sync(work)
58
59 struct builtin_fw {
60         char *name;
61         void *data;
62         unsigned long size;
63 };
64
65 /*
66  * On older kernels we do not have net_device Multi Queue support, but
67  * since we no longer use MQ on mac80211 we can simply use the 0 queue.
68  * Note that if other fullmac drivers make use of this they then need
69  * to be backported somehow or deal with just 1 queueue from MQ.
70  */
71 static inline void netif_tx_wake_all_queues(struct net_device *dev)
72 {
73         netif_wake_queue(dev);
74 }
75 static inline void netif_tx_start_all_queues(struct net_device *dev)
76 {
77         netif_start_queue(dev);
78 }
79 static inline void netif_tx_stop_all_queues(struct net_device *dev)
80 {
81         netif_stop_queue(dev);
82 }
83
84 /* Are all TX queues of the device empty?  */
85 static inline bool qdisc_all_tx_empty(const struct net_device *dev)
86 {
87         return skb_queue_empty(&dev->qdisc->q);
88 }
89
90 bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
91
92 /*
93  * The net_device has a spin_lock on newer kernels, on older kernels we're out of luck
94  */
95 #define netif_addr_lock_bh(dev)
96 #define netif_addr_unlock_bh(dev)
97
98 /*
99  * To port this properly we'd have to port warn_slowpath_null(),
100  * which I'm lazy to do so just do a regular print for now. If you
101  * want to port this read kernel/panic.c
102  */
103 #define __WARN_printf(arg...)   do { printk(arg); __WARN(); } while (0)
104
105 /* This is ported directly as-is on newer kernels */
106 #ifndef WARN
107 #define WARN(condition, format...) ({                                   \
108         int __ret_warn_on = !!(condition);                              \
109         if (unlikely(__ret_warn_on))                                    \
110                 __WARN_printf(format);                                  \
111         unlikely(__ret_warn_on);                                        \
112 })
113 #endif
114
115 /* On 2.6.27 a second argument was added, on older kernels we ignore it */
116 #define dma_mapping_error(pdev, dma_addr) dma_mapping_error(dma_addr)
117 #define pci_dma_mapping_error(pdev, dma_addr) dma_mapping_error(pdev, dma_addr)
118
119 /* This is from include/linux/ieee80211.h */
120 #define IEEE80211_HT_CAP_DSSSCCK40              0x1000
121
122 /* New link list changes added as of 2.6.27, needed for ath9k */
123
124 static inline void __list_cut_position(struct list_head *list,
125                 struct list_head *head, struct list_head *entry)
126 {
127         struct list_head *new_first = entry->next;
128         list->next = head->next;
129         list->next->prev = list;
130         list->prev = entry;
131         entry->next = list;
132         head->next = new_first;
133         new_first->prev = head;
134 }
135
136 /**
137  * list_cut_position - cut a list into two
138  * @list: a new list to add all removed entries
139  * @head: a list with entries
140  * @entry: an entry within head, could be the head itself
141  *      and if so we won't cut the list
142  *
143  * This helper moves the initial part of @head, up to and
144  * including @entry, from @head to @list. You should
145  * pass on @entry an element you know is on @head. @list
146  * should be an empty list or a list you do not care about
147  * losing its data.
148  *
149  */
150 static inline void list_cut_position(struct list_head *list,
151                 struct list_head *head, struct list_head *entry)
152 {
153         if (list_empty(head))
154                 return;
155         if (list_is_singular(head) &&
156                 (head->next != entry && head != entry))
157                 return;
158         if (entry == head)
159                 INIT_LIST_HEAD(list);
160         else
161                 __list_cut_position(list, head, entry);
162 }
163
164
165 /* __list_splice as re-implemented on 2.6.27, we backport it */
166 static inline void __compat_list_splice_new_27(const struct list_head *list,
167                                  struct list_head *prev,
168                                  struct list_head *next)
169 {
170         struct list_head *first = list->next;
171         struct list_head *last = list->prev;
172
173         first->prev = prev;
174         prev->next = first;
175
176         last->next = next;
177         next->prev = last;
178 }
179
180 /**
181  * list_splice_tail - join two lists, each list being a queue
182  * @list: the new list to add.
183  * @head: the place to add it in the first list.
184  */
185 static inline void list_splice_tail(struct list_head *list,
186                                 struct list_head *head)
187 {
188         if (!list_empty(list))
189                 __compat_list_splice_new_27(list, head->prev, head);
190 }
191
192 /**
193  * list_splice_tail_init - join two lists and reinitialise the emptied list
194  * @list: the new list to add.
195  * @head: the place to add it in the first list.
196  *
197  * Each of the lists is a queue.
198  * The list at @list is reinitialised
199  */
200 static inline void list_splice_tail_init(struct list_head *list,
201                                          struct list_head *head)
202 {
203         if (!list_empty(list)) {
204                 __compat_list_splice_new_27(list, head->prev, head);
205                 INIT_LIST_HEAD(list);
206         }
207 }
208
209 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
210 extern unsigned int mmc_align_data_size(struct mmc_card *, unsigned int);
211 extern unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz);
212 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */
213
214 #define iwe_stream_add_value(info, event, value, ends, iwe, event_len) iwe_stream_add_value(event, value, ends, iwe, event_len)
215 #define iwe_stream_add_point(info, stream, ends, iwe, extra) iwe_stream_add_point(stream, ends, iwe, extra)
216 #define iwe_stream_add_event(info, stream, ends, iwe, event_len) iwe_stream_add_event(stream, ends, iwe, event_len)
217
218 /* Flags available in struct iw_request_info */
219 #define IW_REQUEST_FLAG_COMPAT  0x0001  /* Compat ioctl call */
220
221 static inline int iwe_stream_lcp_len(struct iw_request_info *info)
222 {
223 #ifdef CONFIG_COMPAT
224         if (info->flags & IW_REQUEST_FLAG_COMPAT)
225                 return IW_EV_COMPAT_LCP_LEN;
226 #endif
227         return IW_EV_LCP_LEN;
228 }
229
230 #ifdef CONFIG_ARM
231
232 /*
233  * The caller asks to handle a range between offset and offset + size,
234  * but we process a larger range from 0 to offset + size due to lack of
235  * offset support.
236  */
237
238 static inline void dma_sync_single_range_for_cpu(struct device *dev,
239                 dma_addr_t handle, unsigned long offset, size_t size,
240                 enum dma_data_direction dir)
241 {
242         dma_sync_single_for_cpu(dev, handle, offset + size, dir);
243 }
244
245 static inline void dma_sync_single_range_for_device(struct device *dev,
246                 dma_addr_t handle, unsigned long offset, size_t size,
247                 enum dma_data_direction dir)
248 {
249         dma_sync_single_for_device(dev, handle, offset + size, dir);
250 }
251
252 #endif /* arm */
253
254 #if defined(CONFIG_DEBUG_FS)
255 void debugfs_remove_recursive(struct dentry *dentry);
256 #else
257 static inline void debugfs_remove_recursive(struct dentry *dentry)
258 { }
259 #endif
260
261 #define device_create(cls, parent, devt, drvdata, fmt, ...)             \
262 ({                                                                      \
263         struct device *_dev;                                            \
264         _dev = (device_create)(cls, parent, devt, fmt, __VA_ARGS__);    \
265         dev_set_drvdata(_dev, drvdata);                                 \
266         _dev;                                                           \
267 })
268
269 #define dev_name(dev) dev_name((struct device *)dev)
270
271 static inline void ethtool_cmd_speed_set(struct ethtool_cmd *ep,
272                                          __u32 speed)
273 {
274         ep->speed = (__u16)speed;
275 }
276
277 static inline __u32 ethtool_cmd_speed(const struct ethtool_cmd *ep)
278 {
279         return ep->speed;
280 }
281
282 /**
283  * lower_32_bits - return bits 0-31 of a number
284  * @n: the number we're accessing
285  */
286 #define lower_32_bits(n) ((u32)(n))
287
288 #define netif_wake_subqueue netif_start_subqueue
289
290 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)) */
291
292 #endif /* LINUX_26_27_COMPAT_H */