a42df73e7d2a579bc8d53193dd4ca7c8ba4719b8
[akaros.git] / kern / drivers / net / bnx2x / akaros_compat.h
1 /* Copyright (c) 2015 Google Inc.
2  *
3  * Dumping ground for converting between Akaros and other OSs. */
4
5 #ifndef ROS_KERN_AKAROS_COMPAT_H
6 #define ROS_KERN_AKAROS_COMPAT_H
7
8 /* Common headers that most driver files will need */
9
10 #include <assert.h>
11 #include <error.h>
12 #include <ip.h>
13 #include <kmalloc.h>
14 #include <kref.h>
15 #include <pmap.h>
16 #include <slab.h>
17 #include <smp.h>
18 #include <stdio.h>
19 #include <string.h>
20 #include <bitmap.h>
21 #include <mii.h>
22 #include <umem.h>
23 #include <mmio.h>
24 #include <taskqueue.h>
25
26 #define __rcu
27 #define unlikely(x) (x)
28 #define likely(x) (x)
29 #define UINT_MAX UINT64_MAX
30 #define L1_CACHE_SHIFT (LOG2_UP(ARCH_CL_SIZE))
31
32 /* Wanted to keep the _t variants in the code, in case that's useful in the
33  * future */
34 #define MIN_T(t, a, b) MIN(a, b)
35 #define MAX_T(t, a, b) MAX(a, b)
36 #define CLAMP(val, lo, hi) MIN((typeof(val))MAX(val, lo), hi)
37 #define CLAMP_T(t, val, lo, hi) CLAMP(val, lo, hi)
38
39 /* I'm okay with these versions of the asserts. */
40 #define WARN(args...) warn(args)
41 #define WARN_ONCE(args...) warn_once(args)
42 #define WARN_ON(x) warn_on(x)
43 #define WARN_ON_ONCE(x) warn_on_once(x)
44 #define BUG(args...) panic(args)
45 #define BUG_ON(x) assert(x)
46
47 typedef physaddr_t dma_addr_t;
48 typedef int gfp_t;
49
50 /* these dma funcs are empty in linux with !CONFIG_NEED_DMA_MAP_STATE */
51 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)
52 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)
53 #define dma_unmap_addr(PTR, ADDR_NAME)           (0)
54 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  do { } while (0)
55 #define dma_unmap_len(PTR, LEN_NAME)             (0)
56 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    do { } while (0)
57 #define DMA_NONE                                0
58 #define DMA_TO_DEVICE                   1
59 #define DMA_FROM_DEVICE                 2
60 #define DMA_BIDIRECTIONAL               3
61
62 static inline void *__dma_alloc_coherent(size_t size, dma_addr_t *dma_handle,
63                                          gfp_t flags)
64 {
65         size_t order = LOG2_UP(nr_pages(size));
66         void *vaddr = get_cont_pages(order, flags);
67         if (!vaddr) {
68                 *dma_handle = 0;
69                 return 0;
70         }
71         *dma_handle = PADDR(vaddr);
72         return vaddr;
73 }
74
75 static inline void *__dma_zalloc_coherent(size_t size, dma_addr_t *dma_handle,
76                                           gfp_t flags)
77 {
78         void *vaddr = __dma_alloc_coherent(size, dma_handle, flags);
79         if (vaddr)
80                 memset(vaddr, 0, size);
81         return vaddr;
82 }
83
84 static inline void __dma_free_coherent(size_t size, void *cpu_addr,
85                                        dma_addr_t dma_handle)
86 {
87         size_t order = LOG2_UP(nr_pages(size));
88         free_cont_pages(cpu_addr, order);
89 }
90
91 static inline dma_addr_t __dma_map_single(void *cpu_addr, size_t size,
92                                           int direction)
93 {
94         return PADDR(cpu_addr);
95 }
96
97 static inline dma_addr_t __dma_map_page(struct page *page,
98                                         unsigned long offset, size_t size,
99                                         int direction)
100 {
101         assert(offset == 0);
102         return page2pa(page);
103 }
104
105 static inline int __dma_mapping_error(dma_addr_t dma_addr)
106 {
107         return (dma_addr == 0);
108 }
109
110 #define dma_unmap_single(...)
111 #define dma_unmap_page(...)
112 #define dma_set_mask_and_coherent(...) (0)
113 #define dma_sync_single_for_cpu(...)
114
115 /* Wrappers to avoid struct device.  Might want that one of these days */
116 #define dma_alloc_coherent(dev, size, dma_handlep, flag)                       \
117         __dma_alloc_coherent(size, dma_handlep, flag)
118
119 #define dma_zalloc_coherent(dev, size, dma_handlep, flag)                      \
120         __dma_zalloc_coherent(size, dma_handlep, flag)
121
122 #define dma_free_coherent(dev, size, dma_handle, flag)                         \
123         __dma_free_coherent(size, dma_handle, flag)
124
125 #define dma_map_single(dev, addr, size, direction)                             \
126         __dma_map_single(addr, size, direction)
127
128 #define dma_map_page(dev, page, offset, size, direction)                       \
129         __dma_map_page(page, offset, size, direction)
130
131 #define dma_mapping_error(dev, handle)                                         \
132         __dma_mapping_error(handle)
133
134
135 typedef int pci_power_t;
136 typedef int pm_message_t;
137
138 #define DEFINE_SEMAPHORE(name)  \
139     struct semaphore name = SEMAPHORE_INITIALIZER_IRQSAVE(name, 1)
140 #define sema_init(sem, val) sem_init_irqsave(sem, val)
141 #define up(sem) sem_up(sem)
142 #define down(sem) sem_down(sem)
143 #define down_trylock(sem) ({!sem_trydown(sem);})
144 /* In lieu of spatching, I wanted to keep the distinction between down and
145  * down_interruptible/down_timeout.  Akaros doesn't have the latter. */
146 #define down_interruptible(sem) ({sem_down(sem); 0;})
147 #define down_timeout(sem, timeout) ({sem_down(sem); 0;})
148
149 /* Linux printk front ends */
150 #ifndef pr_fmt
151 #define pr_fmt(fmt) fmt
152 #endif
153
154 #define KERN_EMERG
155 #define KERN_ALERT
156 #define KERN_CRIT
157 #define KERN_ERR
158 #define KERN_WARNING
159 #define KERN_NOTICE
160 #define KERN_INFO
161 #define KERN_CONT
162 #define KERN_DEBUG
163
164 /*
165  * These can be used to print at the various log levels.
166  * All of these will print unconditionally, although note that pr_debug()
167  * and other debug macros are compiled out unless either DEBUG is defined
168  * or CONFIG_DYNAMIC_DEBUG is set.
169  */
170 #define pr_emerg(fmt, ...) \
171         printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
172 #define pr_alert(fmt, ...) \
173         printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
174 #define pr_crit(fmt, ...) \
175         printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
176 #define pr_err(fmt, ...) \
177         printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
178 #define pr_warning(fmt, ...) \
179         printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
180 #define pr_warn pr_warning
181 #define pr_notice(fmt, ...) \
182         printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
183 #define pr_info(fmt, ...) \
184         printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
185 #define pr_cont(fmt, ...) \
186         printk(KERN_CONT fmt, ##__VA_ARGS__)
187 #define netdev_printk(lvl, dev, fmt, ...) \
188         printk(fmt, ##__VA_ARGS__)
189
190
191 #ifdef DEBUG
192
193 #define might_sleep() assert(can_block(&per_cpu_info[core_id()]))
194 #define pr_devel(fmt, ...) \
195         printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
196
197 #else
198
199 #define might_sleep()
200 #define pr_devel(fmt, ...) \
201         printd(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
202
203 #endif
204 #define pr_debug pr_devel
205
206
207 enum {
208         NETIF_MSG_DRV           = 0x0001,
209         NETIF_MSG_PROBE         = 0x0002,
210         NETIF_MSG_LINK          = 0x0004,
211         NETIF_MSG_TIMER         = 0x0008,
212         NETIF_MSG_IFDOWN        = 0x0010,
213         NETIF_MSG_IFUP          = 0x0020,
214         NETIF_MSG_RX_ERR        = 0x0040,
215         NETIF_MSG_TX_ERR        = 0x0080,
216         NETIF_MSG_TX_QUEUED     = 0x0100,
217         NETIF_MSG_INTR          = 0x0200,
218         NETIF_MSG_TX_DONE       = 0x0400,
219         NETIF_MSG_RX_STATUS     = 0x0800,
220         NETIF_MSG_PKTDATA       = 0x1000,
221         NETIF_MSG_HW            = 0x2000,
222         NETIF_MSG_WOL           = 0x4000,
223 };
224
225 #define MODULE_AUTHOR(...)
226 #define MODULE_DESCRIPTION(...)
227 #define MODULE_LICENSE(...)
228 #define MODULE_VERSION(...)
229 #define MODULE_FIRMWARE(...)
230 #define MODULE_PARM_DESC(...)
231 #define MODULE_DEVICE_TABLE(...)
232 #define THIS_MODULE ((void*)0)
233
234 /* u64 on linux, but a u32 on plan 9.  the typedef is probably a good idea */
235 typedef unsigned int netdev_features_t;
236
237 /* Linux has features, hw_features, and a couple others.  Plan 9 just has
238  * features.  This #define should work for merging hw and regular features.  We
239  * spatched away the hw_enc and vlan feats. */
240 #define hw_features feat
241
242 /* Attempted conversions for plan 9 features.  For some things, like rx
243  * checksums, the driver flags the block (e.g. Budpck) to say if a receive
244  * checksum was already done.  There is no flag for saying the device can do
245  * it.  For transmits, the stack needs to know in advance if the device can
246  * handle the checksum or not. */
247 #define NETIF_F_RXHASH                          0
248 #define NETIF_F_RXCSUM                          0
249 #define NETIF_F_LRO                                     NETF_LRO
250 #define NETIF_F_GRO                                     0
251 #define NETIF_F_LOOPBACK                        0
252 #define NETIF_F_TSO                                     NETF_TSO
253 #define NETIF_F_SG                                      NETF_SG
254 #define NETIF_F_IP_CSUM                         (NETF_IPCK | NETF_UDPCK | NETF_TCPCK)
255 #define NETIF_F_IPV6_CSUM                       (NETF_IPCK | NETF_UDPCK | NETF_TCPCK)
256 #define NETIF_F_GSO_GRE                         0
257 #define NETIF_F_GSO_UDP_TUNNEL          0
258 #define NETIF_F_GSO_IPIP                        0
259 #define NETIF_F_GSO_SIT                         0
260 #define NETIF_F_TSO_ECN                         0
261 #define NETIF_F_TSO6                            0
262 #define NETIF_F_HW_VLAN_CTAG_TX         0
263 #define NETIF_F_HIGHDMA                         0
264 #define NETIF_F_HW_VLAN_CTAG_RX         0
265
266 /* I'd like to spatch all of the pci methods, but I don't know how to do the
267  * reads.  Since we're not doing the reads, then no sense doing the writes. */
268 static inline int pci_read_config_byte(struct pci_device *dev, uint32_t off,
269                                        uint8_t *val)
270 {
271         *val = pcidev_read8(dev, off);
272         return 0;
273 }
274                                        
275 static inline int pci_read_config_word(struct pci_device *dev, uint32_t off,
276                                        uint16_t *val)
277 {
278         *val = pcidev_read16(dev, off);
279         return 0;
280 }
281                                        
282 static inline int pci_read_config_dword(struct pci_device *dev, uint32_t off,
283                                         uint32_t *val)
284 {
285         *val = pcidev_read32(dev, off);
286         return 0;
287 }
288                                        
289 static inline int pci_write_config_byte(struct pci_device *dev, uint32_t off,
290                                         uint8_t val)
291 {
292         pcidev_write8(dev, off, val);
293         return 0;
294 }
295
296 static inline int pci_write_config_word(struct pci_device *dev, uint32_t off,
297                                         uint16_t val)
298 {
299         pcidev_write16(dev, off, val);
300         return 0;
301 }
302
303 static inline int pci_write_config_dword(struct pci_device *dev, uint32_t off,
304                                          uint32_t val)
305 {
306         pcidev_write32(dev, off, val);
307         return 0;
308 }
309
310 #endif /* ROS_KERN_AKAROS_COMPAT_H */