9f3033205b3ed7e285564bdbd785068bed182459
[akaros.git] / kern / include / linux_compat.h
1 /* Copyright (c) 2015 Google Inc.
2  * Copyright (C) 1991-2017, the Linux Kernel authors
3  *
4  * Dumping ground for converting between Akaros and Linux. */
5
6 #pragma once
7
8 #define ROS_KERN_LINUX_COMPAT_H
9
10 /* Common headers that most driver files will need */
11
12 #include <ros/common.h>
13 #include <assert.h>
14 #include <error.h>
15 #include <net/ip.h>
16 #include <kmalloc.h>
17 #include <kref.h>
18 #include <pmap.h>
19 #include <slab.h>
20 #include <smp.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <bitmap.h>
24 #include <umem.h>
25 #include <mmio.h>
26 #include <taskqueue.h>
27 #include <zlib.h>
28 #include <list.h>
29 #include <refd_pages.h>
30 #include <linux/errno.h>
31 /* temporary dumping ground */
32 #include "compat_todo.h"
33
34 //#define CONFIG_DCB
35 //#define CONFIG_NET_RX_BUSY_POLL 1
36 //#define CONFIG_NET_POLL_CONTROLLER 1
37 //#define CONFIG_INET 1         // will deal with this manually
38 #define CONFIG_PCI_MSI 1
39
40 #define __rcu
41 #define rcu_read_lock()
42 #define rcu_read_unlock()
43 #define rcu_dereference(x) (x)
44 #define rcu_dereference_protected(x, y) (x)
45 #ifndef rcu_assign_pointer
46 #define rcu_assign_pointer(dst, src) (dst) = (src)
47 #endif
48 #define RCU_INIT_POINTER(dst, src) rcu_assign_pointer(dst, src)
49 #define synchronize_rcu()
50 #define synchronize_sched()
51
52 #define atomic_cmpxchg(_addr, _old, _new)                                      \
53 ({                                                                             \
54         typeof(_old) _ret;                                                         \
55         if (atomic_cas((_addr), (_old), (_new)))                                   \
56                 _ret = _old;                                                           \
57         else                                                                       \
58                 _ret = atomic_read(_addr);                                             \
59         _ret;                                                                      \
60 })
61
62 #define UINT_MAX UINT64_MAX
63 #define L1_CACHE_SHIFT (LOG2_UP(ARCH_CL_SIZE))
64 #define __stringify(x...) STRINGIFY(x)
65
66 /* Wanted to keep the _t variants in the code, in case that's useful in the
67  * future */
68 #define MIN_T(t, a, b) MIN(a, b)
69 #define MAX_T(t, a, b) MAX(a, b)
70 #define CLAMP(val, lo, hi) MIN((typeof(val))MAX(val, lo), hi)
71 #define CLAMP_T(t, val, lo, hi) CLAMP(val, lo, hi)
72
73 typedef physaddr_t dma_addr_t;
74 typedef int gfp_t;
75
76 /* these dma funcs are empty in linux with !CONFIG_NEED_DMA_MAP_STATE */
77 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)
78 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)
79 #define dma_unmap_addr(PTR, ADDR_NAME)           (0)
80 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  do { } while (0)
81 #define dma_unmap_len(PTR, LEN_NAME)             (0)
82 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    do { } while (0)
83 #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL << (n)) - 1))
84 #define DMA_MASK_NONE 0x0ULL
85
86 enum dma_data_direction {
87         DMA_BIDIRECTIONAL = 0,
88         DMA_TO_DEVICE = 1,
89         DMA_FROM_DEVICE = 2,
90         DMA_NONE = 3,
91 };
92
93 static inline void *__dma_alloc_coherent(size_t size, dma_addr_t *dma_handle,
94                                          gfp_t flags)
95 {
96         void *vaddr = get_cont_pages(LOG2_UP(nr_pages(size)), flags);
97
98         if (!vaddr) {
99                 *dma_handle = 0;
100                 return 0;
101         }
102         *dma_handle = PADDR(vaddr);
103         return vaddr;
104 }
105
106 static inline void *__dma_zalloc_coherent(size_t size, dma_addr_t *dma_handle,
107                                           gfp_t flags)
108 {
109         void *vaddr = __dma_alloc_coherent(size, dma_handle, flags);
110         if (vaddr)
111                 memset(vaddr, 0, size);
112         return vaddr;
113 }
114
115 static inline void __dma_free_coherent(size_t size, void *cpu_addr,
116                                        dma_addr_t dma_handle)
117 {
118         free_cont_pages(cpu_addr, LOG2_UP(nr_pages(size)));
119 }
120
121 static inline dma_addr_t __dma_map_single(void *cpu_addr, size_t size,
122                                           int direction)
123 {
124         return PADDR(cpu_addr);
125 }
126
127 static inline dma_addr_t __dma_map_page(struct page *page,
128                                         unsigned long offset, size_t size,
129                                         int direction)
130 {
131         assert(offset == 0);
132         return page2pa(page);
133 }
134
135 static inline int __dma_mapping_error(dma_addr_t dma_addr)
136 {
137         return (dma_addr == 0);
138 }
139
140 #define dma_unmap_single(...)
141 #define dma_unmap_page(...)
142 #define dma_set_mask_and_coherent(...) (0)
143 #define dma_sync_single_for_cpu(...)
144 #define dma_sync_single_for_device(...)
145
146 /* Wrappers to avoid struct device.  Might want that one of these days.
147  *
148  * Note dma_alloc_coherent() does a zalloc.  Some Linux drivers (r8169)
149  * accidentally assume the memory is zeroed, which may be what Linux allocators
150  * often do. */
151 #define dma_alloc_coherent(dev, size, dma_handlep, flag)                       \
152         __dma_zalloc_coherent(size, dma_handlep, flag)
153
154 #define dma_zalloc_coherent(dev, size, dma_handlep, flag)                      \
155         __dma_zalloc_coherent(size, dma_handlep, flag)
156
157 #define dma_free_coherent(dev, size, dma_handle, flag)                         \
158         __dma_free_coherent(size, dma_handle, flag)
159
160 #define dma_map_single(dev, addr, size, direction)                             \
161         __dma_map_single(addr, size, direction)
162
163 #define dma_map_page(dev, page, offset, size, direction)                       \
164         __dma_map_page(page, offset, size, direction)
165
166 #define dma_mapping_error(dev, handle)                                         \
167         __dma_mapping_error(handle)
168
169 static void *vmalloc(size_t size)
170 {
171         void *vaddr = get_cont_pages(LOG2_UP(nr_pages(size)), MEM_WAIT);
172         /* zalloc, to be safe */
173         if (vaddr)
174                 memset(vaddr, 0, size);
175         return vaddr;
176 }
177
178 /* Akaros needs to know the size, for now.  So it's not quite compatible */
179 static void vfree(void *vaddr, size_t size)
180 {
181         free_cont_pages(vaddr, LOG2_UP(nr_pages(size)));
182 }
183
184 typedef int pci_power_t;
185 typedef int pm_message_t;
186
187 #define DEFINE_SEMAPHORE(name)  \
188     struct semaphore name = SEMAPHORE_INITIALIZER_IRQSAVE(name, 1)
189 #define sema_init(sem, val) sem_init_irqsave(sem, val)
190 #define up(sem) sem_up(sem)
191 #define down(sem) sem_down(sem)
192 #define down_trylock(sem) ({!sem_trydown(sem);})
193 /* In lieu of spatching, I wanted to keep the distinction between down and
194  * down_interruptible/down_timeout.  Akaros doesn't have the latter. */
195 #define down_interruptible(sem) ({sem_down(sem); 0;})
196 #define down_timeout(sem, timeout) ({sem_down(sem); 0;})
197
198 static void msleep(unsigned int msecs)
199 {
200         kthread_usleep(msecs * 1000);
201 }
202
203 #define mdelay(x) udelay((x) * 1000)
204
205 #define local_bh_disable() cmb()
206 #define local_bh_enable() cmb()
207
208 /* Linux printk front ends */
209 #ifndef pr_fmt
210 #define pr_fmt(fmt) fmt
211 #endif
212
213 #define KERN_EMERG ""
214 #define KERN_ALERT ""
215 #define KERN_CRIT ""
216 #define KERN_ERR ""
217 #define KERN_WARNING ""
218 #define KERN_NOTICE ""
219 #define KERN_INFO ""
220 #define KERN_CONT ""
221 #define KERN_DEBUG ""
222
223 /*
224  * These can be used to print at the various log levels.
225  * All of these will print unconditionally, although note that pr_debug()
226  * and other debug macros are compiled out unless either DEBUG is defined
227  * or CONFIG_DYNAMIC_DEBUG is set.
228  */
229 #define pr_emerg(fmt, ...) \
230         printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
231 #define pr_alert(fmt, ...) \
232         printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
233 #define pr_crit(fmt, ...) \
234         printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
235 #define pr_err(fmt, ...) \
236         printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
237 #define pr_warning(fmt, ...) \
238         printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
239 #define pr_warn pr_warning
240 #define pr_notice(fmt, ...) \
241         printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
242 #define pr_info(fmt, ...) \
243         printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
244 #define pr_cont(fmt, ...) \
245         printk(KERN_CONT pr_fmt(fmt), ##__VA_ARGS__)
246
247 #define __print_netif_name(dev) (dev)->drv_name[0] ? (dev)->drv_name : "netdev"
248
249 #define netdev_printk(lvl, dev, fmt, ...) \
250         printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
251 #define netdev_err(dev, fmt, ...) \
252         printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
253 #define netdev_info(dev, fmt, ...) \
254         printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
255 #define netdev_dbg(dev, fmt, ...) \
256         printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
257 #define netif_err(priv, type, dev, fmt, ...) \
258         printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
259 #define netif_warn(priv, type, dev, fmt, ...) \
260         printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
261 #define netif_notice(priv, type, dev, fmt, ...) \
262         printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
263 #define netif_info(priv, type, dev, fmt, ...) \
264         printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
265 #define netif_dbg(priv, type, dev, fmt, ...) \
266         printk("[%s]: " fmt, __print_netif_name(dev), ##__VA_ARGS__)
267
268 #define dev_err(dev, fmt, ...) \
269         printk("[dev]: " fmt, ##__VA_ARGS__)
270 #define dev_info(dev, fmt, ...) \
271         printk("[dev]: " fmt, ##__VA_ARGS__)
272 #define dev_alert(dev, fmt, ...) \
273         printk("[dev]: " fmt, ##__VA_ARGS__)
274
275 #ifdef DEBUG
276
277 #define might_sleep() assert(can_block(&per_cpu_info[core_id()]))
278 #define pr_devel(fmt, ...) \
279         printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
280
281 #else
282
283 #define might_sleep()
284 #define pr_devel(fmt, ...) \
285         printd(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
286
287 #endif
288 #define pr_debug pr_devel
289
290
291 enum {
292         NETIF_MSG_DRV           = 0x0001,
293         NETIF_MSG_PROBE         = 0x0002,
294         NETIF_MSG_LINK          = 0x0004,
295         NETIF_MSG_TIMER         = 0x0008,
296         NETIF_MSG_IFDOWN        = 0x0010,
297         NETIF_MSG_IFUP          = 0x0020,
298         NETIF_MSG_RX_ERR        = 0x0040,
299         NETIF_MSG_TX_ERR        = 0x0080,
300         NETIF_MSG_TX_QUEUED     = 0x0100,
301         NETIF_MSG_INTR          = 0x0200,
302         NETIF_MSG_TX_DONE       = 0x0400,
303         NETIF_MSG_RX_STATUS     = 0x0800,
304         NETIF_MSG_PKTDATA       = 0x1000,
305         NETIF_MSG_HW            = 0x2000,
306         NETIF_MSG_WOL           = 0x4000,
307 };
308
309 #define MODULE_AUTHOR(...)
310 #define MODULE_DESCRIPTION(...)
311 #define MODULE_LICENSE(...)
312 #define MODULE_VERSION(...)
313 #define MODULE_FIRMWARE(...)
314 #define module_param(...)
315 #define module_param_named(...)
316 #define MODULE_PARM_DESC(...)
317 #define MODULE_DEVICE_TABLE(...)
318 #define THIS_MODULE ((void*)0)
319 #define EXPORT_SYMBOL(...)
320 #define __init
321 #define __exit
322 #define module_init(...)
323 #define module_exit(...)
324
325 #define is_kdump_kernel() (0)
326
327 /* from Linux's ethtool.h.  We probably won't use any of this code, but at
328  * least we can keep it quiet during porting. */
329 #define SPEED_10        10
330 #define SPEED_100       100
331 #define SPEED_1000      1000
332 #define SPEED_2500      2500
333 #define SPEED_10000     10000
334 #define SPEED_20000     20000
335 #define SPEED_40000     40000
336 #define SPEED_56000     56000
337 #define SPEED_UNKNOWN   -1
338
339 /* Duplex, half or full. */
340 #define DUPLEX_HALF     0x00
341 #define DUPLEX_FULL     0x01
342 #define DUPLEX_UNKNOWN  0xff
343
344 #define SUPPORTED_10baseT_Half      (1 << 0)
345 #define SUPPORTED_10baseT_Full      (1 << 1)
346 #define SUPPORTED_100baseT_Half     (1 << 2)
347 #define SUPPORTED_100baseT_Full     (1 << 3)
348 #define SUPPORTED_1000baseT_Half    (1 << 4)
349 #define SUPPORTED_1000baseT_Full    (1 << 5)
350 #define SUPPORTED_Autoneg       (1 << 6)
351 #define SUPPORTED_TP            (1 << 7)
352 #define SUPPORTED_AUI           (1 << 8)
353 #define SUPPORTED_MII           (1 << 9)
354 #define SUPPORTED_FIBRE         (1 << 10)
355 #define SUPPORTED_BNC           (1 << 11)
356 #define SUPPORTED_10000baseT_Full   (1 << 12)
357 #define SUPPORTED_Pause         (1 << 13)
358 #define SUPPORTED_Asym_Pause        (1 << 14)
359 #define SUPPORTED_2500baseX_Full    (1 << 15)
360 #define SUPPORTED_Backplane     (1 << 16)
361 #define SUPPORTED_1000baseKX_Full   (1 << 17)
362 #define SUPPORTED_10000baseKX4_Full (1 << 18)
363 #define SUPPORTED_10000baseKR_Full  (1 << 19)
364 #define SUPPORTED_10000baseR_FEC    (1 << 20)
365 #define SUPPORTED_20000baseMLD2_Full    (1 << 21)
366 #define SUPPORTED_20000baseKR2_Full (1 << 22)
367 #define SUPPORTED_40000baseKR4_Full (1 << 23)
368 #define SUPPORTED_40000baseCR4_Full (1 << 24)
369 #define SUPPORTED_40000baseSR4_Full (1 << 25)
370 #define SUPPORTED_40000baseLR4_Full (1 << 26)
371 #define SUPPORTED_56000baseKR4_Full (1 << 27)
372 #define SUPPORTED_56000baseCR4_Full (1 << 28)
373 #define SUPPORTED_56000baseSR4_Full (1 << 29)
374 #define SUPPORTED_56000baseLR4_Full (1 << 30)
375
376 #define ADVERTISED_10baseT_Half     (1 << 0)
377 #define ADVERTISED_10baseT_Full     (1 << 1)
378 #define ADVERTISED_100baseT_Half    (1 << 2)
379 #define ADVERTISED_100baseT_Full    (1 << 3)
380 #define ADVERTISED_1000baseT_Half   (1 << 4)
381 #define ADVERTISED_1000baseT_Full   (1 << 5)
382 #define ADVERTISED_Autoneg      (1 << 6)
383 #define ADVERTISED_TP           (1 << 7)
384 #define ADVERTISED_AUI          (1 << 8)
385 #define ADVERTISED_MII          (1 << 9)
386 #define ADVERTISED_FIBRE        (1 << 10)
387 #define ADVERTISED_BNC          (1 << 11)
388 #define ADVERTISED_10000baseT_Full  (1 << 12)
389 #define ADVERTISED_Pause        (1 << 13)
390 #define ADVERTISED_Asym_Pause       (1 << 14)
391 #define ADVERTISED_2500baseX_Full   (1 << 15)
392 #define ADVERTISED_Backplane        (1 << 16)
393 #define ADVERTISED_1000baseKX_Full  (1 << 17)
394 #define ADVERTISED_10000baseKX4_Full    (1 << 18)
395 #define ADVERTISED_10000baseKR_Full (1 << 19)
396 #define ADVERTISED_10000baseR_FEC   (1 << 20)
397 #define ADVERTISED_20000baseMLD2_Full   (1 << 21)
398 #define ADVERTISED_20000baseKR2_Full    (1 << 22)
399 #define ADVERTISED_40000baseKR4_Full    (1 << 23)
400 #define ADVERTISED_40000baseCR4_Full    (1 << 24)
401 #define ADVERTISED_40000baseSR4_Full    (1 << 25)
402 #define ADVERTISED_40000baseLR4_Full    (1 << 26)
403 #define ADVERTISED_56000baseKR4_Full    (1 << 27)
404 #define ADVERTISED_56000baseCR4_Full    (1 << 28)
405 #define ADVERTISED_56000baseSR4_Full    (1 << 29)
406 #define ADVERTISED_56000baseLR4_Full    (1 << 30)
407
408 /* Wake-On-Lan options. */
409 #define WAKE_PHY        (1 << 0)
410 #define WAKE_UCAST      (1 << 1)
411 #define WAKE_MCAST      (1 << 2)
412 #define WAKE_BCAST      (1 << 3)
413 #define WAKE_ARP        (1 << 4)
414 #define WAKE_MAGIC      (1 << 5)
415 #define WAKE_MAGICSECURE    (1 << 6) /* only meaningful if WAKE_MAGIC */
416
417 /* Enable or disable autonegotiation. */
418 #define AUTONEG_DISABLE     0x00
419 #define AUTONEG_ENABLE      0x01
420
421 enum ethtool_test_flags {
422         ETH_TEST_FL_OFFLINE = (1 << 0),
423         ETH_TEST_FL_FAILED  = (1 << 1),
424         ETH_TEST_FL_EXTERNAL_LB = (1 << 2),
425         ETH_TEST_FL_EXTERNAL_LB_DONE    = (1 << 3),
426 };
427
428 enum ethtool_stringset {
429         ETH_SS_TEST     = 0,
430         ETH_SS_STATS,
431         ETH_SS_PRIV_FLAGS,
432         ETH_SS_NTUPLE_FILTERS,
433         ETH_SS_FEATURES,
434         ETH_SS_RSS_HASH_FUNCS,
435 };
436
437 enum {
438         ETH_RSS_HASH_TOP_BIT, /* Configurable RSS hash function - Toeplitz */
439         ETH_RSS_HASH_XOR_BIT, /* Configurable RSS hash function - Xor */
440
441         ETH_RSS_HASH_FUNCS_COUNT
442 };
443
444 #define __ETH_RSS_HASH_BIT(bit) ((uint32_t)1 << (bit))
445 #define __ETH_RSS_HASH(name)    __ETH_RSS_HASH_BIT(ETH_RSS_HASH_##name##_BIT)
446
447 #define ETH_RSS_HASH_TOP    __ETH_RSS_HASH(TOP)
448 #define ETH_RSS_HASH_XOR    __ETH_RSS_HASH(XOR)
449
450 #define ETH_RSS_HASH_UNKNOWN    0
451 #define ETH_RSS_HASH_NO_CHANGE  0
452
453
454 /* EEPROM Standards for plug in modules */
455 #define ETH_MODULE_SFF_8079     0x1
456 #define ETH_MODULE_SFF_8079_LEN     256
457 #define ETH_MODULE_SFF_8472     0x2
458 #define ETH_MODULE_SFF_8472_LEN     512
459 #define ETH_MODULE_SFF_8636     0x3
460 #define ETH_MODULE_SFF_8636_LEN     256
461 #define ETH_MODULE_SFF_8436     0x4
462 #define ETH_MODULE_SFF_8436_LEN     256
463
464 #define ETH_GSTRING_LEN     32
465
466 /* ethernet protocol ids.  the plan 9 equivalent enum only exists in
467  * ethermedium.c. */
468 #define ETH_P_IP    0x0800      /* Internet Protocol packet */
469 #define ETH_P_IPV6  0x86DD      /* IPv6 over bluebook       */
470 #define ETH_P_ARP   0x0806      /* Address Resolution packet    */
471 #define ETH_P_FIP   0x8914      /* FCoE Initialization Protocol */
472 #define ETH_P_8021Q 0x8100          /* 802.1Q VLAN Extended Header  */
473
474 /* Sockaddr structs */
475 struct sockaddr {
476         uint16_t                                sa_family;
477         char                                    sa_data[14];
478 };
479
480 struct in_addr {
481         uint32_t                s_addr;
482 };
483 struct sockaddr_in {
484         uint16_t                                sin_family;
485         uint16_t                                sin_port;
486         struct in_addr                  sin_addr;
487         uint8_t                                 sin_zero[8]; /* padding */
488 };
489
490 struct in6_addr {
491         /* this is actually a weird union in glibc */
492         uint8_t                                 s6_addr[16];
493 };
494
495 struct sockaddr_in6 {
496         uint16_t                                sin6_family;
497         uint16_t                                sin6_port;
498         uint32_t                                sin6_flowinfo;
499         struct in6_addr                 sin6_addr;
500         uint32_t                                sin6_scope_id;
501 };
502
503 /* Common way to go from netdev (ether / netif) to driver-private ctlr */
504 static inline void *netdev_priv(struct ether *dev)
505 {
506         return dev->ctlr;
507 }
508
509 /* We do our linker table magic and other nonsense.  Keeping these around to
510  * show the code's intent. */
511 static int register_netdev(struct ether *dev)
512 {
513         return 0;
514 }
515
516 static void unregister_netdev(struct ether *dev)
517 {
518 }
519
520 static void free_netdev(struct ether *dev)
521 {
522 }
523
524 /* u64 on linux, but a u32 on plan 9.  the typedef is probably a good idea */
525 typedef unsigned int netdev_features_t;
526
527 /* Linux has features, hw_features, and a couple others.  Plan 9 just has
528  * features.  This #define should work for merging hw and regular features.  We
529  * spatched away the hw_enc and vlan feats. */
530 #define hw_features feat
531
532 /* Attempted conversions for plan 9 features.  For some things, like rx
533  * checksums, the driver flags the block (e.g. Budpck) to say if a receive
534  * checksum was already done.  There is no flag for saying the device can do
535  * it.  For transmits, the stack needs to know in advance if the device can
536  * handle the checksum or not. */
537 #define NETIF_F_RXHASH                          0
538 #define NETIF_F_RXCSUM                          NETF_RXCSUM
539 #define NETIF_F_LRO                                     NETF_LRO
540 #define NETIF_F_GRO                                     0
541 #define NETIF_F_LOOPBACK                        0
542 #define NETIF_F_TSO                                     NETF_TSO
543 #define NETIF_F_SG                                      NETF_SG
544 #define NETIF_F_IP_CSUM                         (NETF_IPCK | NETF_UDPCK | NETF_TCPCK)
545 #define NETIF_F_IPV6_CSUM                       (NETF_IPCK | NETF_UDPCK | NETF_TCPCK)
546 #define NETIF_F_GSO_GRE                         0
547 #define NETIF_F_GSO_UDP_TUNNEL          0
548 #define NETIF_F_GSO_IPIP                        0
549 #define NETIF_F_GSO_SIT                         0
550 #define NETIF_F_TSO_ECN                         0
551 #define NETIF_F_TSO6                            0
552 #define NETIF_F_HW_VLAN_CTAG_TX         0
553 #define NETIF_F_HIGHDMA                         0
554 #define NETIF_F_HW_VLAN_CTAG_RX         0
555 #define NETIF_F_TSO_MANGLEID            0
556 #define NETIF_F_ALL_TSO (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN | NETIF_F_TSO_MANGLEID)
557
558 #define netif_msg_drv(p)                ((p)->msg_enable & NETIF_MSG_DRV)
559 #define netif_msg_probe(p)              ((p)->msg_enable & NETIF_MSG_PROBE)
560 #define netif_msg_link(p)               ((p)->msg_enable & NETIF_MSG_LINK)
561 #define netif_msg_timer(p)              ((p)->msg_enable & NETIF_MSG_TIMER)
562 #define netif_msg_ifdown(p)             ((p)->msg_enable & NETIF_MSG_IFDOWN)
563 #define netif_msg_ifup(p)               ((p)->msg_enable & NETIF_MSG_IFUP)
564 #define netif_msg_rx_err(p)             ((p)->msg_enable & NETIF_MSG_RX_ERR)
565 #define netif_msg_tx_err(p)             ((p)->msg_enable & NETIF_MSG_TX_ERR)
566 #define netif_msg_tx_queued(p)  ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
567 #define netif_msg_intr(p)               ((p)->msg_enable & NETIF_MSG_INTR)
568 #define netif_msg_tx_done(p)    ((p)->msg_enable & NETIF_MSG_TX_DONE)
569 #define netif_msg_rx_status(p)  ((p)->msg_enable & NETIF_MSG_RX_STATUS)
570 #define netif_msg_pktdata(p)    ((p)->msg_enable & NETIF_MSG_PKTDATA)
571 #define netif_msg_hw(p)                 ((p)->msg_enable & NETIF_MSG_HW)
572 #define netif_msg_wol(p)                ((p)->msg_enable & NETIF_MSG_WOL)
573
574 static inline uint32_t netif_msg_init(int debug_value,
575                                       int default_msg_enable_bits)
576 {
577         /* use default */
578         if (debug_value < 0 || debug_value >= (sizeof(uint32_t) * 8))
579                 return default_msg_enable_bits;
580         if (debug_value == 0)   /* no output */
581                 return 0;
582         /* set low N bits */
583         return (1 << debug_value) - 1;
584 }
585
586 enum netdev_state_t {
587         __LINK_STATE_START,
588         __LINK_STATE_PRESENT,
589         __LINK_STATE_NOCARRIER,
590         __LINK_STATE_LINKWATCH_PENDING,
591         __LINK_STATE_DORMANT,
592 };
593
594 enum netdev_tx {
595         __NETDEV_TX_MIN  = INT32_MIN,   /* make sure enum is signed */
596         NETDEV_TX_OK     = 0x00,                /* driver took care of packet */
597         NETDEV_TX_BUSY   = 0x10,                /* driver tx path was busy*/
598         NETDEV_TX_LOCKED = 0x20,                /* driver tx lock was already taken */
599 };
600 typedef enum netdev_tx netdev_tx_t;
601
602 /* Global mutex in linux for "routing netlink".  Not sure if we have an
603  * equivalent or not in Plan 9. */
604 #define rtnl_lock()
605 #define rtnl_unlock()
606 #define ASSERT_RTNL(...)
607
608 #define synchronize_irq(x) warn_once("Asked to sync IRQ %d, unsupported", x)
609 #define HZ 100
610
611 /* Linux has a PCI device id struct.  Drivers make tables of their supported
612  * devices, and this table is handled by higher level systems.  We don't have
613  * those systems, but we probably want the table still for our own parsing. */
614 struct pci_device_id {
615         uint32_t vendor, device;                /* Vendor and device ID or PCI_ANY_ID*/
616         uint32_t subvendor, subdevice;  /* Subsystem ID's or PCI_ANY_ID */
617         uint32_t class, class_mask;             /* (class,subclass,prog-if) triplet */
618         unsigned long driver_data;              /* Data private to the driver */
619 };
620
621 static const struct pci_device_id *
622 srch_linux_pci_tbl(const struct pci_device_id *tbl, struct pci_device *needle)
623 {
624         const struct pci_device_id *i;
625
626         for (i = tbl; i->vendor; i++) {
627                 if ((needle->ven_id == i->vendor) && (needle->dev_id == i->device))
628                         break;
629         }
630         if (i->vendor)
631                 return i;
632         return 0;
633 }
634
635 #define PCI_ANY_ID (~0)
636 /* This macro is used in setting device_id entries */
637 #define PCI_VDEVICE(vend, dev) \
638     .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
639     .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
640
641 #define PCI_DEVICE(vend, dev) \
642     .vendor = (vend), .device = (dev), \
643     .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
644
645 /* Linux also has its own table of vendor ids.  We have the pci_defs table, but
646  * this is a bootstrap issue. */
647 #define PCI_VENDOR_ID_BROADCOM      0x14e4
648 #define PCI_VENDOR_ID_REALTEK       0x10ec
649 #define PCI_VENDOR_ID_DLINK         0x1186
650 #define PCI_VENDOR_ID_AT            0x1259
651 #define PCI_VENDOR_ID_LINKSYS       0x1737
652 #define PCI_VENDOR_ID_GIGABYTE      0x1458
653
654 /* I'd like to spatch all of the pci methods, but I don't know how to do the
655  * reads.  Since we're not doing the reads, then no sense doing the writes. */
656 static inline int pci_read_config_byte(struct pci_device *dev, uint32_t off,
657                                        uint8_t *val)
658 {
659         *val = pcidev_read8(dev, off);
660         return 0;
661 }
662
663 static inline int pci_read_config_word(struct pci_device *dev, uint32_t off,
664                                        uint16_t *val)
665 {
666         *val = pcidev_read16(dev, off);
667         return 0;
668 }
669
670 static inline int pci_read_config_dword(struct pci_device *dev, uint32_t off,
671                                         uint32_t *val)
672 {
673         *val = pcidev_read32(dev, off);
674         return 0;
675 }
676
677 static inline int pci_write_config_byte(struct pci_device *dev, uint32_t off,
678                                         uint8_t val)
679 {
680         pcidev_write8(dev, off, val);
681         return 0;
682 }
683
684 static inline int pci_write_config_word(struct pci_device *dev, uint32_t off,
685                                         uint16_t val)
686 {
687         pcidev_write16(dev, off, val);
688         return 0;
689 }
690
691 static inline int pci_write_config_dword(struct pci_device *dev, uint32_t off,
692                                          uint32_t val)
693 {
694         pcidev_write32(dev, off, val);
695         return 0;
696 }
697
698 static inline void pci_disable_device(struct pci_device *dev)
699 {
700         pci_clr_bus_master(dev);
701 }
702
703 static inline int pci_enable_device(struct pci_device *dev)
704 {
705         pci_set_bus_master(dev);
706         return 0;
707 }
708
709 static inline uint32_t pci_resource_len(struct pci_device *dev, int bir)
710 {
711         return pci_get_membar_sz(dev, bir);
712 }
713
714 static inline void *pci_resource_start(struct pci_device *dev, int bir)
715 {
716         return (void*)pci_get_membar(dev, bir);
717 }
718
719 static inline void *pci_resource_end(struct pci_device *dev, int bir)
720 {
721         return (void*)(pci_get_membar(dev, bir) + pci_resource_len(dev, bir));
722 }
723
724 #define IORESOURCE_TYPE_BITS    0x00001f00  /* Resource type */
725 #define IORESOURCE_IO       0x00000100  /* PCI/ISA I/O ports */
726 #define IORESOURCE_MEM      0x00000200
727
728 static inline int pci_resource_flags(struct pci_device *pdev, int bir)
729 {
730         return pci_get_membar(pdev, bir) ? IORESOURCE_MEM : IORESOURCE_IO;
731 }
732
733 /* Linux stores this in the device to avoid lookups, which we can consider. */
734 static bool pci_is_pcie(struct pci_device *dev)
735 {
736         return pci_find_cap(dev, PCI_CAP_ID_EXP, NULL) == 0 ? TRUE : FALSE;
737 }
738
739 /* Hacked up version of Linux's.  Assuming reg's are implemented and
740  * read_config never fails. */
741 static int pcie_capability_read_word(struct pci_device *dev, int pos,
742                                      uint16_t *val)
743 {
744         uint32_t pcie_cap;
745
746         *val = 0;
747         if (pos & 1)
748                 return -EINVAL;
749         if (pci_find_cap(dev, PCI_CAP_ID_EXP, &pcie_cap))
750                 return -EINVAL;
751         pci_read_config_word(dev, pcie_cap + pos, val);
752         return 0;
753 }
754
755 static int pcie_capability_write_word(struct pci_device *dev, int pos,
756                                       uint16_t val)
757 {
758         uint32_t pcie_cap;
759
760         if (pos & 3)
761                 return -EINVAL;
762         if (pci_find_cap(dev, PCI_CAP_ID_EXP, &pcie_cap))
763                 return -EINVAL;
764         pci_write_config_word(dev, pcie_cap + pos, val);
765         return 0;
766 }
767
768 static int pcie_capability_clear_and_set_word(struct pci_device *dev, int pos,
769                                               uint16_t clear, uint16_t set)
770 {
771         int ret;
772         uint16_t val;
773
774         ret = pcie_capability_read_word(dev, pos, &val);
775         if (ret)
776                 return ret;
777         val &= ~clear;
778         val |= set;
779         return pcie_capability_write_word(dev, pos, val);
780 }
781
782 static int pcie_capability_clear_word(struct pci_device *dev, int pos,
783                                       uint16_t clear)
784 {
785         return pcie_capability_clear_and_set_word(dev, pos, clear, 0);
786 }
787
788 static int pcie_capability_set_word(struct pci_device *dev, int pos,
789                                     uint16_t set)
790 {
791         return pcie_capability_clear_and_set_word(dev, pos, 0, set);
792 }
793
794 /* Faking it */
795 static int pci_request_regions(struct pci_device *pdev, const char *res_name)
796 {
797         return 0;
798 }
799
800 static void pci_release_regions(struct pci_device *pdev)
801 {
802 }
803
804 static bool pci_dev_run_wake(struct pci_device *dev)
805 {
806         return FALSE;
807 }
808
809 #define ioremap_nocache(paddr, sz) \
810         (void*)vmap_pmem_nocache((uintptr_t)paddr, sz)
811 #define ioremap(paddr, sz) (void*)vmap_pmem((uintptr_t)paddr, sz)
812 #define pci_ioremap_bar(dev, bir) (void*)pci_map_membar(dev, bir)
813 #define pci_disable_link_state(...)
814
815 #define dev_addr_add(dev, addr, type) ({memcpy((dev)->ea, addr, Eaddrlen); 0;})
816 #define dev_addr_del(...)
817
818 /* Some of these might be important.  Mostly we need to rewrite whatever is
819  * using them, but we can leave the functions around to remind us what the code
820  * is supposed to do, especially for things we don't support yet. */
821 #define SET_NETDEV_DEV(...)
822 #define netif_carrier_off(...)
823 #define netif_carrier_on(...)
824 /* May need to do something with edev's queues or flags. */
825 #define netif_tx_wake_all_queues(...)
826 #define netif_tx_wake_queue(...)
827 #define netif_tx_start_all_queues(...)
828 #define netif_tx_start_queue(...)
829 #define netif_tx_stop_queue(...)
830 #define netif_start_queue(...)
831 #define netif_stop_queue(...)
832 #define netif_wake_queue(...)
833 #define netif_device_detach(...)
834 #define netif_queue_stopped(...) (FALSE)
835 #define netif_napi_add(...)
836 #define netif_napi_del(...)
837 #define napi_hash_add(...)
838 #define napi_enable(...)
839 #define napi_disable(...)
840 #define napi_schedule(...)
841 #define napi_schedule_irqoff(...)
842 #define napi_complete(...)
843 #define free_irq(...)   /* We don't free yet! */
844 /* picks a random, valid mac addr for dev */
845 #define eth_hw_addr_random(...)
846 /* checks if the MAC is not 0 and not multicast (all 1s) */
847 #define is_valid_ether_addr(...) (TRUE)
848 /* The flag this checks is set on before open.  Turned off on failure, etc. */
849 #define netif_running(dev) (TRUE)
850 #define netdev_tx_sent_queue(...)
851 #define netdev_update_features(...)
852 #define skb_tx_timestamp(...)
853 #define net_ratelimit() (TRUE)
854
855 #define NET_SKB_PAD 0           /* padding for SKBs.  Ignoring it for now */
856 #define MAX_SKB_FRAGS 16        /* we'll probably delete code using this */
857 #define VLAN_VID_MASK 0x0fff /* VLAN Identifier */
858
859 /* Could spatch this:
860         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
861         to:
862         if (!pci_get_membar(pdev, 0)) {
863
864         eth_zero_addr(bp->dev->ea);
865         to:
866         memset(bp->dev->ea, 0, Eaddrlen);
867 */
868
869 struct firmware {
870         const uint8_t *data;
871         size_t size;
872 };
873
874 static inline int request_firmware(const struct firmware **fwp,
875                                    const char *file_name,
876                                                                    struct device *ignored)
877 {
878         struct firmware *ret_fw;
879         struct file *fw_file;
880         void *fw_data;
881         char dirname[] = "/lib/firmware/";
882         /* could dynamically allocate the min of this and some MAX */
883         char fullpath[sizeof(dirname) + strlen(file_name) + 1];
884
885         snprintf(fullpath, sizeof(fullpath), "%s%s", dirname, file_name);
886         fw_file = do_file_open(fullpath, O_READ, 0);
887         if (!fw_file) {
888                 printk("Unable to find firmware file %s!\n", fullpath);
889                 return -1;
890         }
891         fw_data = kread_whole_file(fw_file);
892         if (!fw_data) {
893                 printk("Unable to load firmware file %s!\n", fullpath);
894                 kref_put(&fw_file->f_kref);
895                 return -1;
896         }
897         ret_fw = kmalloc(sizeof(struct firmware), MEM_WAIT);
898         ret_fw->data = fw_data;
899         ret_fw->size = fw_file->f_dentry->d_inode->i_size;
900         *fwp = ret_fw;
901         kref_put(&fw_file->f_kref);
902         return 0;
903 }
904
905 static inline void release_firmware(const struct firmware *fw)
906 {
907         if (fw) {
908                 kfree((void*)fw->data);
909                 kfree((void*)fw);
910         }
911 }
912
913 static inline uint32_t ethtool_rxfh_indir_default(uint32_t index,
914                                                   uint32_t n_rx_rings)
915 {
916         return index % n_rx_rings;
917 }
918
919 /* Plan 9 does a memcmp for this.  We should probably have a helper, like for
920  * IP addrs. */
921 static inline bool ether_addr_equal(const uint8_t *addr1, const uint8_t *addr2)
922 {
923 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
924         uint32_t fold = ((*(const uint32_t *)addr1) ^ (*(const uint32_t *)addr2)) |
925         ((*(const uint16_t *)(addr1 + 4)) ^ (*(const uint16_t *)(addr2 + 4)));
926
927         return fold == 0;
928 #else
929         const uint16_t *a = (const uint16_t *)addr1;
930         const uint16_t *b = (const uint16_t *)addr2;
931
932         return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) == 0;
933 #endif
934 }
935
936 /* Linux uses this interface for 64 bit stats on 32 bit machines.  We're 64 bit
937  * only, so we can ignore the 32 bit versions. */
938 struct u64_stats_sync {
939 };
940
941 static inline void u64_stats_init(struct u64_stats_sync *syncp)
942 {
943 }
944
945 static inline void u64_stats_update_begin(struct u64_stats_sync *syncp)
946 {
947 }
948
949 static inline void u64_stats_update_end(struct u64_stats_sync *syncp)
950 {
951 }
952
953 static inline void u64_stats_update_begin_raw(struct u64_stats_sync *syncp)
954 {
955 }
956
957 static inline void u64_stats_update_end_raw(struct u64_stats_sync *syncp)
958 {
959 }
960
961 static inline unsigned int
962 __u64_stats_fetch_begin(const struct u64_stats_sync *syncp)
963 {
964         return 0;
965 }
966
967 static inline unsigned int
968 u64_stats_fetch_begin(const struct u64_stats_sync *syncp)
969 {
970         return __u64_stats_fetch_begin(syncp);
971 }
972
973 static inline bool __u64_stats_fetch_retry(const struct u64_stats_sync *syncp,
974                                            unsigned int start)
975 {
976         return false;
977 }
978
979 static inline bool u64_stats_fetch_retry(const struct u64_stats_sync *syncp,
980                                          unsigned int start)
981 {
982         return __u64_stats_fetch_retry(syncp, start);
983 }
984
985 static inline unsigned int
986 u64_stats_fetch_begin_irq(const struct u64_stats_sync *syncp)
987 {
988         return __u64_stats_fetch_begin(syncp);
989 }
990
991 static inline bool u64_stats_fetch_retry_irq(const struct u64_stats_sync *syncp,
992                                              unsigned int start)
993 {
994         return __u64_stats_fetch_retry(syncp, start);
995 }
996
997 #define pm_request_resume(...) (1)
998 #define pm_schedule_suspend(...) (-ENOSYS)
999 #define pm_runtime_get_noresume(...)
1000 #define pm_runtime_active(...) (true)
1001 #define pm_runtime_put_noidle(...)
1002 #define pm_runtime_get_sync(...) (1)
1003 #define pm_runtime_put_sync(...) (-ENOSYS)
1004 #define device_set_wakeup_enable(...) (-EINVAL)
1005
1006 #include <linux/compat_todo.h>