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 #define pci_ioremap_bar LINUX_BACKPORT(pci_ioremap_bar)
  52 void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar);
  53
  54 /**
  55  *      skb_queue_is_last - check if skb is the last entry in the queue
  56  *      @list: queue head
  57  *      @skb: buffer
  58  *
  59  *      Returns true if @skb is the last buffer on the list.
  60  */
  61 static inline bool skb_queue_is_last(const struct sk_buff_head *list,
  62                                      const struct sk_buff *skb)
  63 {
  64         return (skb->next == (struct sk_buff *) list);
  65 }
  66
  67 /**
  68  *      skb_queue_next - return the next packet in the queue
  69  *      @list: queue head
  70  *      @skb: current buffer
  71  *
  72  *      Return the next packet in @list after @skb.  It is only valid to
  73  *      call this if skb_queue_is_last() evaluates to false.
  74  */
  75 static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list,
  76                                              const struct sk_buff *skb)
  77 {
  78         /* This BUG_ON may seem severe, but if we just return then we
  79          * are going to dereference garbage.
  80          */
  81         BUG_ON(skb_queue_is_last(list, skb));
  82         return skb->next;
  83 }
  84
  85 /**
  86  *      __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head
  87  *      @list: queue to initialize
  88  *
  89  *      This initializes only the list and queue length aspects of
  90  *      an sk_buff_head object.  This allows to initialize the list
  91  *      aspects of an sk_buff_head without reinitializing things like
  92  *      the spinlock.  It can also be used for on-stack sk_buff_head
  93  *      objects where the spinlock is known to not be used.
  94  */
  95 static inline void __skb_queue_head_init(struct sk_buff_head *list)
  96 {
  97         list->prev = list->next = (struct sk_buff *)list;
  98         list->qlen = 0;
  99 }
 100
 101 static inline void __skb_queue_splice(const struct sk_buff_head *list,
 102                                       struct sk_buff *prev,
 103                                       struct sk_buff *next)
 104 {
 105         struct sk_buff *first = list->next;
 106         struct sk_buff *last = list->prev;
 107
 108         first->prev = prev;
 109         prev->next = first;
 110
 111         last->next = next;
 112         next->prev = last;
 113 }
 114
 115 /**
 116  *      skb_queue_splice - join two skb lists, this is designed for stacks
 117  *      @list: the new list to add
 118  *      @head: the place to add it in the first list
 119  */
 120 static inline void skb_queue_splice(const struct sk_buff_head *list,
 121                                     struct sk_buff_head *head)
 122 {
 123         if (!skb_queue_empty(list)) {
 124                 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
 125                 head->qlen += list->qlen;
 126         }
 127 }
 128
 129 /**
 130  *      skb_queue_splice - join two skb lists and reinitialise the emptied list
 131  *      @list: the new list to add
 132  *      @head: the place to add it in the first list
 133  *
 134  *      The list at @list is reinitialised
 135  */
 136 static inline void skb_queue_splice_init(struct sk_buff_head *list,
 137                                          struct sk_buff_head *head)
 138 {
 139         if (!skb_queue_empty(list)) {
 140                 __skb_queue_splice(list, (struct sk_buff *) head, head->next);
 141                 head->qlen += list->qlen;
 142                 __skb_queue_head_init(list);
 143         }
 144 }
 145
 146 /**
 147  *      skb_queue_splice_tail - join two skb lists and reinitialise the emptied list
 148  *      @list: the new list to add
 149  *      @head: the place to add it in the first list
 150  *
 151  *      Each of the lists is a queue.
 152  *      The list at @list is reinitialised
 153  */
 154 static inline void skb_queue_splice_tail_init(struct sk_buff_head *list,
 155                                               struct sk_buff_head *head)
 156 {
 157         if (!skb_queue_empty(list)) {
 158                 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
 159                 head->qlen += list->qlen;
 160                 __skb_queue_head_init(list);
 161         }
 162 } /* From include/linux/skbuff.h */
 163
 164 /**
 165  *      skb_queue_splice_tail - join two skb lists, each list being a queue
 166  *      @list: the new list to add
 167  *      @head: the place to add it in the first list
 168  */
 169 static inline void skb_queue_splice_tail(const struct sk_buff_head *list,
 170                                          struct sk_buff_head *head)
 171 {
 172         if (!skb_queue_empty(list)) {
 173                 __skb_queue_splice(list, head->prev, (struct sk_buff *) head);
 174                 head->qlen += list->qlen;
 175         }
 176 }
 177
 178 #define skb_queue_walk_from(queue, skb)                                         \
 179                 for (; skb != (struct sk_buff *)(queue);                        \
 180                      skb = skb->next)
 181
 182 #ifndef DECLARE_TRACE
 183
 184 #define TP_PROTO(args...)       args
 185 #define TP_ARGS(args...)                args
 186
 187 #define DECLARE_TRACE(name, proto, args)                                \
 188         static inline void _do_trace_##name(struct tracepoint *tp, proto) \
 189         { }                                                             \
 190         static inline void trace_##name(proto)                          \
 191         { }                                                             \
 192         static inline int register_trace_##name(void (*probe)(proto))   \
 193         {                                                               \
 194                 return -ENOSYS;                                         \
 195         }                                                               \
 196         static inline int unregister_trace_##name(void (*probe)(proto)) \
 197         {                                                               \
 198                 return -ENOSYS;                                         \
 199         }
 200
 201 #define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
 202 #define EXPORT_TRACEPOINT_SYMBOL(name)
 203
 204
 205 #endif
 206
 207 #define round_jiffies_up LINUX_BACKPORT(round_jiffies_up)
 208 unsigned long round_jiffies_up(unsigned long j);
 209
 210 extern void v2_6_28_skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page,
 211                             int off, int size);
 212
 213 #define wake_up_interruptible_poll(x, m)                        \
 214         __wake_up(x, TASK_INTERRUPTIBLE, 1, (void *) (m))
 215
 216 #define n_tty_ioctl_helper LINUX_BACKPORT(n_tty_ioctl_helper)
 217 extern int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
 218                        unsigned int cmd, unsigned long arg);
 219
 220 #define pci_wake_from_d3 LINUX_BACKPORT(pci_wake_from_d3)
 221 int pci_wake_from_d3(struct pci_dev *dev, bool enable);
 222
 223 #define alloc_workqueue(name, flags, max_active) __create_workqueue(name, flags, max_active)
 224
 225 #ifndef pr_fmt
 226 #define pr_fmt(fmt) fmt
 227 #endif
 228
 229 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)) */
 230
 231 #endif /* LINUX_26_28_COMPAT_H */