compat: backport pci_is_pcie and pci_pcie_cap
[~emulex/for-vlad/old/compat.git] / include / linux / compat-2.6.33.h
1 #ifndef LINUX_26_33_COMPAT_H
2 #define LINUX_26_33_COMPAT_H
3
4 #include <linux/version.h>
5
6 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33))
7
8 #include <linux/skbuff.h>
9 #include <linux/pci.h>
10 #if defined(CONFIG_PCCARD) || defined(CONFIG_PCCARD_MODULE)
11 #include <pcmcia/cs_types.h>
12 #include <pcmcia/cistpl.h>
13 #include <pcmcia/ds.h>
14 #endif
15 #include <linux/kfifo.h>
16 #include <linux/firmware.h>
17
18 #define release_firmware compat_release_firmware
19 #define request_firmware compat_request_firmware
20 #define request_firmware_nowait compat_request_firmware_nowait
21
22 #if defined(CONFIG_FW_LOADER) || defined(CONFIG_FW_LOADER_MODULE)
23 int compat_request_firmware(const struct firmware **fw, const char *name,
24                      struct device *device);
25 int compat_request_firmware_nowait(
26         struct module *module, int uevent,
27         const char *name, struct device *device, gfp_t gfp, void *context,
28         void (*cont)(const struct firmware *fw, void *context));
29
30 void compat_release_firmware(const struct firmware *fw);
31 #else
32 static inline int compat_request_firmware(const struct firmware **fw,
33                                    const char *name,
34                                    struct device *device)
35 {
36         return -EINVAL;
37 }
38 static inline int request_firmware_nowait(
39         struct module *module, int uevent,
40         const char *name, struct device *device, gfp_t gfp, void *context,
41         void (*cont)(const struct firmware *fw, void *context))
42 {
43         return -EINVAL;
44 }
45
46 static inline void compat_release_firmware(const struct firmware *fw)
47 {
48 }
49 #endif
50
51 #define KEY_RFKILL              247     /* Key that controls all radios */
52
53 #define IFF_DONT_BRIDGE 0x800           /* disallow bridging this ether dev */
54 /* source: include/linux/if.h */
55
56 /* this will never happen on older kernels */
57 #define NETDEV_POST_INIT 0xffff
58
59 static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
60                 unsigned int length)
61 {
62         struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN);
63
64         if (NET_IP_ALIGN && skb)
65                 skb_reserve(skb, NET_IP_ALIGN);
66         return skb;
67 }
68
69 #if defined(CONFIG_PCCARD) || defined(CONFIG_PCCARD_MODULE)
70
71 #if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
72
73 #define pcmcia_request_window(a, b, c) pcmcia_request_window(&a, b, c)
74
75 #define pcmcia_map_mem_page(a, b, c) pcmcia_map_mem_page(b, c)
76
77 /* loop over CIS entries */
78 int pcmcia_loop_tuple(struct pcmcia_device *p_dev, cisdata_t code,
79                       int (*loop_tuple) (struct pcmcia_device *p_dev,
80                                          tuple_t *tuple,
81                                          void *priv_data),
82                       void *priv_data);
83
84 #endif /* CONFIG_PCMCIA */
85
86 /* loop over CIS entries */
87 int pccard_loop_tuple(struct pcmcia_socket *s, unsigned int function,
88                       cisdata_t code, cisparse_t *parse, void *priv_data,
89                       int (*loop_tuple) (tuple_t *tuple,
90                                          cisparse_t *parse,
91                                          void *priv_data));
92
93 #endif /* CONFIG_PCCARD */
94
95 /* Backport for kfifo
96  * kfifo_alloc and kfifo_free must be backported manually 
97  */
98 #define kfifo_in(a, b, c) __kfifo_put(*a, (unsigned char *)b, c)
99 #define kfifo_out(a, b, c) __kfifo_get(*a, (unsigned char *)b, c)
100 #define kfifo_len(a) __kfifo_len(*a)
101
102 /**
103  * kfifo_is_empty - returns true if the fifo is empty
104  * @fifo: the fifo to be used.
105  */
106 static inline __must_check int kfifo_is_empty(struct kfifo **fifo)
107 {
108         return (*fifo)->in == (*fifo)->out;
109 }
110
111 /**
112  * kfifo_size - returns the size of the fifo in bytes
113  * @fifo: the fifo to be used.
114  */
115 static inline __must_check unsigned int kfifo_size(struct kfifo *fifo)
116 {
117         return fifo->size;
118 }
119
120 /**
121  * kfifo_is_full - returns true if the fifo is full
122  * @fifo: the fifo to be used.
123  */
124 static inline __must_check int kfifo_is_full(struct kfifo **fifo)
125 {
126         return kfifo_len(fifo) == kfifo_size(*fifo);
127 }
128
129 static inline void compat_kfifo_free(struct kfifo **fifo) {
130         if (*fifo)
131                 kfifo_free(*fifo);
132 }
133 #define kfifo_free compat_kfifo_free
134
135 /**
136  * list_for_each_entry_continue_rcu - continue iteration over list of given type
137  * @pos:        the type * to use as a loop cursor.
138  * @head:       the head for your list.
139  * @member:     the name of the list_struct within the struct.
140  *
141  * Continue to iterate over list of given type, continuing after
142  * the current position.
143  */
144 #define list_for_each_entry_continue_rcu(pos, head, member)             \
145         for (pos = list_entry_rcu(pos->member.next, typeof(*pos), member); \
146              prefetch(pos->member.next), &pos->member != (head);        \
147              pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
148
149 #define sock_recv_ts_and_drops(msg, sk, skb) sock_recv_timestamp(msg, sk, skb)
150
151 /**
152  * pci_pcie_cap - get the saved PCIe capability offset
153  * @dev: PCI device
154  *
155  * PCIe capability offset is calculated at PCI device initialization
156  * time and saved in the data structure. This function returns saved
157  * PCIe capability offset. Using this instead of pci_find_capability()
158  * reduces unnecessary search in the PCI configuration space. If you
159  * need to calculate PCIe capability offset from raw device for some
160  * reasons, please use pci_find_capability() instead.
161  */
162 static inline int pci_pcie_cap(struct pci_dev *dev)
163 {
164         return pci_find_capability(dev, PCI_CAP_ID_EXP);
165 }
166
167 /**
168  * pci_is_pcie - check if the PCI device is PCI Express capable
169  * @dev: PCI device
170  *
171  * Retrun true if the PCI device is PCI Express capable, false otherwise.
172  */
173 static inline bool pci_is_pcie(struct pci_dev *dev)
174 {
175 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
176         return dev->is_pcie;
177 #else
178         return !!pci_pcie_cap(dev);
179 #endif
180 }
181
182 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)) */
183
184 #endif /* LINUX_26_33_COMPAT_H */