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 #define pci_pme_capable LINUX_BACKPORT(pci_pme_capable)
  91 bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
  92
  93 /*
  94  * The net_device has a spin_lock on newer kernels, on older kernels we're out of luck
  95  */
  96 #define netif_addr_lock_bh(dev)
  97 #define netif_addr_unlock_bh(dev)
  98
  99 /*
 100  * To port this properly we'd have to port warn_slowpath_null(),
 101  * which I'm lazy to do so just do a regular print for now. If you
 102  * want to port this read kernel/panic.c
 103  */
 104 #define __WARN_printf(arg...)   do { printk(arg); __WARN(); } while (0)
 105
 106 /* This is ported directly as-is on newer kernels */
 107 #ifndef WARN
 108 #define WARN(condition, format...) ({                                   \
 109         int __ret_warn_on = !!(condition);                              \
 110         if (unlikely(__ret_warn_on))                                    \
 111                 __WARN_printf(format);                                  \
 112         unlikely(__ret_warn_on);                                        \
 113 })
 114 #endif
 115
 116 /* On 2.6.27 a second argument was added, on older kernels we ignore it */
 117 #define dma_mapping_error(pdev, dma_addr) dma_mapping_error(dma_addr)
 118 #define pci_dma_mapping_error(pdev, dma_addr) dma_mapping_error(pdev, dma_addr)
 119
 120 /* This is from include/linux/ieee80211.h */
 121 #define IEEE80211_HT_CAP_DSSSCCK40              0x1000
 122
 123 /* New link list changes added as of 2.6.27, needed for ath9k */
 124
 125 static inline void __list_cut_position(struct list_head *list,
 126                 struct list_head *head, struct list_head *entry)
 127 {
 128         struct list_head *new_first = entry->next;
 129         list->next = head->next;
 130         list->next->prev = list;
 131         list->prev = entry;
 132         entry->next = list;
 133         head->next = new_first;
 134         new_first->prev = head;
 135 }
 136
 137 /**
 138  * list_cut_position - cut a list into two
 139  * @list: a new list to add all removed entries
 140  * @head: a list with entries
 141  * @entry: an entry within head, could be the head itself
 142  *      and if so we won't cut the list
 143  *
 144  * This helper moves the initial part of @head, up to and
 145  * including @entry, from @head to @list. You should
 146  * pass on @entry an element you know is on @head. @list
 147  * should be an empty list or a list you do not care about
 148  * losing its data.
 149  *
 150  */
 151 static inline void list_cut_position(struct list_head *list,
 152                 struct list_head *head, struct list_head *entry)
 153 {
 154         if (list_empty(head))
 155                 return;
 156         if (list_is_singular(head) &&
 157                 (head->next != entry && head != entry))
 158                 return;
 159         if (entry == head)
 160                 INIT_LIST_HEAD(list);
 161         else
 162                 __list_cut_position(list, head, entry);
 163 }
 164
 165
 166 /* __list_splice as re-implemented on 2.6.27, we backport it */
 167 static inline void __compat_list_splice_new_27(const struct list_head *list,
 168                                  struct list_head *prev,
 169                                  struct list_head *next)
 170 {
 171         struct list_head *first = list->next;
 172         struct list_head *last = list->prev;
 173
 174         first->prev = prev;
 175         prev->next = first;
 176
 177         last->next = next;
 178         next->prev = last;
 179 }
 180
 181 /**
 182  * list_splice_tail - join two lists, each list being a queue
 183  * @list: the new list to add.
 184  * @head: the place to add it in the first list.
 185  */
 186 static inline void list_splice_tail(struct list_head *list,
 187                                 struct list_head *head)
 188 {
 189         if (!list_empty(list))
 190                 __compat_list_splice_new_27(list, head->prev, head);
 191 }
 192
 193 /**
 194  * list_splice_tail_init - join two lists and reinitialise the emptied list
 195  * @list: the new list to add.
 196  * @head: the place to add it in the first list.
 197  *
 198  * Each of the lists is a queue.
 199  * The list at @list is reinitialised
 200  */
 201 static inline void list_splice_tail_init(struct list_head *list,
 202                                          struct list_head *head)
 203 {
 204         if (!list_empty(list)) {
 205                 __compat_list_splice_new_27(list, head->prev, head);
 206                 INIT_LIST_HEAD(list);
 207         }
 208 }
 209
 210 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
 211 #define mmc_align_data_size LINUX_BACKPORT(mmc_align_data_size)
 212 extern unsigned int mmc_align_data_size(struct mmc_card *, unsigned int);
 213 #define sdio_align_size LINUX_BACKPORT(sdio_align_size)
 214 extern unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz);
 215 #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */
 216
 217 #define iwe_stream_add_value(info, event, value, ends, iwe, event_len) iwe_stream_add_value(event, value, ends, iwe, event_len)
 218 #define iwe_stream_add_point(info, stream, ends, iwe, extra) iwe_stream_add_point(stream, ends, iwe, extra)
 219 #define iwe_stream_add_event(info, stream, ends, iwe, event_len) iwe_stream_add_event(stream, ends, iwe, event_len)
 220
 221 /* Flags available in struct iw_request_info */
 222 #define IW_REQUEST_FLAG_COMPAT  0x0001  /* Compat ioctl call */
 223
 224 static inline int iwe_stream_lcp_len(struct iw_request_info *info)
 225 {
 226 #ifdef CONFIG_COMPAT
 227         if (info->flags & IW_REQUEST_FLAG_COMPAT)
 228                 return IW_EV_COMPAT_LCP_LEN;
 229 #endif
 230         return IW_EV_LCP_LEN;
 231 }
 232
 233 #ifdef CONFIG_ARM
 234
 235 /*
 236  * The caller asks to handle a range between offset and offset + size,
 237  * but we process a larger range from 0 to offset + size due to lack of
 238  * offset support.
 239  */
 240
 241 static inline void dma_sync_single_range_for_cpu(struct device *dev,
 242                 dma_addr_t handle, unsigned long offset, size_t size,
 243                 enum dma_data_direction dir)
 244 {
 245         dma_sync_single_for_cpu(dev, handle, offset + size, dir);
 246 }
 247
 248 static inline void dma_sync_single_range_for_device(struct device *dev,
 249                 dma_addr_t handle, unsigned long offset, size_t size,
 250                 enum dma_data_direction dir)
 251 {
 252         dma_sync_single_for_device(dev, handle, offset + size, dir);
 253 }
 254
 255 #endif /* arm */
 256
 257 #define debugfs_remove_recursive LINUX_BACKPORT(debugfs_remove_recursive)
 258
 259 #if defined(CONFIG_DEBUG_FS)
 260 void debugfs_remove_recursive(struct dentry *dentry);
 261 #else
 262 static inline void debugfs_remove_recursive(struct dentry *dentry)
 263 { }
 264 #endif
 265
 266 #define device_create(cls, parent, devt, drvdata, fmt, ...)             \
 267 ({                                                                      \
 268         struct device *_dev;                                            \
 269         _dev = (device_create)(cls, parent, devt, fmt, __VA_ARGS__);    \
 270         dev_set_drvdata(_dev, drvdata);                                 \
 271         _dev;                                                           \
 272 })
 273
 274 #define dev_name(dev) dev_name((struct device *)dev)
 275
 276 static inline void ethtool_cmd_speed_set(struct ethtool_cmd *ep,
 277                                          __u32 speed)
 278 {
 279         ep->speed = (__u16)speed;
 280 }
 281
 282 static inline __u32 ethtool_cmd_speed(const struct ethtool_cmd *ep)
 283 {
 284         return ep->speed;
 285 }
 286
 287 /**
 288  * lower_32_bits - return bits 0-31 of a number
 289  * @n: the number we're accessing
 290  */
 291 #define lower_32_bits(n) ((u32)(n))
 292
 293 #define netif_wake_subqueue netif_start_subqueue
 294
 295 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)) */
 296
 297 #endif /* LINUX_26_27_COMPAT_H */