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