BNX2X: spatch changes for BUG and WARN
[akaros.git] / kern / drivers / net / bnx2x / akaros_compat.h
1 /* Copyright (c) 2015 Google Inc.
2  *
3  * Dumping ground for converting between Akaros and other OSs. */
4
5 #ifndef ROS_KERN_AKAROS_COMPAT_H
6 #define ROS_KERN_AKAROS_COMPAT_H
7
8 /* Common headers that most driver files will need */
9
10 #include <assert.h>
11 #include <error.h>
12 #include <ip.h>
13 #include <kmalloc.h>
14 #include <kref.h>
15 #include <pmap.h>
16 #include <slab.h>
17 #include <smp.h>
18 #include <stdio.h>
19 #include <string.h>
20 #include <bitmap.h>
21 #include <mii.h>
22 #include <umem.h>
23 #include <mmio.h>
24 #include <taskqueue.h>
25
26 /* temporary dumping ground */
27 #include "compat_todo.h"
28
29 #define __rcu
30 #define rcu_read_lock()
31 #define rcu_read_unlock()
32 #define rcu_dereference(x) (x)
33 #define rcu_dereference_protected(x, y) (x)
34 #define rcu_assign_pointer(dst, src) (dst) = (src)
35 #define RCU_INIT_POINTER(dst, src) rcu_assign_pointer(dst, src)
36 #define synchronize_rcu()
37
38 #define unlikely(x) (x)
39 #define likely(x) (x)
40 #define UINT_MAX UINT64_MAX
41 #define L1_CACHE_SHIFT (LOG2_UP(ARCH_CL_SIZE))
42
43 /* Wanted to keep the _t variants in the code, in case that's useful in the
44  * future */
45 #define MIN_T(t, a, b) MIN(a, b)
46 #define MAX_T(t, a, b) MAX(a, b)
47 #define CLAMP(val, lo, hi) MIN((typeof(val))MAX(val, lo), hi)
48 #define CLAMP_T(t, val, lo, hi) CLAMP(val, lo, hi)
49
50 typedef physaddr_t dma_addr_t;
51 typedef int gfp_t;
52
53 /* these dma funcs are empty in linux with !CONFIG_NEED_DMA_MAP_STATE */
54 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)
55 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)
56 #define dma_unmap_addr(PTR, ADDR_NAME)           (0)
57 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  do { } while (0)
58 #define dma_unmap_len(PTR, LEN_NAME)             (0)
59 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    do { } while (0)
60 #define DMA_NONE                                0
61 #define DMA_TO_DEVICE                   1
62 #define DMA_FROM_DEVICE                 2
63 #define DMA_BIDIRECTIONAL               3
64
65 static inline void *__dma_alloc_coherent(size_t size, dma_addr_t *dma_handle,
66                                          gfp_t flags)
67 {
68         size_t order = LOG2_UP(nr_pages(size));
69         void *vaddr = get_cont_pages(order, flags);
70         if (!vaddr) {
71                 *dma_handle = 0;
72                 return 0;
73         }
74         *dma_handle = PADDR(vaddr);
75         return vaddr;
76 }
77
78 static inline void *__dma_zalloc_coherent(size_t size, dma_addr_t *dma_handle,
79                                           gfp_t flags)
80 {
81         void *vaddr = __dma_alloc_coherent(size, dma_handle, flags);
82         if (vaddr)
83                 memset(vaddr, 0, size);
84         return vaddr;
85 }
86
87 static inline void __dma_free_coherent(size_t size, void *cpu_addr,
88                                        dma_addr_t dma_handle)
89 {
90         size_t order = LOG2_UP(nr_pages(size));
91         free_cont_pages(cpu_addr, order);
92 }
93
94 static inline dma_addr_t __dma_map_single(void *cpu_addr, size_t size,
95                                           int direction)
96 {
97         return PADDR(cpu_addr);
98 }
99
100 static inline dma_addr_t __dma_map_page(struct page *page,
101                                         unsigned long offset, size_t size,
102                                         int direction)
103 {
104         assert(offset == 0);
105         return page2pa(page);
106 }
107
108 static inline int __dma_mapping_error(dma_addr_t dma_addr)
109 {
110         return (dma_addr == 0);
111 }
112
113 #define dma_unmap_single(...)
114 #define dma_unmap_page(...)
115 #define dma_set_mask_and_coherent(...) (0)
116 #define dma_sync_single_for_cpu(...)
117
118 /* Wrappers to avoid struct device.  Might want that one of these days */
119 #define dma_alloc_coherent(dev, size, dma_handlep, flag)                       \
120         __dma_alloc_coherent(size, dma_handlep, flag)
121
122 #define dma_zalloc_coherent(dev, size, dma_handlep, flag)                      \
123         __dma_zalloc_coherent(size, dma_handlep, flag)
124
125 #define dma_free_coherent(dev, size, dma_handle, flag)                         \
126         __dma_free_coherent(size, dma_handle, flag)
127
128 #define dma_map_single(dev, addr, size, direction)                             \
129         __dma_map_single(addr, size, direction)
130
131 #define dma_map_page(dev, page, offset, size, direction)                       \
132         __dma_map_page(page, offset, size, direction)
133
134 #define dma_mapping_error(dev, handle)                                         \
135         __dma_mapping_error(handle)
136
137
138 typedef int pci_power_t;
139 typedef int pm_message_t;
140
141 #define DEFINE_SEMAPHORE(name)  \
142     struct semaphore name = SEMAPHORE_INITIALIZER_IRQSAVE(name, 1)
143 #define sema_init(sem, val) sem_init_irqsave(sem, val)
144 #define up(sem) sem_up(sem)
145 #define down(sem) sem_down(sem)
146 #define down_trylock(sem) ({!sem_trydown(sem);})
147 /* In lieu of spatching, I wanted to keep the distinction between down and
148  * down_interruptible/down_timeout.  Akaros doesn't have the latter. */
149 #define down_interruptible(sem) ({sem_down(sem); 0;})
150 #define down_timeout(sem, timeout) ({sem_down(sem); 0;})
151
152 /* Linux printk front ends */
153 #ifndef pr_fmt
154 #define pr_fmt(fmt) fmt
155 #endif
156
157 #define KERN_EMERG ""
158 #define KERN_ALERT ""
159 #define KERN_CRIT ""
160 #define KERN_ERR ""
161 #define KERN_WARNING ""
162 #define KERN_NOTICE ""
163 #define KERN_INFO ""
164 #define KERN_CONT ""
165 #define KERN_DEBUG ""
166
167 /*
168  * These can be used to print at the various log levels.
169  * All of these will print unconditionally, although note that pr_debug()
170  * and other debug macros are compiled out unless either DEBUG is defined
171  * or CONFIG_DYNAMIC_DEBUG is set.
172  */
173 #define pr_emerg(fmt, ...) \
174         printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
175 #define pr_alert(fmt, ...) \
176         printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
177 #define pr_crit(fmt, ...) \
178         printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
179 #define pr_err(fmt, ...) \
180         printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
181 #define pr_warning(fmt, ...) \
182         printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
183 #define pr_warn pr_warning
184 #define pr_notice(fmt, ...) \
185         printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
186 #define pr_info(fmt, ...) \
187         printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
188 #define pr_cont(fmt, ...) \
189         printk(KERN_CONT fmt, ##__VA_ARGS__)
190 #define netdev_printk(lvl, dev, fmt, ...) \
191         printk(fmt, ##__VA_ARGS__)
192 #define netdev_err(dev, fmt, ...) \
193         printk(fmt, ##__VA_ARGS__)
194 #define netdev_info(dev, fmt, ...) \
195         printk(fmt, ##__VA_ARGS__)
196 #define dev_err(dev, fmt, ...) \
197         printk(fmt, ##__VA_ARGS__)
198 #define dev_info(dev, fmt, ...) \
199         printk(fmt, ##__VA_ARGS__)
200
201
202 #ifdef DEBUG
203
204 #define might_sleep() assert(can_block(&per_cpu_info[core_id()]))
205 #define pr_devel(fmt, ...) \
206         printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
207
208 #else
209
210 #define might_sleep()
211 #define pr_devel(fmt, ...) \
212         printd(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
213
214 #endif
215 #define pr_debug pr_devel
216
217
218 enum {
219         NETIF_MSG_DRV           = 0x0001,
220         NETIF_MSG_PROBE         = 0x0002,
221         NETIF_MSG_LINK          = 0x0004,
222         NETIF_MSG_TIMER         = 0x0008,
223         NETIF_MSG_IFDOWN        = 0x0010,
224         NETIF_MSG_IFUP          = 0x0020,
225         NETIF_MSG_RX_ERR        = 0x0040,
226         NETIF_MSG_TX_ERR        = 0x0080,
227         NETIF_MSG_TX_QUEUED     = 0x0100,
228         NETIF_MSG_INTR          = 0x0200,
229         NETIF_MSG_TX_DONE       = 0x0400,
230         NETIF_MSG_RX_STATUS     = 0x0800,
231         NETIF_MSG_PKTDATA       = 0x1000,
232         NETIF_MSG_HW            = 0x2000,
233         NETIF_MSG_WOL           = 0x4000,
234 };
235
236 #define MODULE_AUTHOR(...)
237 #define MODULE_DESCRIPTION(...)
238 #define MODULE_LICENSE(...)
239 #define MODULE_VERSION(...)
240 #define MODULE_FIRMWARE(...)
241 #define module_param(...)
242 #define module_param_named(...)
243 #define MODULE_PARM_DESC(...)
244 #define MODULE_DEVICE_TABLE(...)
245 #define THIS_MODULE ((void*)0)
246 #define EXPORT_SYMBOL(...)
247 #define __init
248 #define __exit
249 #define module_init(...)
250 #define module_exit(...)
251
252 #define is_kdump_kernel() (0)
253
254 /* from Linux's ethtool.h.  We probably won't use any of this code, but at
255  * least we can keep it quiet during porting. */
256 #define SPEED_10        10
257 #define SPEED_100       100
258 #define SPEED_1000      1000
259 #define SPEED_2500      2500
260 #define SPEED_10000     10000
261 #define SPEED_20000     20000
262 #define SPEED_40000     40000
263 #define SPEED_56000     56000
264 #define SPEED_UNKNOWN   -1
265
266 /* Duplex, half or full. */
267 #define DUPLEX_HALF     0x00
268 #define DUPLEX_FULL     0x01
269 #define DUPLEX_UNKNOWN  0xff
270
271 #define SUPPORTED_10baseT_Half      (1 << 0)
272 #define SUPPORTED_10baseT_Full      (1 << 1)
273 #define SUPPORTED_100baseT_Half     (1 << 2)
274 #define SUPPORTED_100baseT_Full     (1 << 3)
275 #define SUPPORTED_1000baseT_Half    (1 << 4)
276 #define SUPPORTED_1000baseT_Full    (1 << 5)
277 #define SUPPORTED_Autoneg       (1 << 6)
278 #define SUPPORTED_TP            (1 << 7)
279 #define SUPPORTED_AUI           (1 << 8)
280 #define SUPPORTED_MII           (1 << 9)
281 #define SUPPORTED_FIBRE         (1 << 10)
282 #define SUPPORTED_BNC           (1 << 11)
283 #define SUPPORTED_10000baseT_Full   (1 << 12)
284 #define SUPPORTED_Pause         (1 << 13)
285 #define SUPPORTED_Asym_Pause        (1 << 14)
286 #define SUPPORTED_2500baseX_Full    (1 << 15)
287 #define SUPPORTED_Backplane     (1 << 16)
288 #define SUPPORTED_1000baseKX_Full   (1 << 17)
289 #define SUPPORTED_10000baseKX4_Full (1 << 18)
290 #define SUPPORTED_10000baseKR_Full  (1 << 19)
291 #define SUPPORTED_10000baseR_FEC    (1 << 20)
292 #define SUPPORTED_20000baseMLD2_Full    (1 << 21)
293 #define SUPPORTED_20000baseKR2_Full (1 << 22)
294 #define SUPPORTED_40000baseKR4_Full (1 << 23)
295 #define SUPPORTED_40000baseCR4_Full (1 << 24)
296 #define SUPPORTED_40000baseSR4_Full (1 << 25)
297 #define SUPPORTED_40000baseLR4_Full (1 << 26)
298 #define SUPPORTED_56000baseKR4_Full (1 << 27)
299 #define SUPPORTED_56000baseCR4_Full (1 << 28)
300 #define SUPPORTED_56000baseSR4_Full (1 << 29)
301 #define SUPPORTED_56000baseLR4_Full (1 << 30)
302
303 #define ADVERTISED_10baseT_Half     (1 << 0)
304 #define ADVERTISED_10baseT_Full     (1 << 1)
305 #define ADVERTISED_100baseT_Half    (1 << 2)
306 #define ADVERTISED_100baseT_Full    (1 << 3)
307 #define ADVERTISED_1000baseT_Half   (1 << 4)
308 #define ADVERTISED_1000baseT_Full   (1 << 5)
309 #define ADVERTISED_Autoneg      (1 << 6)
310 #define ADVERTISED_TP           (1 << 7)
311 #define ADVERTISED_AUI          (1 << 8)
312 #define ADVERTISED_MII          (1 << 9)
313 #define ADVERTISED_FIBRE        (1 << 10)
314 #define ADVERTISED_BNC          (1 << 11)
315 #define ADVERTISED_10000baseT_Full  (1 << 12)
316 #define ADVERTISED_Pause        (1 << 13)
317 #define ADVERTISED_Asym_Pause       (1 << 14)
318 #define ADVERTISED_2500baseX_Full   (1 << 15)
319 #define ADVERTISED_Backplane        (1 << 16)
320 #define ADVERTISED_1000baseKX_Full  (1 << 17)
321 #define ADVERTISED_10000baseKX4_Full    (1 << 18)
322 #define ADVERTISED_10000baseKR_Full (1 << 19)
323 #define ADVERTISED_10000baseR_FEC   (1 << 20)
324 #define ADVERTISED_20000baseMLD2_Full   (1 << 21)
325 #define ADVERTISED_20000baseKR2_Full    (1 << 22)
326 #define ADVERTISED_40000baseKR4_Full    (1 << 23)
327 #define ADVERTISED_40000baseCR4_Full    (1 << 24)
328 #define ADVERTISED_40000baseSR4_Full    (1 << 25)
329 #define ADVERTISED_40000baseLR4_Full    (1 << 26)
330 #define ADVERTISED_56000baseKR4_Full    (1 << 27)
331 #define ADVERTISED_56000baseCR4_Full    (1 << 28)
332 #define ADVERTISED_56000baseSR4_Full    (1 << 29)
333 #define ADVERTISED_56000baseLR4_Full    (1 << 30)
334
335 enum ethtool_test_flags {
336         ETH_TEST_FL_OFFLINE = (1 << 0),
337         ETH_TEST_FL_FAILED  = (1 << 1),
338         ETH_TEST_FL_EXTERNAL_LB = (1 << 2),
339         ETH_TEST_FL_EXTERNAL_LB_DONE    = (1 << 3),
340 };
341
342 enum ethtool_stringset {
343         ETH_SS_TEST     = 0,
344         ETH_SS_STATS,
345         ETH_SS_PRIV_FLAGS,
346         ETH_SS_NTUPLE_FILTERS,
347         ETH_SS_FEATURES,
348         ETH_SS_RSS_HASH_FUNCS,
349 };
350
351 enum {
352         ETH_RSS_HASH_TOP_BIT, /* Configurable RSS hash function - Toeplitz */
353         ETH_RSS_HASH_XOR_BIT, /* Configurable RSS hash function - Xor */
354
355         ETH_RSS_HASH_FUNCS_COUNT
356 };
357
358 #define __ETH_RSS_HASH_BIT(bit) ((uint32_t)1 << (bit))
359 #define __ETH_RSS_HASH(name)    __ETH_RSS_HASH_BIT(ETH_RSS_HASH_##name##_BIT)
360
361 #define ETH_RSS_HASH_TOP    __ETH_RSS_HASH(TOP)
362 #define ETH_RSS_HASH_XOR    __ETH_RSS_HASH(XOR)
363
364 #define ETH_RSS_HASH_UNKNOWN    0
365 #define ETH_RSS_HASH_NO_CHANGE  0
366
367
368 /* EEPROM Standards for plug in modules */
369 #define ETH_MODULE_SFF_8079     0x1
370 #define ETH_MODULE_SFF_8079_LEN     256
371 #define ETH_MODULE_SFF_8472     0x2
372 #define ETH_MODULE_SFF_8472_LEN     512
373 #define ETH_MODULE_SFF_8636     0x3
374 #define ETH_MODULE_SFF_8636_LEN     256
375 #define ETH_MODULE_SFF_8436     0x4
376 #define ETH_MODULE_SFF_8436_LEN     256
377
378 #define ETH_GSTRING_LEN     32
379
380 /* ethernet protocol ids.  the plan 9 equivalent enum only exists in
381  * ethermedium.c. */
382 #define ETH_P_IP    0x0800      /* Internet Protocol packet */
383 #define ETH_P_IPV6  0x86DD      /* IPv6 over bluebook       */
384 #define ETH_P_ARP   0x0806      /* Address Resolution packet    */
385 #define ETH_P_FIP   0x8914      /* FCoE Initialization Protocol */
386 #define ETH_P_8021Q 0x8100          /* 802.1Q VLAN Extended Header  */
387
388 /* Sockaddr structs */
389 struct sockaddr {
390         uint16_t                                sa_family;
391         char                                    sa_data[14];
392 };
393
394 struct in_addr {
395         uint32_t                s_addr;
396 };
397 struct sockaddr_in {
398         uint16_t                                sin_family;
399         uint16_t                                sin_port;
400         struct in_addr                  sin_addr;
401         uint8_t                                 sin_zero[8]; /* padding */
402 };
403
404 struct in6_addr {
405         /* this is actually a weird union in glibc */
406         uint8_t                                 s6_addr[16];
407 };
408
409 struct sockaddr_in6 {
410         uint16_t                                sin6_family;
411         uint16_t                                sin6_port;
412         uint32_t                                sin6_flowinfo;
413         struct in6_addr                 sin6_addr;
414         uint32_t                                sin6_scope_id;
415 };
416
417 /* Common way to go from netdev (ether / netif) to driver-private ctlr */
418 static inline void *netdev_priv(struct ether *dev)
419 {
420         return dev->ctlr;
421 }
422
423 /* u64 on linux, but a u32 on plan 9.  the typedef is probably a good idea */
424 typedef unsigned int netdev_features_t;
425
426 /* Linux has features, hw_features, and a couple others.  Plan 9 just has
427  * features.  This #define should work for merging hw and regular features.  We
428  * spatched away the hw_enc and vlan feats. */
429 #define hw_features feat
430
431 /* Attempted conversions for plan 9 features.  For some things, like rx
432  * checksums, the driver flags the block (e.g. Budpck) to say if a receive
433  * checksum was already done.  There is no flag for saying the device can do
434  * it.  For transmits, the stack needs to know in advance if the device can
435  * handle the checksum or not. */
436 #define NETIF_F_RXHASH                          0
437 #define NETIF_F_RXCSUM                          0
438 #define NETIF_F_LRO                                     NETF_LRO
439 #define NETIF_F_GRO                                     0
440 #define NETIF_F_LOOPBACK                        0
441 #define NETIF_F_TSO                                     NETF_TSO
442 #define NETIF_F_SG                                      NETF_SG
443 #define NETIF_F_IP_CSUM                         (NETF_IPCK | NETF_UDPCK | NETF_TCPCK)
444 #define NETIF_F_IPV6_CSUM                       (NETF_IPCK | NETF_UDPCK | NETF_TCPCK)
445 #define NETIF_F_GSO_GRE                         0
446 #define NETIF_F_GSO_UDP_TUNNEL          0
447 #define NETIF_F_GSO_IPIP                        0
448 #define NETIF_F_GSO_SIT                         0
449 #define NETIF_F_TSO_ECN                         0
450 #define NETIF_F_TSO6                            0
451 #define NETIF_F_HW_VLAN_CTAG_TX         0
452 #define NETIF_F_HIGHDMA                         0
453 #define NETIF_F_HW_VLAN_CTAG_RX         0
454
455 /* Global mutex in linux for "routing netlink".  Not sure if we have an
456  * equivalent or not in Plan 9. */
457 #define rtnl_lock()
458 #define rtnl_unlock()
459 #define ASSERT_RTNL(...)
460
461 #define synchronize_irq(x) warn_once("Asked to sync IRQ %d, unsupported", x)
462 #define HZ 100
463
464 /* Linux has a PCI device id struct.  Drivers make tables of their supported
465  * devices, and this table is handled by higher level systems.  We don't have
466  * those systems, but we probably want the table still for our own parsing. */
467 struct pci_device_id {
468         uint32_t vendor, device;                /* Vendor and device ID or PCI_ANY_ID*/
469         uint32_t subvendor, subdevice;  /* Subsystem ID's or PCI_ANY_ID */
470         uint32_t class, class_mask;             /* (class,subclass,prog-if) triplet */
471         unsigned long driver_data;              /* Data private to the driver */
472 };
473
474 #define PCI_ANY_ID (~0)
475 /* This macro is used in setting device_id entries */
476 #define PCI_VDEVICE(vend, dev) \
477     .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
478     .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
479
480 /* Linux also has its own table of vendor ids.  We have the pci_defs table, but
481  * this is a bootstrap issue. */
482 #define PCI_VENDOR_ID_BROADCOM      0x14e4
483
484 /* I'd like to spatch all of the pci methods, but I don't know how to do the
485  * reads.  Since we're not doing the reads, then no sense doing the writes. */
486 static inline int pci_read_config_byte(struct pci_device *dev, uint32_t off,
487                                        uint8_t *val)
488 {
489         *val = pcidev_read8(dev, off);
490         return 0;
491 }
492                                        
493 static inline int pci_read_config_word(struct pci_device *dev, uint32_t off,
494                                        uint16_t *val)
495 {
496         *val = pcidev_read16(dev, off);
497         return 0;
498 }
499                                        
500 static inline int pci_read_config_dword(struct pci_device *dev, uint32_t off,
501                                         uint32_t *val)
502 {
503         *val = pcidev_read32(dev, off);
504         return 0;
505 }
506                                        
507 static inline int pci_write_config_byte(struct pci_device *dev, uint32_t off,
508                                         uint8_t val)
509 {
510         pcidev_write8(dev, off, val);
511         return 0;
512 }
513
514 static inline int pci_write_config_word(struct pci_device *dev, uint32_t off,
515                                         uint16_t val)
516 {
517         pcidev_write16(dev, off, val);
518         return 0;
519 }
520
521 static inline int pci_write_config_dword(struct pci_device *dev, uint32_t off,
522                                          uint32_t val)
523 {
524         pcidev_write32(dev, off, val);
525         return 0;
526 }
527
528 static inline void pci_disable_device(struct pci_device *dev)
529 {
530         pci_clr_bus_master(dev);
531 }
532
533 static inline int pci_enable_device(struct pci_device *dev)
534 {
535         pci_set_bus_master(dev);
536         return 0;
537 }
538
539
540
541 // TODO: maybe spatch these
542
543 static inline uint32_t pci_resource_len(struct pci_device *dev, int bir)
544 {
545         return pci_get_membar_sz(dev, bir);
546 }
547
548 static inline void *pci_resource_start(struct pci_device *dev, int bir)
549 {
550         return (void*)pci_get_membar(dev, bir);
551 }
552
553 static inline void *pci_resource_end(struct pci_device *dev, int bir)
554 {
555         return (void*)(pci_get_membar(dev, bir) + pci_resource_len(dev, bir));
556 }
557
558 #define ioremap_nocache(paddr, sz) \
559         (void*)vmap_pmem_nocache((uintptr_t)paddr, sz)
560 #define ioremap(paddr, sz) (void*)vmap_pmem(paddr, sz)
561 #define pci_ioremap_bar(dev, bir) (void*)pci_map_membar(dev, bir)
562 #define pci_set_master(x) pci_set_bus_master(x)
563
564 #define dev_addr_add(dev, addr, type) ({memcpy((dev)->ea, addr, Eaddrlen); 0;})
565 #define dev_addr_del(...)
566
567 #define SET_NETDEV_DEV(...)
568 #define netif_carrier_off(...)
569 #define netif_carrier_on(...)
570 /* May need to do something with edev's queues or flags. */
571 #define netif_tx_wake_all_queues(...)
572 #define netif_tx_wake_queue(...)
573 #define netif_tx_start_all_queues(...)
574 #define netif_tx_start_queue(...)
575 /* picks a random, valid mac addr for dev */
576 #define eth_hw_addr_random(...)
577 /* checks if the MAC is not 0 and not multicast (all 1s) */
578 #define is_valid_ether_addr(...) (TRUE)
579
580 #define EPROBE_DEFER 1
581
582 /* Could spatch this:
583         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
584         to:
585         if (!pci_get_membar(pdev, 0)) {
586
587         eth_zero_addr(bp->dev->ea);
588         to:
589         memset(bp->dev->ea, 0, Eaddrlen);
590 */
591
592 #endif /* ROS_KERN_AKAROS_COMPAT_H */