Add checkpatch.pl
[akaros.git] / kern / include / linux_compat.h
1 /* Copyright (c) 2015 Google Inc.
2  *
3  * Dumping ground for converting between Akaros and Linux. */
4
5 #ifndef ROS_KERN_LINUX_COMPAT_H
6 #define ROS_KERN_LINUX_COMPAT_H
7
8 /* Common headers that most driver files will need */
9
10 #include <ros/common.h>
11 #include <assert.h>
12 #include <error.h>
13 #include <ip.h>
14 #include <kmalloc.h>
15 #include <kref.h>
16 #include <pmap.h>
17 #include <slab.h>
18 #include <smp.h>
19 #include <stdio.h>
20 #include <string.h>
21 #include <bitmap.h>
22 #include <umem.h>
23 #include <mmio.h>
24 #include <taskqueue.h>
25 #include <zlib.h>
26 #include <list.h>
27 #include <linux/errno.h>
28 /* temporary dumping ground */
29 #include "compat_todo.h"
30
31 //#define CONFIG_DCB
32 //#define CONFIG_NET_RX_BUSY_POLL 1
33 //#define CONFIG_NET_POLL_CONTROLLER 1
34 //#define CONFIG_INET 1         // will deal with this manually
35 #define CONFIG_PCI_MSI 1
36
37 #define __rcu
38 #define rcu_read_lock()
39 #define rcu_read_unlock()
40 #define rcu_dereference(x) (x)
41 #define rcu_dereference_protected(x, y) (x)
42 #define rcu_assign_pointer(dst, src) (dst) = (src)
43 #define RCU_INIT_POINTER(dst, src) rcu_assign_pointer(dst, src)
44 #define synchronize_rcu()
45
46 #define atomic_cmpxchg(_addr, _old, _new)                                      \
47 ({                                                                             \
48         typeof(_old) _ret;                                                         \
49         if (atomic_cas((_addr), (_old), (_new)))                                   \
50                 _ret = _old;                                                           \
51         else                                                                       \
52                 _ret = atomic_read(_addr);                                             \
53         _ret;                                                                      \
54 })
55
56 #define UINT_MAX UINT64_MAX
57 #define L1_CACHE_SHIFT (LOG2_UP(ARCH_CL_SIZE))
58 #define __stringify(x...) STRINGIFY(x)
59
60 /* Wanted to keep the _t variants in the code, in case that's useful in the
61  * future */
62 #define MIN_T(t, a, b) MIN(a, b)
63 #define MAX_T(t, a, b) MAX(a, b)
64 #define CLAMP(val, lo, hi) MIN((typeof(val))MAX(val, lo), hi)
65 #define CLAMP_T(t, val, lo, hi) CLAMP(val, lo, hi)
66
67 typedef physaddr_t dma_addr_t;
68 typedef int gfp_t;
69
70 /* these dma funcs are empty in linux with !CONFIG_NEED_DMA_MAP_STATE */
71 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)
72 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)
73 #define dma_unmap_addr(PTR, ADDR_NAME)           (0)
74 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  do { } while (0)
75 #define dma_unmap_len(PTR, LEN_NAME)             (0)
76 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    do { } while (0)
77
78 enum dma_data_direction {
79         DMA_BIDIRECTIONAL = 0,
80         DMA_TO_DEVICE = 1,
81         DMA_FROM_DEVICE = 2,
82         DMA_NONE = 3,
83 };
84
85 static inline void *__dma_alloc_coherent(size_t size, dma_addr_t *dma_handle,
86                                          gfp_t flags)
87 {
88         size_t order = LOG2_UP(nr_pages(size));
89         /* our shitty allocator doesn't align the higher order allocations, so we
90          * go 2x, and align manually.  we don't save the original pointer, so we
91          * can't free them later. */
92         void *vaddr = get_cont_pages(order > 0 ?  order + 1 : order,
93                                      flags);
94         if (!vaddr) {
95                 *dma_handle = 0;
96                 return 0;
97         }
98         /* manual alignment.  order 0 allocs are already page aligned */
99         vaddr = ALIGN(vaddr, PGSIZE << order);
100         *dma_handle = PADDR(vaddr);
101         return vaddr;
102 }
103
104 static inline void *__dma_zalloc_coherent(size_t size, dma_addr_t *dma_handle,
105                                           gfp_t flags)
106 {
107         void *vaddr = __dma_alloc_coherent(size, dma_handle, flags);
108         if (vaddr)
109                 memset(vaddr, 0, size);
110         return vaddr;
111 }
112
113 static inline void __dma_free_coherent(size_t size, void *cpu_addr,
114                                        dma_addr_t dma_handle)
115 {
116         size_t order = LOG2_UP(nr_pages(size));
117         if (order > 0) {
118                 warn("Not freeing high order alloc!  Fix the allocator!");
119                 return;
120         }
121         free_cont_pages(cpu_addr, order);
122 }
123
124 static inline dma_addr_t __dma_map_single(void *cpu_addr, size_t size,
125                                           int direction)
126 {
127         return PADDR(cpu_addr);
128 }
129
130 static inline dma_addr_t __dma_map_page(struct page *page,
131                                         unsigned long offset, size_t size,
132                                         int direction)
133 {
134         assert(offset == 0);
135         return page2pa(page);
136 }
137
138 static inline int __dma_mapping_error(dma_addr_t dma_addr)
139 {
140         return (dma_addr == 0);
141 }
142
143 #define dma_unmap_single(...)
144 #define dma_unmap_page(...)
145 #define dma_set_mask_and_coherent(...) (0)
146 #define dma_sync_single_for_cpu(...)
147 #define dma_sync_single_for_device(...)
148
149 /* Wrappers to avoid struct device.  Might want that one of these days */
150 #define dma_alloc_coherent(dev, size, dma_handlep, flag)                       \
151         __dma_alloc_coherent(size, dma_handlep, flag)
152
153 #define dma_zalloc_coherent(dev, size, dma_handlep, flag)                      \
154         __dma_zalloc_coherent(size, dma_handlep, flag)
155
156 #define dma_free_coherent(dev, size, dma_handle, flag)                         \
157         __dma_free_coherent(size, dma_handle, flag)
158
159 #define dma_map_single(dev, addr, size, direction)                             \
160         __dma_map_single(addr, size, direction)
161
162 #define dma_map_page(dev, page, offset, size, direction)                       \
163         __dma_map_page(page, offset, size, direction)
164
165 #define dma_mapping_error(dev, handle)                                         \
166         __dma_mapping_error(handle)
167
168 static void *vmalloc(size_t size)
169 {
170         void *vaddr = get_cont_pages(LOG2_UP(nr_pages(size)), KMALLOC_WAIT);
171         /* zalloc, to be safe */
172         if (vaddr)
173                 memset(vaddr, 0, size);
174         return vaddr;
175 }
176
177 /* Akaros needs to know the size, for now.  So it's not quite compatible */
178 static void vfree(void *vaddr, size_t size)
179 {
180         free_cont_pages(vaddr, LOG2_UP(nr_pages(size)));
181 }
182
183 typedef int pci_power_t;
184 typedef int pm_message_t;
185
186 #define DEFINE_SEMAPHORE(name)  \
187     struct semaphore name = SEMAPHORE_INITIALIZER_IRQSAVE(name, 1)
188 #define sema_init(sem, val) sem_init_irqsave(sem, val)
189 #define up(sem) sem_up(sem)
190 #define down(sem) sem_down(sem)
191 #define down_trylock(sem) ({!sem_trydown(sem);})
192 /* In lieu of spatching, I wanted to keep the distinction between down and
193  * down_interruptible/down_timeout.  Akaros doesn't have the latter. */
194 #define down_interruptible(sem) ({sem_down(sem); 0;})
195 #define down_timeout(sem, timeout) ({sem_down(sem); 0;})
196
197 #define local_bh_disable() cmb()
198 #define local_bh_enable() cmb()
199
200 /* Linux printk front ends */
201 #ifndef pr_fmt
202 #define pr_fmt(fmt) "bnx2x:" fmt
203 #endif
204
205 #define KERN_EMERG ""
206 #define KERN_ALERT ""
207 #define KERN_CRIT ""
208 #define KERN_ERR ""
209 #define KERN_WARNING ""
210 #define KERN_NOTICE ""
211 #define KERN_INFO ""
212 #define KERN_CONT ""
213 #define KERN_DEBUG ""
214
215 /*
216  * These can be used to print at the various log levels.
217  * All of these will print unconditionally, although note that pr_debug()
218  * and other debug macros are compiled out unless either DEBUG is defined
219  * or CONFIG_DYNAMIC_DEBUG is set.
220  */
221 #define pr_emerg(fmt, ...) \
222         printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
223 #define pr_alert(fmt, ...) \
224         printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
225 #define pr_crit(fmt, ...) \
226         printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
227 #define pr_err(fmt, ...) \
228         printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
229 #define pr_warning(fmt, ...) \
230         printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
231 #define pr_warn pr_warning
232 #define pr_notice(fmt, ...) \
233         printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
234 #define pr_info(fmt, ...) \
235         printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
236 #define pr_cont(fmt, ...) \
237         printk(KERN_CONT pr_fmt(fmt), ##__VA_ARGS__)
238 #define netdev_printk(lvl, dev, fmt, ...) \
239         printk("[netdev]: " fmt, ##__VA_ARGS__)
240 #define netdev_err(dev, fmt, ...) \
241         printk("[netdev]: " fmt, ##__VA_ARGS__)
242 #define netdev_info(dev, fmt, ...) \
243         printk("[netdev]: " fmt, ##__VA_ARGS__)
244 #define netdev_dbg(dev, fmt, ...) \
245         printk("[netdev]: " fmt, ##__VA_ARGS__)
246 #define dev_err(dev, fmt, ...) \
247         printk("[dev]: " fmt, ##__VA_ARGS__)
248 #define dev_info(dev, fmt, ...) \
249         printk("[dev]: " fmt, ##__VA_ARGS__)
250 #define dev_alert(dev, fmt, ...) \
251         printk("[dev]: " fmt, ##__VA_ARGS__)
252
253 #ifdef DEBUG
254
255 #define might_sleep() assert(can_block(&per_cpu_info[core_id()]))
256 #define pr_devel(fmt, ...) \
257         printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
258
259 #else
260
261 #define might_sleep()
262 #define pr_devel(fmt, ...) \
263         printd(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
264
265 #endif
266 #define pr_debug pr_devel
267
268
269 enum {
270         NETIF_MSG_DRV           = 0x0001,
271         NETIF_MSG_PROBE         = 0x0002,
272         NETIF_MSG_LINK          = 0x0004,
273         NETIF_MSG_TIMER         = 0x0008,
274         NETIF_MSG_IFDOWN        = 0x0010,
275         NETIF_MSG_IFUP          = 0x0020,
276         NETIF_MSG_RX_ERR        = 0x0040,
277         NETIF_MSG_TX_ERR        = 0x0080,
278         NETIF_MSG_TX_QUEUED     = 0x0100,
279         NETIF_MSG_INTR          = 0x0200,
280         NETIF_MSG_TX_DONE       = 0x0400,
281         NETIF_MSG_RX_STATUS     = 0x0800,
282         NETIF_MSG_PKTDATA       = 0x1000,
283         NETIF_MSG_HW            = 0x2000,
284         NETIF_MSG_WOL           = 0x4000,
285 };
286
287 #define MODULE_AUTHOR(...)
288 #define MODULE_DESCRIPTION(...)
289 #define MODULE_LICENSE(...)
290 #define MODULE_VERSION(...)
291 #define MODULE_FIRMWARE(...)
292 #define module_param(...)
293 #define module_param_named(...)
294 #define MODULE_PARM_DESC(...)
295 #define MODULE_DEVICE_TABLE(...)
296 #define THIS_MODULE ((void*)0)
297 #define EXPORT_SYMBOL(...)
298 #define __init
299 #define __exit
300 #define module_init(...)
301 #define module_exit(...)
302
303 #define is_kdump_kernel() (0)
304
305 /* from Linux's ethtool.h.  We probably won't use any of this code, but at
306  * least we can keep it quiet during porting. */
307 #define SPEED_10        10
308 #define SPEED_100       100
309 #define SPEED_1000      1000
310 #define SPEED_2500      2500
311 #define SPEED_10000     10000
312 #define SPEED_20000     20000
313 #define SPEED_40000     40000
314 #define SPEED_56000     56000
315 #define SPEED_UNKNOWN   -1
316
317 /* Duplex, half or full. */
318 #define DUPLEX_HALF     0x00
319 #define DUPLEX_FULL     0x01
320 #define DUPLEX_UNKNOWN  0xff
321
322 #define SUPPORTED_10baseT_Half      (1 << 0)
323 #define SUPPORTED_10baseT_Full      (1 << 1)
324 #define SUPPORTED_100baseT_Half     (1 << 2)
325 #define SUPPORTED_100baseT_Full     (1 << 3)
326 #define SUPPORTED_1000baseT_Half    (1 << 4)
327 #define SUPPORTED_1000baseT_Full    (1 << 5)
328 #define SUPPORTED_Autoneg       (1 << 6)
329 #define SUPPORTED_TP            (1 << 7)
330 #define SUPPORTED_AUI           (1 << 8)
331 #define SUPPORTED_MII           (1 << 9)
332 #define SUPPORTED_FIBRE         (1 << 10)
333 #define SUPPORTED_BNC           (1 << 11)
334 #define SUPPORTED_10000baseT_Full   (1 << 12)
335 #define SUPPORTED_Pause         (1 << 13)
336 #define SUPPORTED_Asym_Pause        (1 << 14)
337 #define SUPPORTED_2500baseX_Full    (1 << 15)
338 #define SUPPORTED_Backplane     (1 << 16)
339 #define SUPPORTED_1000baseKX_Full   (1 << 17)
340 #define SUPPORTED_10000baseKX4_Full (1 << 18)
341 #define SUPPORTED_10000baseKR_Full  (1 << 19)
342 #define SUPPORTED_10000baseR_FEC    (1 << 20)
343 #define SUPPORTED_20000baseMLD2_Full    (1 << 21)
344 #define SUPPORTED_20000baseKR2_Full (1 << 22)
345 #define SUPPORTED_40000baseKR4_Full (1 << 23)
346 #define SUPPORTED_40000baseCR4_Full (1 << 24)
347 #define SUPPORTED_40000baseSR4_Full (1 << 25)
348 #define SUPPORTED_40000baseLR4_Full (1 << 26)
349 #define SUPPORTED_56000baseKR4_Full (1 << 27)
350 #define SUPPORTED_56000baseCR4_Full (1 << 28)
351 #define SUPPORTED_56000baseSR4_Full (1 << 29)
352 #define SUPPORTED_56000baseLR4_Full (1 << 30)
353
354 #define ADVERTISED_10baseT_Half     (1 << 0)
355 #define ADVERTISED_10baseT_Full     (1 << 1)
356 #define ADVERTISED_100baseT_Half    (1 << 2)
357 #define ADVERTISED_100baseT_Full    (1 << 3)
358 #define ADVERTISED_1000baseT_Half   (1 << 4)
359 #define ADVERTISED_1000baseT_Full   (1 << 5)
360 #define ADVERTISED_Autoneg      (1 << 6)
361 #define ADVERTISED_TP           (1 << 7)
362 #define ADVERTISED_AUI          (1 << 8)
363 #define ADVERTISED_MII          (1 << 9)
364 #define ADVERTISED_FIBRE        (1 << 10)
365 #define ADVERTISED_BNC          (1 << 11)
366 #define ADVERTISED_10000baseT_Full  (1 << 12)
367 #define ADVERTISED_Pause        (1 << 13)
368 #define ADVERTISED_Asym_Pause       (1 << 14)
369 #define ADVERTISED_2500baseX_Full   (1 << 15)
370 #define ADVERTISED_Backplane        (1 << 16)
371 #define ADVERTISED_1000baseKX_Full  (1 << 17)
372 #define ADVERTISED_10000baseKX4_Full    (1 << 18)
373 #define ADVERTISED_10000baseKR_Full (1 << 19)
374 #define ADVERTISED_10000baseR_FEC   (1 << 20)
375 #define ADVERTISED_20000baseMLD2_Full   (1 << 21)
376 #define ADVERTISED_20000baseKR2_Full    (1 << 22)
377 #define ADVERTISED_40000baseKR4_Full    (1 << 23)
378 #define ADVERTISED_40000baseCR4_Full    (1 << 24)
379 #define ADVERTISED_40000baseSR4_Full    (1 << 25)
380 #define ADVERTISED_40000baseLR4_Full    (1 << 26)
381 #define ADVERTISED_56000baseKR4_Full    (1 << 27)
382 #define ADVERTISED_56000baseCR4_Full    (1 << 28)
383 #define ADVERTISED_56000baseSR4_Full    (1 << 29)
384 #define ADVERTISED_56000baseLR4_Full    (1 << 30)
385
386 enum ethtool_test_flags {
387         ETH_TEST_FL_OFFLINE = (1 << 0),
388         ETH_TEST_FL_FAILED  = (1 << 1),
389         ETH_TEST_FL_EXTERNAL_LB = (1 << 2),
390         ETH_TEST_FL_EXTERNAL_LB_DONE    = (1 << 3),
391 };
392
393 enum ethtool_stringset {
394         ETH_SS_TEST     = 0,
395         ETH_SS_STATS,
396         ETH_SS_PRIV_FLAGS,
397         ETH_SS_NTUPLE_FILTERS,
398         ETH_SS_FEATURES,
399         ETH_SS_RSS_HASH_FUNCS,
400 };
401
402 enum {
403         ETH_RSS_HASH_TOP_BIT, /* Configurable RSS hash function - Toeplitz */
404         ETH_RSS_HASH_XOR_BIT, /* Configurable RSS hash function - Xor */
405
406         ETH_RSS_HASH_FUNCS_COUNT
407 };
408
409 #define __ETH_RSS_HASH_BIT(bit) ((uint32_t)1 << (bit))
410 #define __ETH_RSS_HASH(name)    __ETH_RSS_HASH_BIT(ETH_RSS_HASH_##name##_BIT)
411
412 #define ETH_RSS_HASH_TOP    __ETH_RSS_HASH(TOP)
413 #define ETH_RSS_HASH_XOR    __ETH_RSS_HASH(XOR)
414
415 #define ETH_RSS_HASH_UNKNOWN    0
416 #define ETH_RSS_HASH_NO_CHANGE  0
417
418
419 /* EEPROM Standards for plug in modules */
420 #define ETH_MODULE_SFF_8079     0x1
421 #define ETH_MODULE_SFF_8079_LEN     256
422 #define ETH_MODULE_SFF_8472     0x2
423 #define ETH_MODULE_SFF_8472_LEN     512
424 #define ETH_MODULE_SFF_8636     0x3
425 #define ETH_MODULE_SFF_8636_LEN     256
426 #define ETH_MODULE_SFF_8436     0x4
427 #define ETH_MODULE_SFF_8436_LEN     256
428
429 #define ETH_GSTRING_LEN     32
430
431 /* ethernet protocol ids.  the plan 9 equivalent enum only exists in
432  * ethermedium.c. */
433 #define ETH_P_IP    0x0800      /* Internet Protocol packet */
434 #define ETH_P_IPV6  0x86DD      /* IPv6 over bluebook       */
435 #define ETH_P_ARP   0x0806      /* Address Resolution packet    */
436 #define ETH_P_FIP   0x8914      /* FCoE Initialization Protocol */
437 #define ETH_P_8021Q 0x8100          /* 802.1Q VLAN Extended Header  */
438
439 /* Sockaddr structs */
440 struct sockaddr {
441         uint16_t                                sa_family;
442         char                                    sa_data[14];
443 };
444
445 struct in_addr {
446         uint32_t                s_addr;
447 };
448 struct sockaddr_in {
449         uint16_t                                sin_family;
450         uint16_t                                sin_port;
451         struct in_addr                  sin_addr;
452         uint8_t                                 sin_zero[8]; /* padding */
453 };
454
455 struct in6_addr {
456         /* this is actually a weird union in glibc */
457         uint8_t                                 s6_addr[16];
458 };
459
460 struct sockaddr_in6 {
461         uint16_t                                sin6_family;
462         uint16_t                                sin6_port;
463         uint32_t                                sin6_flowinfo;
464         struct in6_addr                 sin6_addr;
465         uint32_t                                sin6_scope_id;
466 };
467
468 /* Common way to go from netdev (ether / netif) to driver-private ctlr */
469 static inline void *netdev_priv(struct ether *dev)
470 {
471         return dev->ctlr;
472 }
473
474 /* u64 on linux, but a u32 on plan 9.  the typedef is probably a good idea */
475 typedef unsigned int netdev_features_t;
476
477 /* Linux has features, hw_features, and a couple others.  Plan 9 just has
478  * features.  This #define should work for merging hw and regular features.  We
479  * spatched away the hw_enc and vlan feats. */
480 #define hw_features feat
481
482 /* Attempted conversions for plan 9 features.  For some things, like rx
483  * checksums, the driver flags the block (e.g. Budpck) to say if a receive
484  * checksum was already done.  There is no flag for saying the device can do
485  * it.  For transmits, the stack needs to know in advance if the device can
486  * handle the checksum or not. */
487 #define NETIF_F_RXHASH                          0
488 #define NETIF_F_RXCSUM                          0
489 #define NETIF_F_LRO                                     NETF_LRO
490 #define NETIF_F_GRO                                     0
491 #define NETIF_F_LOOPBACK                        0
492 #define NETIF_F_TSO                                     NETF_TSO
493 #define NETIF_F_SG                                      NETF_SG
494 #define NETIF_F_IP_CSUM                         (NETF_IPCK | NETF_UDPCK | NETF_TCPCK)
495 #define NETIF_F_IPV6_CSUM                       (NETF_IPCK | NETF_UDPCK | NETF_TCPCK)
496 #define NETIF_F_GSO_GRE                         0
497 #define NETIF_F_GSO_UDP_TUNNEL          0
498 #define NETIF_F_GSO_IPIP                        0
499 #define NETIF_F_GSO_SIT                         0
500 #define NETIF_F_TSO_ECN                         0
501 #define NETIF_F_TSO6                            0
502 #define NETIF_F_HW_VLAN_CTAG_TX         0
503 #define NETIF_F_HIGHDMA                         0
504 #define NETIF_F_HW_VLAN_CTAG_RX         0
505
506 #define netif_msg_drv(p)                ((p)->msg_enable & NETIF_MSG_DRV)
507 #define netif_msg_probe(p)              ((p)->msg_enable & NETIF_MSG_PROBE)
508 #define netif_msg_link(p)               ((p)->msg_enable & NETIF_MSG_LINK)
509 #define netif_msg_timer(p)              ((p)->msg_enable & NETIF_MSG_TIMER)
510 #define netif_msg_ifdown(p)             ((p)->msg_enable & NETIF_MSG_IFDOWN)
511 #define netif_msg_ifup(p)               ((p)->msg_enable & NETIF_MSG_IFUP)
512 #define netif_msg_rx_err(p)             ((p)->msg_enable & NETIF_MSG_RX_ERR)
513 #define netif_msg_tx_err(p)             ((p)->msg_enable & NETIF_MSG_TX_ERR)
514 #define netif_msg_tx_queued(p)  ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
515 #define netif_msg_intr(p)               ((p)->msg_enable & NETIF_MSG_INTR)
516 #define netif_msg_tx_done(p)    ((p)->msg_enable & NETIF_MSG_TX_DONE)
517 #define netif_msg_rx_status(p)  ((p)->msg_enable & NETIF_MSG_RX_STATUS)
518 #define netif_msg_pktdata(p)    ((p)->msg_enable & NETIF_MSG_PKTDATA)
519 #define netif_msg_hw(p)                 ((p)->msg_enable & NETIF_MSG_HW)
520 #define netif_msg_wol(p)                ((p)->msg_enable & NETIF_MSG_WOL)
521
522 enum netdev_state_t {
523         __LINK_STATE_START,
524         __LINK_STATE_PRESENT,
525         __LINK_STATE_NOCARRIER,
526         __LINK_STATE_LINKWATCH_PENDING,
527         __LINK_STATE_DORMANT,
528 };
529
530 enum netdev_tx {
531         __NETDEV_TX_MIN  = INT32_MIN,   /* make sure enum is signed */
532         NETDEV_TX_OK     = 0x00,                /* driver took care of packet */
533         NETDEV_TX_BUSY   = 0x10,                /* driver tx path was busy*/
534         NETDEV_TX_LOCKED = 0x20,                /* driver tx lock was already taken */
535 };
536 typedef enum netdev_tx netdev_tx_t;
537
538 /* Global mutex in linux for "routing netlink".  Not sure if we have an
539  * equivalent or not in Plan 9. */
540 #define rtnl_lock()
541 #define rtnl_unlock()
542 #define ASSERT_RTNL(...)
543
544 #define synchronize_irq(x) warn_once("Asked to sync IRQ %d, unsupported", x)
545 #define HZ 100
546
547 /* Linux has a PCI device id struct.  Drivers make tables of their supported
548  * devices, and this table is handled by higher level systems.  We don't have
549  * those systems, but we probably want the table still for our own parsing. */
550 struct pci_device_id {
551         uint32_t vendor, device;                /* Vendor and device ID or PCI_ANY_ID*/
552         uint32_t subvendor, subdevice;  /* Subsystem ID's or PCI_ANY_ID */
553         uint32_t class, class_mask;             /* (class,subclass,prog-if) triplet */
554         unsigned long driver_data;              /* Data private to the driver */
555 };
556
557 #define PCI_ANY_ID (~0)
558 /* This macro is used in setting device_id entries */
559 #define PCI_VDEVICE(vend, dev) \
560     .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
561     .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
562
563 /* Linux also has its own table of vendor ids.  We have the pci_defs table, but
564  * this is a bootstrap issue. */
565 #define PCI_VENDOR_ID_BROADCOM      0x14e4
566
567 /* I'd like to spatch all of the pci methods, but I don't know how to do the
568  * reads.  Since we're not doing the reads, then no sense doing the writes. */
569 static inline int pci_read_config_byte(struct pci_device *dev, uint32_t off,
570                                        uint8_t *val)
571 {
572         *val = pcidev_read8(dev, off);
573         return 0;
574 }
575
576 static inline int pci_read_config_word(struct pci_device *dev, uint32_t off,
577                                        uint16_t *val)
578 {
579         *val = pcidev_read16(dev, off);
580         return 0;
581 }
582
583 static inline int pci_read_config_dword(struct pci_device *dev, uint32_t off,
584                                         uint32_t *val)
585 {
586         *val = pcidev_read32(dev, off);
587         return 0;
588 }
589
590 static inline int pci_write_config_byte(struct pci_device *dev, uint32_t off,
591                                         uint8_t val)
592 {
593         pcidev_write8(dev, off, val);
594         return 0;
595 }
596
597 static inline int pci_write_config_word(struct pci_device *dev, uint32_t off,
598                                         uint16_t val)
599 {
600         pcidev_write16(dev, off, val);
601         return 0;
602 }
603
604 static inline int pci_write_config_dword(struct pci_device *dev, uint32_t off,
605                                          uint32_t val)
606 {
607         pcidev_write32(dev, off, val);
608         return 0;
609 }
610
611 static inline void pci_disable_device(struct pci_device *dev)
612 {
613         pci_clr_bus_master(dev);
614 }
615
616 static inline int pci_enable_device(struct pci_device *dev)
617 {
618         pci_set_bus_master(dev);
619         return 0;
620 }
621
622 static inline uint32_t pci_resource_len(struct pci_device *dev, int bir)
623 {
624         return pci_get_membar_sz(dev, bir);
625 }
626
627 static inline void *pci_resource_start(struct pci_device *dev, int bir)
628 {
629         return (void*)pci_get_membar(dev, bir);
630 }
631
632 static inline void *pci_resource_end(struct pci_device *dev, int bir)
633 {
634         return (void*)(pci_get_membar(dev, bir) + pci_resource_len(dev, bir));
635 }
636
637 /* Hacked up version of Linux's.  Assuming reg's are implemented and
638  * read_config never fails. */
639 static int pcie_capability_read_word(struct pci_device *dev, int pos,
640                                      uint16_t *val)
641 {
642         uint32_t pcie_cap;
643         *val = 0;
644         if (pos & 1)
645                 return -EINVAL;
646         if (pci_find_cap(dev, PCI_CAP_ID_EXP, &pcie_cap))
647                 return -EINVAL;
648         pci_read_config_word(dev, pcie_cap + pos, val);
649         return 0;
650 }
651
652 #define ioremap_nocache(paddr, sz) \
653         (void*)vmap_pmem_nocache((uintptr_t)paddr, sz)
654 #define ioremap(paddr, sz) (void*)vmap_pmem((uintptr_t)paddr, sz)
655 #define pci_ioremap_bar(dev, bir) (void*)pci_map_membar(dev, bir)
656 #define pci_set_master(x) pci_set_bus_master(x)
657
658 #define dev_addr_add(dev, addr, type) ({memcpy((dev)->ea, addr, Eaddrlen); 0;})
659 #define dev_addr_del(...)
660
661 #define SET_NETDEV_DEV(...)
662 #define netif_carrier_off(...)
663 #define netif_carrier_on(...)
664 /* May need to do something with edev's queues or flags. */
665 #define netif_tx_wake_all_queues(...)
666 #define netif_tx_wake_queue(...)
667 #define netif_tx_start_all_queues(...)
668 #define netif_tx_start_queue(...)
669 #define netif_tx_stop_queue(...)
670 #define netif_napi_add(...)
671 #define napi_hash_add(...)
672 #define napi_enable(...)
673 #define napi_disable(...)
674 #define napi_schedule(...)
675 #define napi_schedule_irqoff(...)
676 #define napi_complete(...)
677 /* picks a random, valid mac addr for dev */
678 #define eth_hw_addr_random(...)
679 /* checks if the MAC is not 0 and not multicast (all 1s) */
680 #define is_valid_ether_addr(...) (TRUE)
681 /* The flag this checks is set on before open.  Turned off on failure, etc. */
682 #define netif_running(dev) (TRUE)
683 #define netdev_tx_sent_queue(...)
684 #define skb_tx_timestamp(...)
685
686 #define NET_SKB_PAD 0           /* padding for SKBs.  Ignoring it for now */
687 #define MAX_SKB_FRAGS 16        /* we'll probably delete code using this */
688 #define VLAN_VID_MASK 0x0fff /* VLAN Identifier */
689
690 /* Could spatch this:
691         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
692         to:
693         if (!pci_get_membar(pdev, 0)) {
694
695         eth_zero_addr(bp->dev->ea);
696         to:
697         memset(bp->dev->ea, 0, Eaddrlen);
698 */
699
700 struct firmware {
701         const uint8_t *data;
702         size_t size;
703 };
704
705 /* the ignored param is a &pcidev->dev in linux, which is a struct dev.  our
706  * pcidev->dev is the "slot" */
707 static inline int request_firmware(const struct firmware **fwp,
708                                    const char *file_name, uint8_t *ignored)
709 {
710         struct firmware *ret_fw;
711         struct file *fw_file;
712         void *fw_data;
713         char dirname[] = "/lib/firmware/";
714         /* could dynamically allocate the min of this and some MAX */
715         char fullpath[sizeof(dirname) + strlen(file_name) + 1];
716
717         snprintf(fullpath, sizeof(fullpath), "%s%s", dirname, file_name);
718         fw_file = do_file_open(fullpath, O_READ, 0);
719         if (!fw_file) {
720                 printk("Unable to find firmware file %s!\n", fullpath);
721                 return -1;
722         }
723         fw_data = kread_whole_file(fw_file);
724         if (!fw_data) {
725                 printk("Unable to load firmware file %s!\n", fullpath);
726                 kref_put(&fw_file->f_kref);
727                 return -1;
728         }
729         ret_fw = kmalloc(sizeof(struct firmware), KMALLOC_WAIT);
730         ret_fw->data = fw_data;
731         ret_fw->size = fw_file->f_dentry->d_inode->i_size;
732         *fwp = ret_fw;
733         kref_put(&fw_file->f_kref);
734         return 0;
735 }
736
737 static inline void release_firmware(const struct firmware *fw)
738 {
739         if (fw) {
740                 kfree((void*)fw->data);
741                 kfree((void*)fw);
742         }
743 }
744
745 static inline uint32_t ethtool_rxfh_indir_default(uint32_t index,
746                                                   uint32_t n_rx_rings)
747 {
748         return index % n_rx_rings;
749 }
750
751 /* Plan 9 does a memcmp for this.  We should probably have a helper, like for
752  * IP addrs. */
753 static inline bool ether_addr_equal(const uint8_t *addr1, const uint8_t *addr2)
754 {
755 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
756         uint32_t fold = ((*(const uint32_t *)addr1) ^ (*(const uint32_t *)addr2)) |
757         ((*(const uint16_t *)(addr1 + 4)) ^ (*(const uint16_t *)(addr2 + 4)));
758
759         return fold == 0;
760 #else
761         const uint16_t *a = (const uint16_t *)addr1;
762         const uint16_t *b = (const uint16_t *)addr2;
763
764         return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) == 0;
765 #endif
766 }
767
768 #include <linux/compat_todo.h>
769
770 #endif /* ROS_KERN_LINUX_COMPAT_H */