include/linux/compat-3.2.h

   1 #ifndef LINUX_3_2_COMPAT_H
   2 #define LINUX_3_2_COMPAT_H
   3
   4 #include <linux/version.h>
   5
   6 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0))
   7
   8 #include <linux/skbuff.h>
   9 #include <linux/dma-mapping.h>
  10 #include <linux/ethtool.h>
  11
  12 /* backports b4625dab */
  13 #define  SDIO_CCCR_REV_3_00    3       /* CCCR/FBR Version 3.00 */
  14 #define  SDIO_SDIO_REV_3_00    4       /* SDIO Spec Version 3.00 */
  15
  16 #define PMSG_IS_AUTO(msg)       (((msg).event & PM_EVENT_AUTO) != 0)
  17
  18 extern int __ethtool_get_settings(struct net_device *dev,
  19                                   struct ethtool_cmd *cmd);
  20
  21 #ifndef CONFIG_COMPAT_SLES_11_3
  22 #ifdef CONFIG_COMPAT_SKB_FRAG_NEEDED
  23
  24 /**
  25  * skb_frag_page - retrieve the page refered to by a paged fragment
  26  * @frag: the paged fragment
  27  *
  28  * Returns the &struct page associated with @frag.
  29  */
  30 static inline struct page *skb_frag_page(const skb_frag_t *frag)
  31 {
  32         return frag->page;
  33 }
  34
  35 /**
  36  * __skb_frag_set_page - sets the page contained in a paged fragment
  37  * @frag: the paged fragment
  38  * @page: the page to set
  39  *
  40  * Sets the fragment @frag to contain @page.
  41  */
  42 static inline void __skb_frag_set_page(skb_frag_t *frag, struct page *page)
  43 {
  44         frag->page = page;
  45 }
  46
  47 /**
  48  * skb_frag_set_page - sets the page contained in a paged fragment of an skb
  49  * @skb: the buffer
  50  * @f: the fragment offset
  51  * @page: the page to set
  52  *
  53  * Sets the @f'th fragment of @skb to contain @page.
  54  */
  55 static inline void skb_frag_set_page(struct sk_buff *skb, int f,
  56                                      struct page *page)
  57 {
  58         __skb_frag_set_page(&skb_shinfo(skb)->frags[f], page);
  59 }
  60
  61 /**
  62  * skb_frag_address_safe - gets the address of the data contained in a paged fragment
  63  * @frag: the paged fragment buffer
  64  *
  65  * Returns the address of the data within @frag. Checks that the page
  66  * is mapped and returns %NULL otherwise.
  67  */
  68 static inline void *skb_frag_address_safe(const skb_frag_t *frag)
  69 {
  70         void *ptr = page_address(skb_frag_page(frag));
  71         if (unlikely(!ptr))
  72                 return NULL;
  73
  74         return ptr + frag->page_offset;
  75 }
  76
  77 /**
  78  * skb_frag_dma_map - maps a paged fragment via the DMA API
  79  * @device: the device to map the fragment to
  80  * @frag: the paged fragment to map
  81  * @offset: the offset within the fragment (starting at the
  82  *          fragment's own offset)
  83  * @size: the number of bytes to map
  84  * @direction: the direction of the mapping (%PCI_DMA_*)
  85  *
  86  * Maps the page associated with @frag to @device.
  87  */
  88 static inline dma_addr_t skb_frag_dma_map(struct device *dev,
  89                                           const skb_frag_t *frag,
  90                                           size_t offset, size_t size,
  91                                           enum dma_data_direction dir)
  92 {
  93         return dma_map_page(dev, skb_frag_page(frag),
  94                             frag->page_offset + offset, size, dir);
  95 }
  96
  97 #define ETH_P_TDLS      0x890D          /* TDLS */
  98
  99 static inline unsigned int skb_frag_size(const skb_frag_t *frag)
 100 {
 101         return frag->size;
 102 }
 103
 104 static inline void skb_frag_size_set(skb_frag_t *frag, unsigned int size)
 105 {
 106         frag->size = size;
 107 }
 108
 109 static inline void skb_frag_size_add(skb_frag_t *frag, int delta)
 110 {
 111         frag->size += delta;
 112 }
 113
 114 static inline void skb_frag_size_sub(skb_frag_t *frag, int delta)
 115 {
 116         frag->size -= delta;
 117 }
 118
 119 /**
 120  * __skb_frag_unref - release a reference on a paged fragment.
 121  * @frag: the paged fragment
 122  *
 123  * Releases a reference on the paged fragment @frag.
 124  */
 125 static inline void __skb_frag_unref(skb_frag_t *frag)
 126 {
 127         put_page(skb_frag_page(frag));
 128 }
 129
 130 #endif /* CONFIG_COMPAT_SKB_FRAG_NEEDED */
 131
 132 static inline char *hex_byte_pack(char *buf, u8 byte)
 133 {
 134         *buf++ = hex_asc_hi(byte);
 135         *buf++ = hex_asc_lo(byte);
 136         return buf;
 137 }
 138 #endif /* CONFIG_COMPAT_SLES_11_3 */
 139
 140 /* module_platform_driver() - Helper macro for drivers that don't do
 141  * anything special in module init/exit.  This eliminates a lot of
 142  * boilerplate.  Each module may only use this macro once, and
 143  * calling it replaces module_init() and module_exit()
 144  */
 145 #define module_platform_driver(__platform_driver) \
 146         module_driver(__platform_driver, platform_driver_register, \
 147                         platform_driver_unregister)
 148
 149 #ifndef CONFIG_COMPAT_RHEL_6_4
 150 static inline void *dma_zalloc_coherent(struct device *dev, size_t size,
 151                                         dma_addr_t *dma_handle, gfp_t flag)
 152 {
 153         void *ret = dma_alloc_coherent(dev, size, dma_handle, flag);
 154         if (ret)
 155                 memset(ret, 0, size);
 156         return ret;
 157 }
 158 #endif /* CONFIG_COMPAT_RHEL_6_4 */
 159
 160 extern int __netdev_printk(const char *level, const struct net_device *dev,
 161                            struct va_format *vaf);
 162
 163 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0)) */
 164
 165 #endif /* LINUX_3_2_COMPAT_H */