BNX2X: Spatch min, min_t, etc
[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 #define __rcu
27 #define unlikely(x) (x)
28
29 /* Wanted to keep the _t variants in the code, in case that's useful in the
30  * future */
31 #define MIN_T(t, a, b) MIN(a, b)
32 #define MAX_T(t, a, b) MAX(a, b)
33 #define CLAMP(val, lo, hi) MIN((typeof(val))MAX(val, lo), hi)
34 #define CLAMP_T(t, val, lo, hi) CLAMP(val, lo, hi)
35
36 typedef unsigned long dma_addr_t;
37 /* these dma funcs are empty in linux with !CONFIG_NEED_DMA_MAP_STATE */
38 #define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME)
39 #define DEFINE_DMA_UNMAP_LEN(LEN_NAME)
40 #define dma_unmap_addr(PTR, ADDR_NAME)           (0)
41 #define dma_unmap_addr_set(PTR, ADDR_NAME, VAL)  do { } while (0)
42 #define dma_unmap_len(PTR, LEN_NAME)             (0)
43 #define dma_unmap_len_set(PTR, LEN_NAME, VAL)    do { } while (0)
44 typedef int pci_power_t;
45
46 #define DEFINE_SEMAPHORE(name)  \
47     struct semaphore name = SEMAPHORE_INITIALIZER_IRQSAVE(name, 1)
48 #define sema_init(sem, val) sem_init_irqsave(sem, val)
49 #define up(sem) sem_up(sem)
50 #define down(sem) sem_down(sem)
51 #define down_trylock(sem) ({!sem_trydown(sem);})
52 /* In lieu of spatching, I wanted to keep the distinction between down and
53  * down_interruptible/down_timeout.  Akaros doesn't have the latter. */
54 #define down_interruptible(sem) ({sem_down(sem); 0;})
55 #define down_timeout(sem, timeout) ({sem_down(sem); 0;})
56
57 /* Linux printk front ends */
58 #ifndef pr_fmt
59 #define pr_fmt(fmt) fmt
60 #endif
61
62 #define KERN_EMERG
63 #define KERN_ALERT
64 #define KERN_CRIT
65 #define KERN_ERR
66 #define KERN_WARNING
67 #define KERN_NOTICE
68 #define KERN_INFO
69 #define KERN_CONT
70 #define KERN_DEBUG
71
72 /*
73  * These can be used to print at the various log levels.
74  * All of these will print unconditionally, although note that pr_debug()
75  * and other debug macros are compiled out unless either DEBUG is defined
76  * or CONFIG_DYNAMIC_DEBUG is set.
77  */
78 #define pr_emerg(fmt, ...) \
79         printk(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__)
80 #define pr_alert(fmt, ...) \
81         printk(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__)
82 #define pr_crit(fmt, ...) \
83         printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
84 #define pr_err(fmt, ...) \
85         printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
86 #define pr_warning(fmt, ...) \
87         printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
88 #define pr_warn pr_warning
89 #define pr_notice(fmt, ...) \
90         printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
91 #define pr_info(fmt, ...) \
92         printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
93 #define pr_cont(fmt, ...) \
94         printk(KERN_CONT fmt, ##__VA_ARGS__)
95
96
97 #ifdef DEBUG
98
99 #define might_sleep() assert(can_block(&per_cpu_info[core_id()]))
100 #define pr_devel(fmt, ...) \
101         printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
102
103 #else
104
105 #define might_sleep()
106 #define pr_devel(fmt, ...) \
107         printd(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
108
109 #endif
110 #define pr_debug pr_devel
111
112
113 enum {
114         NETIF_MSG_DRV           = 0x0001,
115         NETIF_MSG_PROBE         = 0x0002,
116         NETIF_MSG_LINK          = 0x0004,
117         NETIF_MSG_TIMER         = 0x0008,
118         NETIF_MSG_IFDOWN        = 0x0010,
119         NETIF_MSG_IFUP          = 0x0020,
120         NETIF_MSG_RX_ERR        = 0x0040,
121         NETIF_MSG_TX_ERR        = 0x0080,
122         NETIF_MSG_TX_QUEUED     = 0x0100,
123         NETIF_MSG_INTR          = 0x0200,
124         NETIF_MSG_TX_DONE       = 0x0400,
125         NETIF_MSG_RX_STATUS     = 0x0800,
126         NETIF_MSG_PKTDATA       = 0x1000,
127         NETIF_MSG_HW            = 0x2000,
128         NETIF_MSG_WOL           = 0x4000,
129 };
130
131 /* I'd like to spatch all of the pci methods, but I don't know how to do the
132  * reads.  Since we're not doing the reads, then no sense doing the writes. */
133 static inline int pci_read_config_byte(struct pci_device *dev, uint32_t off,
134                                        uint8_t *val)
135 {
136         *val = pcidev_read8(dev, off);
137         return 0;
138 }
139                                        
140 static inline int pci_read_config_word(struct pci_device *dev, uint32_t off,
141                                        uint16_t *val)
142 {
143         *val = pcidev_read16(dev, off);
144         return 0;
145 }
146                                        
147 static inline int pci_read_config_dword(struct pci_device *dev, uint32_t off,
148                                         uint32_t *val)
149 {
150         *val = pcidev_read32(dev, off);
151         return 0;
152 }
153                                        
154 static inline int pci_write_config_byte(struct pci_device *dev, uint32_t off,
155                                         uint8_t val)
156 {
157         pcidev_write8(dev, off, val);
158         return 0;
159 }
160
161 static inline int pci_write_config_word(struct pci_device *dev, uint32_t off,
162                                         uint16_t val)
163 {
164         pcidev_write16(dev, off, val);
165         return 0;
166 }
167
168 static inline int pci_write_config_dword(struct pci_device *dev, uint32_t off,
169                                          uint32_t val)
170 {
171         pcidev_write32(dev, off, val);
172         return 0;
173 }
174
175 #endif /* ROS_KERN_AKAROS_COMPAT_H */