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