Added support for SLES11SP3
[compat-rdma/compat.git] / 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 */