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