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