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