9b6b9580e87cadf10f7c6cb919f433a3d461de68
[compat-rdma/compat.git] / include / linux / compat-2.6.28.h
1 #ifndef LINUX_26_28_COMPAT_H
2 #define LINUX_26_28_COMPAT_H
3
4 #include <linux/version.h>
5
6 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28))
7
8 #include <linux/skbuff.h>
9 #include <linux/if_ether.h>
10 #include <linux/usb.h>
11 #include <linux/types.h>
12 #include <linux/types.h>
13 #include <linux/cpumask.h>
14
15 #ifndef ETH_P_PAE
16 #define ETH_P_PAE 0x888E      /* Port Access Entity (IEEE 802.1X) */
17 #endif
18
19 #include <linux/pci.h>
20
21 typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } compat_cpumask_t;
22
23 #if defined(CONFIG_X86) || defined(CONFIG_X86_64) || defined(CONFIG_PPC)
24 /*
25  * CONFIG_PHYS_ADDR_T_64BIT was added as new to all architectures
26  * as of 2.6.28 but x86 and ppc had it already. x86 only got phys_addr_t
27  * as of 2.6.25 but then is backported in compat-2.6.25.h
28  */
29 #else
30 #if defined(CONFIG_64BIT) || defined(CONFIG_X86_PAE) || defned(CONFIG_PPC64) || defined(CONFIG_PHYS_64BIT)
31 #define CONFIG_PHYS_ADDR_T_64BIT 1
32 typedef u64 phys_addr_t;
33 #else
34 typedef u32 phys_addr_t;
35 #endif
36
37 #endif /* non x86 and ppc */
38
39 #ifndef WARN_ONCE
40 #define WARN_ONCE(condition, format...) ({                      \
41         static int __warned;                                    \
42         int __ret_warn_once = !!(condition);                    \
43                                                                 \
44         if (unlikely(__ret_warn_once))                          \
45                 if (WARN(!__warned, format))                    \
46                         __warned = 1;                           \
47         unlikely(__ret_warn_once);                              \
48 })
49 #endif /* From include/asm-generic/bug.h */
50
51 #if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
52
53 #include <pcmcia/cs_types.h>
54 #include <pcmcia/cs.h>
55 #include <pcmcia/cistpl.h>
56 #ifdef pcmcia_parse_tuple
57 #undef pcmcia_parse_tuple
58 #define pcmcia_parse_tuple(tuple, parse) pccard_parse_tuple(tuple, parse)
59 #endif
60
61 /* From : include/pcmcia/ds.h */
62 /* loop CIS entries for valid configuration */
63 int pcmcia_loop_config(struct pcmcia_device *p_dev,
64                        int      (*conf_check)   (struct pcmcia_device *p_dev,
65                                                  cistpl_cftable_entry_t *cfg,
66                                                  cistpl_cftable_entry_t *dflt,
67                                                  unsigned int vcc,
68                                                  void *priv_data),
69                        void *priv_data);
70
71 #endif /* CONFIG_PCMCIA */
72
73 /* USB anchors were added as of 2.6.23 */
74 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23))
75
76 #if defined(CONFIG_USB) || defined(CONFIG_USB_MODULE)
77 #if 0
78 extern void usb_poison_urb(struct urb *urb);
79 #endif
80 extern void usb_unpoison_urb(struct urb *urb);
81
82 #if 0
83 extern void usb_poison_anchored_urbs(struct usb_anchor *anchor);
84 #endif
85
86 extern int usb_anchor_empty(struct usb_anchor *anchor);
87 #endif /* CONFIG_USB */
88 #endif
89
90
91 void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar);
92
93 /**
94  *      skb_queue_is_last - check if skb is the last entry in the queue
95  *      @list: queue head
96  *      @skb: buffer
97  *
98  *      Returns true if @skb is the last buffer on the list.
99  */
100 static inline bool skb_queue_is_last(const struct sk_buff_head *list,
101                                      const struct sk_buff *skb)
102 {
103         return (skb->next == (struct sk_buff *) list);
104 }
105
106 /**
107  *      skb_queue_next - return the next packet in the queue
108  *      @list: queue head
109  *      @skb: current buffer
110  *
111  *      Return the next packet in @list after @skb.  It is only valid to
112  *      call this if skb_queue_is_last() evaluates to false.
113  */
114 static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list,
115                                              const struct sk_buff *skb)
116 {
117         /* This BUG_ON may seem severe, but if we just return then we
118          * are going to dereference garbage.
119          */
120         BUG_ON(skb_queue_is_last(list, skb));
121         return skb->next;
122 }
123
124 /**
125  *      __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head
126  *      @list: queue to initialize
127  *
128  *      This initializes only the list and queue length aspects of
129  *      an sk_buff_head object.  This allows to initialize the list
130  *      aspects of an sk_buff_head without reinitializing things like
131  *      the spinlock.  It can also be used for on-stack sk_buff_head
132  *      objects where the spinlock is known to not be used.
133  */
134 static inline void __skb_queue_head_init(struct sk_buff_head *list)
135 {
136         list->prev = list->next = (struct sk_buff *)list;
137         list->qlen = 0;
138 }
139
140 static inline void __skb_queue_splice(const struct sk_buff_head *list,
141                                       struct sk_buff *prev,
142                                       struct sk_buff *next)
143 {
144         struct sk_buff *first = list->next;
145         struct sk_buff *last = list->prev;
146
147         first->prev = prev;
148         prev->next = first;
149
150         last->next = next;
151         next->prev = last;
152 }
153
154 /**
155  *      skb_queue_splice - join two skb lists, this is designed for stacks
156  *      @list: the new list to add
157  *      @head: the place to add it in the first list
158  */
159 static inline void skb_queue_splice(const struct sk_buff_head *list,
160                                     struct sk_buff_head *head)
161 {
162         if (!skb_queue_empty(list)) {
163                 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
164                 head->qlen += list->qlen;
165         }
166 }
167
168 /**
169  *      skb_queue_splice - join two skb lists and reinitialise the emptied list
170  *      @list: the new list to add
171  *      @head: the place to add it in the first list
172  *
173  *      The list at @list is reinitialised
174  */
175 static inline void skb_queue_splice_init(struct sk_buff_head *list,
176                                          struct sk_buff_head *head)
177 {
178         if (!skb_queue_empty(list)) {
179                 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
180                 head->qlen += list->qlen;
181                 __skb_queue_head_init(list);
182         }
183 }
184
185 /**
186  *      skb_queue_splice_tail - join two skb lists and reinitialise the emptied list
187  *      @list: the new list to add
188  *      @head: the place to add it in the first list
189  *
190  *      Each of the lists is a queue.
191  *      The list at @list is reinitialised
192  */
193 static inline void skb_queue_splice_tail_init(struct sk_buff_head *list,
194                                               struct sk_buff_head *head)
195 {
196         if (!skb_queue_empty(list)) {
197                 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
198                 head->qlen += list->qlen;
199                 __skb_queue_head_init(list);
200         }
201 } /* From include/linux/skbuff.h */
202
203 /**
204  *      skb_queue_splice_tail - join two skb lists, each list being a queue
205  *      @list: the new list to add
206  *      @head: the place to add it in the first list
207  */
208 static inline void skb_queue_splice_tail(const struct sk_buff_head *list,
209                                          struct sk_buff_head *head)
210 {
211         if (!skb_queue_empty(list)) {
212                 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
213                 head->qlen += list->qlen;
214         }
215 }
216
217 #define skb_queue_walk_from(queue, skb)                                         \
218                 for (; skb != (struct sk_buff *)(queue);                        \
219                      skb = skb->next)
220
221 #ifndef DECLARE_TRACE
222
223 #define TP_PROTO(args...)       args
224 #define TP_ARGS(args...)                args
225
226 #define DECLARE_TRACE(name, proto, args)                                \
227         static inline void _do_trace_##name(struct tracepoint *tp, proto) \
228         { }                                                             \
229         static inline void trace_##name(proto)                          \
230         { }                                                             \
231         static inline int register_trace_##name(void (*probe)(proto))   \
232         {                                                               \
233                 return -ENOSYS;                                         \
234         }                                                               \
235         static inline int unregister_trace_##name(void (*probe)(proto)) \
236         {                                                               \
237                 return -ENOSYS;                                         \
238         }
239
240 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
241 #define EXPORT_TRACEPOINT_SYMBOL(name)
242
243
244 #endif
245
246 /* openSuse includes round_jiffies_up in it's kernel 2.6.27.
247  * This is needed to prevent conflicts with the openSuse definition.
248  */
249 #define round_jiffies_up backport_round_jiffies_up
250
251 unsigned long round_jiffies_up(unsigned long j);
252
253 extern void v2_6_28_skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page,
254                             int off, int size);
255
256 #define wake_up_interruptible_poll(x, m)                        \
257         __wake_up(x, TASK_INTERRUPTIBLE, 1, (void *) (m))
258
259 extern int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
260                        unsigned int cmd, unsigned long arg);
261
262 int pci_wake_from_d3(struct pci_dev *dev, bool enable);
263
264 #define alloc_workqueue(name, flags, max_active) __create_workqueue(name, flags, max_active)
265
266 #ifndef pr_fmt
267 #define pr_fmt(fmt) fmt
268 #endif
269
270 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)) */
271
272 #endif /* LINUX_26_28_COMPAT_H */