Clean up imported rdma headers to compile mlx4
[akaros.git] / kern / include / linux / compat_todo.h
1 /*
2  * Copyright (C) 1991-2015, the Linux Kernel authors
3  *
4  * This source code is licensed under the GNU General Public License,
5  * Version 2. See the file COPYING for more details.
6  *
7  * This file consists of various bits of Linux code used in porting drivers to
8  * Akaros. */
9
10 #ifndef _LINUX_COMPAT_TODO_H
11 #define _LINUX_COMPAT_TODO_H
12
13 #include <arch/types.h>
14 #include <ros/common.h>
15 #include <atomic.h>
16 #include <bitops.h>
17 #include <kthread.h>
18 #include <list.h>
19 #include <stdbool.h>
20 #include <stddef.h>
21 #include <string.h>
22 #include <taskqueue.h>
23
24 #define ETH_ALEN        6               /* Octets in one ethernet addr   */
25 #define ETH_ZLEN        60              /* Min. octets in frame sans FCS */
26 #define ETH_FCS_LEN     4               /* Octets in the FCS             */
27
28 struct ethhdr {
29         unsigned char   h_dest[ETH_ALEN];       /* destination eth addr */
30         unsigned char   h_source[ETH_ALEN];     /* source ether addr    */
31         uint16_t        h_proto;                /* packet type ID field */
32 } __attribute__((packed));
33
34 extern int ____ilog2_NaN;
35
36 /**
37  * ilog2 - log of base 2 of 32-bit or a 64-bit unsigned value
38  * @n - parameter
39  *
40  * constant-capable log of base 2 calculation
41  * - this can be used to initialise global variables from constant data, hence
42  *   the massive ternary operator construction
43  *
44  * selects the appropriately-sized optimised version depending on sizeof(n)
45  */
46 #define ilog2(n)                                \
47 (                                               \
48         __builtin_constant_p(n) ? (             \
49                 (n) < 1 ? ____ilog2_NaN :       \
50                 (n) & (1ULL << 63) ? 63 :       \
51                 (n) & (1ULL << 62) ? 62 :       \
52                 (n) & (1ULL << 61) ? 61 :       \
53                 (n) & (1ULL << 60) ? 60 :       \
54                 (n) & (1ULL << 59) ? 59 :       \
55                 (n) & (1ULL << 58) ? 58 :       \
56                 (n) & (1ULL << 57) ? 57 :       \
57                 (n) & (1ULL << 56) ? 56 :       \
58                 (n) & (1ULL << 55) ? 55 :       \
59                 (n) & (1ULL << 54) ? 54 :       \
60                 (n) & (1ULL << 53) ? 53 :       \
61                 (n) & (1ULL << 52) ? 52 :       \
62                 (n) & (1ULL << 51) ? 51 :       \
63                 (n) & (1ULL << 50) ? 50 :       \
64                 (n) & (1ULL << 49) ? 49 :       \
65                 (n) & (1ULL << 48) ? 48 :       \
66                 (n) & (1ULL << 47) ? 47 :       \
67                 (n) & (1ULL << 46) ? 46 :       \
68                 (n) & (1ULL << 45) ? 45 :       \
69                 (n) & (1ULL << 44) ? 44 :       \
70                 (n) & (1ULL << 43) ? 43 :       \
71                 (n) & (1ULL << 42) ? 42 :       \
72                 (n) & (1ULL << 41) ? 41 :       \
73                 (n) & (1ULL << 40) ? 40 :       \
74                 (n) & (1ULL << 39) ? 39 :       \
75                 (n) & (1ULL << 38) ? 38 :       \
76                 (n) & (1ULL << 37) ? 37 :       \
77                 (n) & (1ULL << 36) ? 36 :       \
78                 (n) & (1ULL << 35) ? 35 :       \
79                 (n) & (1ULL << 34) ? 34 :       \
80                 (n) & (1ULL << 33) ? 33 :       \
81                 (n) & (1ULL << 32) ? 32 :       \
82                 (n) & (1ULL << 31) ? 31 :       \
83                 (n) & (1ULL << 30) ? 30 :       \
84                 (n) & (1ULL << 29) ? 29 :       \
85                 (n) & (1ULL << 28) ? 28 :       \
86                 (n) & (1ULL << 27) ? 27 :       \
87                 (n) & (1ULL << 26) ? 26 :       \
88                 (n) & (1ULL << 25) ? 25 :       \
89                 (n) & (1ULL << 24) ? 24 :       \
90                 (n) & (1ULL << 23) ? 23 :       \
91                 (n) & (1ULL << 22) ? 22 :       \
92                 (n) & (1ULL << 21) ? 21 :       \
93                 (n) & (1ULL << 20) ? 20 :       \
94                 (n) & (1ULL << 19) ? 19 :       \
95                 (n) & (1ULL << 18) ? 18 :       \
96                 (n) & (1ULL << 17) ? 17 :       \
97                 (n) & (1ULL << 16) ? 16 :       \
98                 (n) & (1ULL << 15) ? 15 :       \
99                 (n) & (1ULL << 14) ? 14 :       \
100                 (n) & (1ULL << 13) ? 13 :       \
101                 (n) & (1ULL << 12) ? 12 :       \
102                 (n) & (1ULL << 11) ? 11 :       \
103                 (n) & (1ULL << 10) ? 10 :       \
104                 (n) & (1ULL <<  9) ?  9 :       \
105                 (n) & (1ULL <<  8) ?  8 :       \
106                 (n) & (1ULL <<  7) ?  7 :       \
107                 (n) & (1ULL <<  6) ?  6 :       \
108                 (n) & (1ULL <<  5) ?  5 :       \
109                 (n) & (1ULL <<  4) ?  4 :       \
110                 (n) & (1ULL <<  3) ?  3 :       \
111                 (n) & (1ULL <<  2) ?  2 :       \
112                 (n) & (1ULL <<  1) ?  1 :       \
113                 (n) & (1ULL <<  0) ?  0 :       \
114                 ____ilog2_NaN                   \
115                                    ) :          \
116         LOG2_UP(n)                              \
117  )
118
119 struct rb_node {
120         unsigned long  __rb_parent_color;
121         struct rb_node *rb_right;
122         struct rb_node *rb_left;
123 };
124
125 struct rb_root {
126         struct rb_node *rb_node;
127 };
128
129 #define RB_ROOT (struct rb_root) { NULL, }
130
131 static inline void rb_link_node(struct rb_node * node, struct rb_node * parent,
132                                 struct rb_node ** rb_link)
133 {
134         node->__rb_parent_color = (unsigned long)parent;
135         node->rb_left = node->rb_right = NULL;
136
137         *rb_link = node;
138 }
139
140 #define __printf(...)
141
142 #define sprintf(s, fmt, ...) ({ \
143         int ret = -1; \
144         if (__builtin_types_compatible_p(typeof(s), char[])) \
145                 ret = snprintf(s, sizeof(s), fmt, ##__VA_ARGS__); \
146         else \
147                 panic("Not implemented"); \
148         ret; \
149 })
150
151 #define printk_once(fmt, ...) ({ \
152         static bool __print_once; \
153         if (!__print_once) { \
154                 __print_once = true; \
155                 printk(fmt, ##__VA_ARGS__); \
156         } \
157 })
158
159 #define dev_warn(dev, format, ...) \
160         pr_warn(format, ## __VA_ARGS__)
161
162 #define dev_printk(level, dev, fmt, ...) \
163         printk(level fmt, ## __VA_ARGS__)
164
165 /* XXX This is not a tree. */
166 struct radix_tree_node {
167         unsigned long           index;
168         void                    *item;
169         struct radix_tree_node  *next;
170 };
171
172 struct radix_tree_root {
173         struct radix_tree_node  *rnode;
174 };
175
176 #define INIT_RADIX_TREE(root, mask) \
177 do { \
178         (root)->rnode = NULL; \
179 } while (0)
180
181 static inline int radix_tree_insert(struct radix_tree_root *root,
182                                     unsigned long index, void *item)
183 {
184         struct radix_tree_node *p;
185
186         for (p = root->rnode; p; p = p->next) {
187                 if (p->index == index)
188                         return -EEXIST;
189         }
190         p = kmalloc(sizeof(*p), KMALLOC_WAIT);
191         if (!p)
192                 return -ENOMEM;
193         p->index = index;
194         p->item = item;
195         p->next = root->rnode;
196         root->rnode = p;
197         return 0;
198 }
199
200 static inline void *radix_tree_lookup(struct radix_tree_root *root,
201                                       unsigned long index)
202 {
203         struct radix_tree_node *p;
204
205         for (p = root->rnode; p; p = p->next) {
206                 if (p->index == index)
207                         return p->item;
208         }
209         return NULL;
210 }
211
212 static inline void *radix_tree_delete(struct radix_tree_root *root,
213                                       unsigned long index)
214 {
215         panic("todo");
216 }
217
218 #define INIT_DEFERRABLE_WORK(_work, _func) \
219         INIT_DELAYED_WORK(_work, _func) /* XXX */
220
221 struct tasklet_struct {
222         uint32_t state;
223         void (*func)(unsigned long);
224         unsigned long data;
225 };
226
227 static void __tasklet_wrapper(uint32_t srcid, long a0, long a1, long a2)
228 {
229         struct tasklet_struct *t = (struct tasklet_struct *)a0;
230
231         if (atomic_cas_u32(&t->state, 1, 0))
232                 t->func(t->data);
233 }
234
235 static inline void tasklet_schedule(struct tasklet_struct *t)
236 {
237         if (atomic_cas_u32(&t->state, 0, 1)) {
238                 send_kernel_message(core_id(), __tasklet_wrapper, (long)t, 0, 0,
239                                     KMSG_ROUTINE);
240         }
241 }
242
243 static inline void tasklet_disable(struct tasklet_struct *t)
244 {
245         panic("tasklet_disable unimplemented");
246         // XXX t->state = 2
247 }
248
249 static inline void tasklet_init(struct tasklet_struct *t,
250                                 void (*func)(unsigned long), unsigned long data)
251 {
252         t->state = 0;
253         t->func = func;
254         t->data = data;
255 }
256
257 struct completion {
258         unsigned int done;
259 };
260
261 static inline void init_completion(struct completion *x)
262 {
263         x->done = 0;
264 }
265
266 static inline void reinit_completion(struct completion *x)
267 {
268         printd("Core %d: reinit_completion %p\n", core_id(), x);
269         x->done = 0;
270 }
271
272 static inline void complete(struct completion *x)
273 {
274         printd("Core %d: complete %p\n", core_id(), x);
275         x->done = 1;
276         wmb();
277 }
278
279 static inline void wait_for_completion(struct completion *x)
280 {
281         while (!x->done)
282                 rmb();
283 }
284
285 static inline unsigned long wait_for_completion_timeout(struct completion *x,
286                                                         unsigned long timeout)
287 {
288         printd("Core %d: wait_for_completion_timeout %p\n", core_id(), x);
289         while (!x->done) {
290                 if (timeout) {
291                         volatile int i = 100000;
292                         while (i--);
293                         timeout--;
294                         rmb();
295                 } else {
296                         break;
297                 }
298         }
299         return timeout;
300 }
301
302 struct timer_list {
303         spinlock_t lock;
304         bool scheduled;
305         unsigned long delay;
306         void (*function)(unsigned long);
307         unsigned long data;
308 };
309
310 static inline void init_timer(struct timer_list *timer)
311 {
312         spinlock_init_irqsave(&timer->lock);
313         timer->scheduled = false;
314         timer->delay = 0;
315         timer->function = 0;
316         timer->data = 0;
317 }
318
319 static void __timer_wrapper(uint32_t srcid, long a0, long a1, long a2)
320 {
321         struct timer_list *timer = (struct timer_list *)a0;
322         unsigned long delay = 0;
323
324         spin_lock_irqsave(&timer->lock);
325         delay = timer->delay;
326         timer->scheduled = false;
327         spin_unlock_irqsave(&timer->lock);
328
329         kthread_usleep(delay * 10000);
330         timer->function(timer->data);
331 }
332
333 static inline void add_timer(struct timer_list *timer)
334 {
335         timer->scheduled = true;
336         send_kernel_message(core_id(), __timer_wrapper, (long)timer, 0, 0,
337                             KMSG_ROUTINE);
338 }
339
340 static inline void mod_timer(struct timer_list *timer, unsigned long delay)
341 {
342         spin_lock_irqsave(&timer->lock);
343         timer->delay = delay;
344         if (timer->scheduled) {
345                 spin_unlock_irqsave(&timer->lock);
346                 return;
347         }
348         timer->scheduled = true;
349         spin_unlock_irqsave(&timer->lock);
350         send_kernel_message(core_id(), __timer_wrapper, (long)timer, 0, 0,
351                             KMSG_ROUTINE);
352 }
353
354 static inline void del_timer_sync(struct timer_list *timer)
355 {
356         panic("del_timer_sync unimplemented");
357 }
358
359 struct cpu_rmap {
360 };
361
362 extern unsigned long saved_max_pfn;
363
364 struct device {
365 };
366
367 struct device_attribute {
368 };
369
370 #define DEFINE_MUTEX(mutexname) \
371         qlock_t mutexname = QLOCK_INITIALIZER(mutexname);
372
373 #define IS_ENABLED(...) (0)
374
375 /* linux/compiler-gcc.h */
376 #define __packed                        __attribute__((packed))
377 #define __attribute_const__             __attribute__((__const__))
378 #define __aligned(n)                    __attribute__((aligned(n)))
379 #define __always_unused                 __attribute__((unused))
380
381 /*
382  * Check at compile time that something is of a particular type.
383  * Always evaluates to 1 so you may use it easily in comparisons.
384  */
385 #define typecheck(type,x) \
386 ({      type __dummy; \
387         typeof(x) __dummy2; \
388         (void)(&__dummy == &__dummy2); \
389         1; \
390 })
391
392 /*
393  * Check at compile time that 'function' is a certain type, or is a pointer
394  * to that type (needs to use typedef for the function type.)
395  */
396 #define typecheck_fn(type,function) \
397 ({      typeof(type) __tmp = function; \
398         (void)__tmp; \
399 })
400
401 #if BITS_PER_LONG > 32
402 #define NET_SKBUFF_DATA_USES_OFFSET 1
403 #endif
404
405 #ifdef NET_SKBUFF_DATA_USES_OFFSET
406 typedef unsigned int sk_buff_data_t;
407 #else
408 typedef unsigned char *sk_buff_data_t;
409 #endif
410
411 typedef struct skb_frag_struct skb_frag_t;
412
413 struct skb_frag_struct {
414         struct {
415                 struct page *p;
416         } page;
417 #if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)
418         uint32_t page_offset;
419         uint32_t size;
420 #else
421         uint16_t page_offset;
422         uint16_t size;
423 #endif
424 };
425
426 /* asm-generic/getorder.h */
427 /*
428  * Runtime evaluation of get_order()
429  */
430 static inline __attribute_const__
431 int __get_order(unsigned long size)
432 {
433         int order;
434
435         size--;
436         size >>= PAGE_SHIFT;
437 #if BITS_PER_LONG == 32
438         order = fls(size);
439 #else
440         order = fls64(size);
441 #endif
442         return order;
443 }
444
445 /**
446  * get_order - Determine the allocation order of a memory size
447  * @size: The size for which to get the order
448  *
449  * Determine the allocation order of a particular sized block of memory.  This
450  * is on a logarithmic scale, where:
451  *
452  *      0 -> 2^0 * PAGE_SIZE and below
453  *      1 -> 2^1 * PAGE_SIZE to 2^0 * PAGE_SIZE + 1
454  *      2 -> 2^2 * PAGE_SIZE to 2^1 * PAGE_SIZE + 1
455  *      3 -> 2^3 * PAGE_SIZE to 2^2 * PAGE_SIZE + 1
456  *      4 -> 2^4 * PAGE_SIZE to 2^3 * PAGE_SIZE + 1
457  *      ...
458  *
459  * The order returned is used to find the smallest allocation granule required
460  * to hold an object of the specified size.
461  *
462  * The result is undefined if the size is 0.
463  *
464  * This function may be used to initialise variables with compile time
465  * evaluations of constants.
466  */
467 #define get_order(n)                                            \
468 (                                                               \
469         __builtin_constant_p(n) ? (                             \
470                 ((n) == 0UL) ? BITS_PER_LONG - PAGE_SHIFT :     \
471                 (((n) < (1UL << PAGE_SHIFT)) ? 0 :              \
472                  ilog2((n) - 1) - PAGE_SHIFT + 1)               \
473         ) :                                                     \
474         __get_order(n)                                          \
475 )
476
477 /* asm-generic/io.h */
478 static inline void __raw_writeq(uint64_t value, volatile void *addr)
479 {
480         *(volatile uint64_t *)addr = value;
481 }
482
483 /* linux/export.h */
484 #define EXPORT_SYMBOL_GPL(...)
485
486 /* linux/gfp.h */
487 #define  __GFP_DMA              0x01u
488 #define  __GFP_HIGHMEM          0x02u
489 #define  __GFP_DMA32            0x04u
490 #define  __GFP_MOVABLE          0x08u
491 #define  __GFP_WAIT             0x10u
492 #define  __GFP_HIGH             0x20u
493 #define  __GFP_IO               0x40u
494 #define  __GFP_FS               0x80u
495 #define  __GFP_COLD             0x100u
496 #define  __GFP_NOWARN           0x200u
497 #define  __GFP_REPEAT           0x400u
498 #define  __GFP_NOFAIL           0x800u
499 #define  __GFP_NORETRY          0x1000u
500 #define  __GFP_MEMALLOC         0x2000u
501 #define  __GFP_COMP             0x4000u
502 #define  __GFP_ZERO             0x8000u
503 #define  __GFP_NOMEMALLOC       0x10000u
504 #define  __GFP_HARDWALL         0x20000u
505 #define  __GFP_THISNODE         0x40000u
506 #define  __GFP_RECLAIMABLE      0x80000u
507 #define  __GFP_NOACCOUNT        0x100000u
508 #define  __GFP_NOTRACK          0x200000u
509 #define  __GFP_NO_KSWAPD        0x400000u
510 #define  __GFP_OTHER_NODE       0x800000u
511 #define  __GFP_WRITE            0x1000000u
512 /* If the above are modified, __GFP_BITS_SHIFT may need updating */
513
514 #define GFP_HIGHUSER 0
515
516 /* linux/kernel.h */
517 #define min3(x, y, z) MIN((typeof(x))MIN(x, y), z)
518 #define max3(x, y, z) MAX((typeof(x))MAX(x, y), z)
519
520 #define SIZE_MAX        (~(size_t)0)
521
522 typedef unsigned int pci_channel_state_t;
523
524 enum pci_channel_state {
525         /* I/O channel is in normal state */
526         pci_channel_io_normal = 1,
527
528         /* I/O to channel is blocked */
529         pci_channel_io_frozen = 2,
530
531         /* PCI card is dead */
532         pci_channel_io_perm_failure = 3,
533 };
534
535 typedef unsigned int pci_ers_result_t;
536
537 enum pci_ers_result {
538         /* no result/none/not supported in device driver */
539         PCI_ERS_RESULT_NONE = 1,
540
541         /* Device driver can recover without slot reset */
542         PCI_ERS_RESULT_CAN_RECOVER = 2,
543
544         /* Device driver wants slot to be reset. */
545         PCI_ERS_RESULT_NEED_RESET = 3,
546
547         /* Device has completely failed, is unrecoverable */
548         PCI_ERS_RESULT_DISCONNECT = 4,
549
550         /* Device driver is fully recovered and operational */
551         PCI_ERS_RESULT_RECOVERED = 5,
552
553         /* No AER capabilities registered for the driver */
554         PCI_ERS_RESULT_NO_AER_DRIVER = 6,
555 };
556
557 /* These values come from the PCI Express Spec */
558 enum pcie_link_width {
559         PCIE_LNK_WIDTH_RESRV    = 0x00,
560         PCIE_LNK_X1             = 0x01,
561         PCIE_LNK_X2             = 0x02,
562         PCIE_LNK_X4             = 0x04,
563         PCIE_LNK_X8             = 0x08,
564         PCIE_LNK_X12            = 0x0C,
565         PCIE_LNK_X16            = 0x10,
566         PCIE_LNK_X32            = 0x20,
567         PCIE_LNK_WIDTH_UNKNOWN  = 0xFF,
568 };
569
570 /* Based on the PCI Hotplug Spec, but some values are made up by us */
571 enum pci_bus_speed {
572         PCI_SPEED_33MHz                 = 0x00,
573         PCI_SPEED_66MHz                 = 0x01,
574         PCI_SPEED_66MHz_PCIX            = 0x02,
575         PCI_SPEED_100MHz_PCIX           = 0x03,
576         PCI_SPEED_133MHz_PCIX           = 0x04,
577         PCI_SPEED_66MHz_PCIX_ECC        = 0x05,
578         PCI_SPEED_100MHz_PCIX_ECC       = 0x06,
579         PCI_SPEED_133MHz_PCIX_ECC       = 0x07,
580         PCI_SPEED_66MHz_PCIX_266        = 0x09,
581         PCI_SPEED_100MHz_PCIX_266       = 0x0a,
582         PCI_SPEED_133MHz_PCIX_266       = 0x0b,
583         AGP_UNKNOWN                     = 0x0c,
584         AGP_1X                          = 0x0d,
585         AGP_2X                          = 0x0e,
586         AGP_4X                          = 0x0f,
587         AGP_8X                          = 0x10,
588         PCI_SPEED_66MHz_PCIX_533        = 0x11,
589         PCI_SPEED_100MHz_PCIX_533       = 0x12,
590         PCI_SPEED_133MHz_PCIX_533       = 0x13,
591         PCIE_SPEED_2_5GT                = 0x14,
592         PCIE_SPEED_5_0GT                = 0x15,
593         PCIE_SPEED_8_0GT                = 0x16,
594         PCI_SPEED_UNKNOWN               = 0xff,
595 };
596
597 /* linux/slab.h */
598 #define kzalloc_node(...) (0 /* XXX */)
599
600 #define __cpu_to_le32(x) (x)
601 #define __le32_to_cpu(x) (x)
602
603 #define swab32 __builtin_bswap32
604
605 #define cond_resched() { /* XXX */ \
606         volatile int i = 100000; \
607         /* printk("%s:%d %s cond_resched\n", __FILE__, __LINE__, __FUNCTION__); */ \
608         while (i--); \
609 }
610
611 #define iounmap(...) (0 /* XXX */)
612
613 typedef uint64_t phys_addr_t;
614 typedef phys_addr_t resource_size_t;
615
616 struct dma_pool *dma_pool_create(const char *name, void *dev,
617                                  size_t size, size_t align, size_t allocation);
618
619 void dma_pool_destroy(struct dma_pool *pool);
620
621 void *dma_pool_alloc(struct dma_pool *pool, int mem_flags, dma_addr_t *handle);
622
623 void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t addr);
624
625 #define pci_pool dma_pool
626 #define pci_pool_create(name, pdev, size, align, allocation) \
627                 dma_pool_create(name, pdev, size, align, allocation)
628 #define pci_pool_destroy(pool) dma_pool_destroy(pool)
629 #define pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
630 #define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
631
632 #define __user
633 #define __bitwise
634
635 struct vm_area_struct {
636 };
637
638 /* uapi/rdma/ib_user_mad.h */
639 #define IB_USER_MAD_USER_RMPP 1
640
641 #define be16_to_cpup(p) be16_to_cpu(*(uint16_t *)(p))
642 #define be32_to_cpup(p) be32_to_cpu(*(uint32_t *)(p))
643
644 /* access_ok.h */
645
646 static inline uint16_t get_unaligned_le16(const void *p)
647 {
648         return le16_to_cpu(*(uint16_t *)p);
649 }
650
651 static inline uint32_t get_unaligned_le32(const void *p)
652 {
653         return le32_to_cpu(*(uint32_t *)p);
654 }
655
656 static inline uint64_t get_unaligned_le64(const void *p)
657 {
658         return le64_to_cpu(*(uint64_t *)p);
659 }
660
661 static inline void put_unaligned_le16(uint16_t val, void *p)
662 {
663         *((uint16_t *)p) = cpu_to_le16(val);
664 }
665
666 static inline void put_unaligned_le32(uint32_t val, void *p)
667 {
668         *((uint32_t *)p) = cpu_to_le32(val);
669 }
670
671 static inline void put_unaligned_le64(uint64_t val, void *p)
672 {
673         *((uint64_t *)p) = cpu_to_le64(val);
674 }
675
676 extern void __bad_unaligned_access_size(void);
677
678 #define __get_unaligned_le(ptr) ({ \
679         __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \
680         __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_le16((ptr)), \
681         __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_le32((ptr)), \
682         __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_le64((ptr)), \
683         __bad_unaligned_access_size())))); \
684 })
685
686 #define __put_unaligned_le(val, ptr) ({                                 \
687         void *__gu_p = (ptr);                                           \
688         switch (sizeof(*(ptr))) {                                       \
689         case 1:                                                         \
690                 *(uint8_t *)__gu_p = (uint8_t)(val);                    \
691                 break;                                                  \
692         case 2:                                                         \
693                 put_unaligned_le16((uint16_t)(val), __gu_p);            \
694                 break;                                                  \
695         case 4:                                                         \
696                 put_unaligned_le32((uint32_t)(val), __gu_p);            \
697                 break;                                                  \
698         case 8:                                                         \
699                 put_unaligned_le64((uint64_t)(val), __gu_p);            \
700                 break;                                                  \
701         default:                                                        \
702                 __bad_unaligned_access_size();                          \
703                 break;                                                  \
704         }                                                               \
705         (void)0; })
706
707 #define get_unaligned __get_unaligned_le
708 #define put_unaligned __put_unaligned_le
709
710 #define vmalloc_node(...) (0 /* XXX */)
711 /* needed by icm.c: */
712 #define kmalloc_node(size, flags, node) 0
713 #define alloc_pages_node(nid, gfp_mask, order) 0
714
715 struct scatterlist {
716         unsigned long   page_link;
717         unsigned int    offset;
718         unsigned int    length;
719         dma_addr_t      dma_address;
720 };
721
722 #define sg_dma_address(sg) ((sg)->dma_address)
723 #define sg_dma_len(sg) ((sg)->length)
724
725 #define sg_is_chain(sg) ((sg)->page_link & 0x01)
726 #define sg_is_last(sg) ((sg)->page_link & 0x02)
727 #define sg_chain_ptr(sg) ((struct scatterlist *) ((sg)->page_link & ~0x03))
728
729 static inline void sg_assign_page(struct scatterlist *sg, struct page *page)
730 {
731         unsigned long page_link = sg->page_link & 0x3;
732         sg->page_link = page_link | (unsigned long) page;
733 }
734
735 /**
736  * sg_set_page - Set sg entry to point at given page
737  * @sg:          SG entry
738  * @page:        The page
739  * @len:         Length of data
740  * @offset:      Offset into page
741  *
742  * Description:
743  *   Use this function to set an sg entry pointing at a page, never assign
744  *   the page directly. We encode sg table information in the lower bits
745  *   of the page pointer. See sg_page() for looking up the page belonging
746  *   to an sg entry.
747  *
748  **/
749 static inline void sg_set_page(struct scatterlist *sg, struct page *page,
750                                unsigned int len, unsigned int offset)
751 {
752         sg_assign_page(sg, page);
753         sg->offset = offset;
754         sg->length = len;
755 }
756
757 static inline struct page *sg_page(struct scatterlist *sg)
758 {
759         return (struct page *)(sg->page_link & ~0x3);
760 }
761
762 static inline void sg_set_buf(struct scatterlist *sg, void *buf,
763                               unsigned int buflen)
764 {
765         sg_set_page(sg, kva2page(buf), buflen, PGOFF(buf));
766 }
767
768 #define for_each_sg(sglist, sg, nr, __i) \
769         for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg))
770
771 static inline void sg_mark_end(struct scatterlist *sg)
772 {
773         /*
774          * Set termination bit, clear potential chain bit
775          */
776         sg->page_link |= 0x02;
777         sg->page_link &= ~0x01;
778 }
779
780 void sg_init_table(struct scatterlist *, unsigned int);
781 struct scatterlist *sg_next(struct scatterlist *);
782
783 static inline int nontranslate_map_sg(void *dev, struct scatterlist *sglist,
784                                       int nelems, int dir)
785 {
786         int i;
787         struct scatterlist *sg;
788
789         for_each_sg(sglist, sg, nelems, i) {
790                 sg_dma_address(sg) = page2pa(sg_page(sg)) + sg->offset;
791                 sg_dma_len(sg) = sg->length;
792         }
793         return nelems;
794 }
795
796 static inline int dma_map_sg(void *dev, struct scatterlist *sg, int nents,
797                              enum dma_data_direction dir)
798 {
799         return nontranslate_map_sg(dev, sg, nents, dir);
800 }
801
802 static inline void dma_unmap_sg(void *dev, struct scatterlist *sg, int nents,
803                                 enum dma_data_direction dir)
804 {
805         /* TODO nop */
806 }
807
808 struct dma_attrs {
809 };
810
811 #define dma_map_sg_attrs(d, s, n, r, a) dma_map_sg(d, s, n, r)
812 #define dma_unmap_sg_attrs(d, s, n, r, a) dma_unmap_sg(d, s, n, r)
813
814 static inline int pci_map_sg(struct pci_device *pdev, struct scatterlist *sg,
815                              int nents, int direction)
816 {
817         return dma_map_sg(NULL, sg, nents, (enum dma_data_direction)direction);
818 }
819
820 static inline void pci_unmap_sg(struct pci_device *pdev, struct scatterlist *sg,
821                                 int nents, int direction)
822 {
823         dma_unmap_sg(NULL, sg, nents, (enum dma_data_direction)direction);
824 }
825
826 #define cache_line_size() get_cache_line_size_bytes(available_caches.l1)
827
828 static inline void *lowmem_page_address(struct page *page)
829 {
830         /* XXX not sure about this */
831         return page2kva(page);
832 }
833
834 #define page_address(page) lowmem_page_address(page)
835
836 #define netif_get_num_default_rss_queues() (8 /* FIXME */)
837
838 static inline void netdev_rss_key_fill(void *buffer, size_t len)
839 {
840         /* XXX */
841         memset(buffer, 0, len);
842 }
843
844 /* Hacked up version of Linux's.  Assuming reg's are implemented and
845  * read_config never fails. */
846 static int pcie_capability_read_dword(struct pci_device *dev, int pos,
847                                       uint32_t *val)
848 {
849         uint32_t pcie_cap;
850         *val = 0;
851         if (pos & 3)
852                 return -EINVAL;
853         if (pci_find_cap(dev, PCI_CAP_ID_EXP, &pcie_cap))
854                 return -EINVAL;
855         pci_read_config_dword(dev, pcie_cap + pos, val);
856         return 0;
857 }
858
859 static inline const char *pci_name(const struct pci_device *pdev)
860 {
861         return "pci"; // TODO
862 }
863
864 #define dev_name(dev) ("ether0" /* XXX */)
865
866 #define pci_request_regions(...) (0 /* XXX */)
867 #define pci_save_state(...) (0 /* XXX */)
868 #define pci_set_consistent_dma_mask(...) (0 /* XXX */)
869 #define pci_set_dma_mask(...) (0 /* XXX */)
870 #define pci_channel_offline(...) (0 /* XXX */)
871 #define dma_set_max_seg_size(...) (0 /* XXX */)
872 #define dma_get_cache_alignment(...) (1 /* XXX */)
873 #define dev_to_node(...) (0 /* XXX */)
874 #define set_dev_node(...) /* TODO */
875 #define num_online_cpus() (1U /* XXX */)
876 #define cpu_to_node(cpu) ((void)(cpu),0)
877
878 #define pcie_get_minimum_link(dev, speed, width) ({ \
879         *(speed) = PCIE_SPEED_8_0GT; \
880         *(width) = PCIE_LNK_X8; \
881         0; })
882
883 static inline void get_random_bytes(char *buf, int nbytes)
884 {
885         // FIXME this is not random
886         for (int i = 0; i < nbytes; i++)
887                 buf[i] = i;
888 }
889
890 /* linux/moduleparam.h */
891 #define module_param_array(...)
892
893 #define ATOMIC_INIT(i) (i)
894
895 /* linux/ioport.h */
896 #define IORESOURCE_MEM          0x00000200
897
898 /* linux/pci_ids.h */
899 #define PCI_VENDOR_ID_MELLANOX          0x15b3
900
901 struct sysinfo {
902         long uptime;             /* Seconds since boot */
903         unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
904         unsigned long totalram;  /* Total usable main memory size */
905         unsigned long freeram;   /* Available memory size */
906         unsigned long sharedram; /* Amount of shared memory */
907         unsigned long bufferram; /* Memory used by buffers */
908         unsigned long totalswap; /* Total swap space size */
909         unsigned long freeswap;  /* swap space still available */
910         unsigned short procs;    /* Number of current processes */
911         unsigned long totalhigh; /* Total high memory size */
912         unsigned long freehigh;  /* Available high memory size */
913         unsigned int mem_unit;   /* Memory unit size in bytes */
914         char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
915 };
916
917 #define pci_pcie_cap(...) (0 /* TODO use pci_device->caps ? */)
918
919 #define NET_IP_ALIGN 2
920 #define ____cacheline_aligned_in_smp
921
922 typedef struct cpumask { } cpumask_t;
923 typedef struct cpumask cpumask_var_t[1];
924
925 #define cpumask_set_cpu(...) (0 /* TODO */)
926 #define zalloc_cpumask_var(...) (1 /* TODO */)
927 #define cpumask_local_spread(...) (0 /* TODO */)
928
929 struct notifier_block {
930 };
931
932 struct net_device_stats {
933         unsigned long tx_dropped;
934         unsigned long rx_dropped;
935 };
936
937 struct hwtstamp_config {
938         int flags;
939         int tx_type;
940         int rx_filter;
941 };
942
943 struct skb_shared_hwtstamps {
944 };
945
946 #define VLAN_N_VID 4096
947
948 /* linux/if_vlan.h */
949 #define VLAN_PRIO_SHIFT 13
950
951 /* linux/pci.h */
952 #define PCI_DMA_BIDIRECTIONAL   0
953 #define PCI_DMA_TODEVICE        1
954 #define PCI_DMA_FROMDEVICE      2
955 #define PCI_DMA_NONE            3
956
957 /* uapi/linux/net_tstamp.h */
958 enum hwtstamp_tx_types {
959         HWTSTAMP_TX_OFF,
960         HWTSTAMP_TX_ON,
961         HWTSTAMP_TX_ONESTEP_SYNC,
962 };
963
964 /* linux/skbuff.h */
965 enum {
966         SKBTX_HW_TSTAMP = 1 << 0,
967         SKBTX_SW_TSTAMP = 1 << 1,
968         SKBTX_IN_PROGRESS = 1 << 2,
969         SKBTX_DEV_ZEROCOPY = 1 << 3,
970         SKBTX_WIFI_STATUS = 1 << 4,
971         SKBTX_SHARED_FRAG = 1 << 5,
972         SKBTX_SCHED_TSTAMP = 1 << 6,
973         SKBTX_ACK_TSTAMP = 1 << 7,
974 };
975 #define CHECKSUM_NONE           0
976 #define CHECKSUM_UNNECESSARY    1
977 #define CHECKSUM_COMPLETE       2
978 #define CHECKSUM_PARTIAL        3
979
980 #define IPPROTO_IP 0
981 #define IPPROTO_ICMP 1
982 #define IPPROTO_TCP 6
983 #define IPPROTO_UDP 17
984 #define IPPROTO_GRE 47
985
986 #define IFNAMSIZ 16
987 #define MAX_ADDR_LEN 32
988
989 /* linux/mmzone.h */
990 #define PAGE_ALLOC_COSTLY_ORDER 3
991
992 /* linux/cache.h */
993 #define L1_CACHE_BYTES (1 << L1_CACHE_SHIFT)
994 #define SMP_CACHE_BYTES L1_CACHE_BYTES
995
996 /* linux/if_vlan.h */
997 #define VLAN_HLEN 4
998
999 #define NETIF_F_RXFCS 0
1000
1001 #define irq_to_desc(irq) ({ /* I_AM_HERE; */ NULL; /* TODO */ })
1002
1003 static inline void eth_broadcast_addr(uint8_t *addr)
1004 {
1005         memset(addr, 0xff, Eaddrlen);
1006 }
1007
1008 static inline bool netif_carrier_ok(struct ether *dev)
1009 {
1010         return true; // XXX
1011 }
1012
1013 #define BOND_LINK_FAIL 1
1014 #define BOND_LINK_UP 2
1015 #define BOND_MODE_8023AD 1
1016 #define BOND_MODE_ACTIVEBACKUP 2
1017 #define BOND_MODE_XOR 3
1018 #define BOND_STATE_BACKUP 0
1019 #define eth_validate_addr 0
1020 #define HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ 1
1021 #define HWTSTAMP_FILTER_PTP_V1_L4_EVENT 2
1022 #define HWTSTAMP_FILTER_PTP_V1_L4_SYNC 3
1023 #define HWTSTAMP_FILTER_PTP_V2_DELAY_REQ 4
1024 #define HWTSTAMP_FILTER_PTP_V2_EVENT 5
1025 #define HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ 6
1026 #define HWTSTAMP_FILTER_PTP_V2_L2_EVENT 7
1027 #define HWTSTAMP_FILTER_PTP_V2_L2_SYNC 8
1028 #define HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ 9
1029 #define HWTSTAMP_FILTER_PTP_V2_L4_EVENT 10
1030 #define HWTSTAMP_FILTER_PTP_V2_L4_SYNC 11
1031 #define HWTSTAMP_FILTER_PTP_V2_SYNC 12
1032 #define HWTSTAMP_FILTER_SOME 13
1033 #define HWTSTAMP_FILTER_ALL 14
1034 #define HWTSTAMP_FILTER_NONE 15
1035 #define IFF_ALLMULTI 1
1036 #define IFF_PROMISC 2
1037 #define IFF_UNICAST_FLT 3
1038 #define NETDEV_BONDING_INFO 0
1039 #define NETIF_F_HW_VLAN_CTAG_FILTER 1
1040 #define NETIF_F_NTUPLE 2
1041 #define NETIF_F_RXALL 3
1042 #define NOTIFY_DONE 0
1043 #define SIOCGHWTSTAMP 1
1044 #define SIOCSHWTSTAMP 2
1045
1046 #endif