1 /*-
2 * Copyright (c) 2010 Max Khon <fjoe@freebsd.org>
3 * Copyright (c) 2012 Oleksandr Tymoshenko <gonzo@bluezbox.com>
4 * Copyright (c) 2013 Jared D. McNeill <jmcneill@invisible.ca>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28 #ifndef __VCHI_NETBSD_H__
29 #define __VCHI_NETBSD_H__
30
31 #include <sys/systm.h>
32 #include <sys/param.h>
33 #include <sys/bus.h>
34 #include <sys/conf.h>
35 #include <sys/lock.h>
36 #include <sys/kernel.h>
37 #include <sys/kthread.h>
38 #include <sys/mutex.h>
39 #include <sys/malloc.h>
40 #include <sys/proc.h>
41 #include <sys/types.h>
42 #include <sys/ioccom.h>
43 #include <sys/atomic.h>
44 #include <sys/rwlock.h>
45 #include <sys/callout.h>
46
47 #include <linux/completion.h>
48
49 /*
50 * Copy from/to user API
51 */
52 #define copy_from_user(to, from, n) copyin((from), (to), (n))
53 #define copy_to_user(to, from, n) copyout((from), (to), (n))
54
55 /*
56 * Atomic API
57 */
58 typedef volatile unsigned int atomic_t;
59
60 #define atomic_set(p, v) (*(p) = (v))
61 #define atomic_read(p) (*(volatile int *)(p))
62 #define atomic_inc(p) atomic_inc_uint(p)
63 #define atomic_dec(p) atomic_dec_uint(p)
64 #define atomic_dec_and_test(p) (atomic_dec_uint_nv(p) == 0)
65 #define atomic_inc_return(v) atomic_inc_uint_nv(v)
66 #define atomic_dec_return(v) atomic_dec_uint_nv(v)
67 #define atomic_add(v, p) atomic_add_int(p, v)
68 #define atomic_sub(v, p) atomic_add_int(p, -(v))
69 #define atomic_add_return(v, p) atomic_add_int_nv(p, v)
70 #define atomic_sub_return(v, p) atomic_add_int_nv(p, -(v))
71 #define atomic_xchg(p, v) atomic_swap_uint(p, v)
72 #define atomic_cmpxchg(p, oldv, newv) atomic_cas_uint(p, oldv, newv)
73
74 #define ATOMIC_INIT(v) (v)
75
76 /*
77 * Spinlock API
78 */
79 typedef kmutex_t spinlock_t;
80
81 /*
82 * NB: Need to initialize these at attach time!
83 */
84 #define DEFINE_SPINLOCK(name) kmutex_t name
85
86 #define spin_lock_init(lock) mutex_init(lock, MUTEX_DEFAULT, IPL_SCHED)
87 #define spin_lock_destroy(lock) mutex_destroy(lock)
88 #define spin_lock(lock) mutex_spin_enter(lock)
89 #define spin_unlock(lock) mutex_spin_exit(lock)
90
91 /*
92 * Mutex API
93 */
94 struct mutex {
95 kmutex_t mtx;
96 };
97
98 #define lmutex_init(lock) mutex_init(&(lock)->mtx, MUTEX_DEFAULT, IPL_NONE)
99 #define lmutex_destroy(lock) mutex_destroy(&(lock)->mtx)
100 #define lmutex_lock(lock) mutex_enter(&(lock)->mtx)
101 #define lmutex_lock_interruptible(lock) (mutex_enter(&(lock)->mtx),0)
102 #define lmutex_unlock(lock) mutex_exit(&(lock)->mtx)
103
104 /*
105 * Rwlock API
106 */
107 typedef kmutex_t rwlock_t;
108
109 #define DEFINE_RWLOCK(name) kmutex_t name
110
111 #define rwlock_init(rwlock) mutex_init(rwlock, MUTEX_DEFAULT, IPL_SCHED)
112 #define read_lock(rwlock) mutex_spin_enter(rwlock)
113 #define read_unlock(rwlock) mutex_spin_exit(rwlock)
114
115 #define write_lock(rwlock) mutex_spin_enter(rwlock)
116 #define write_unlock(rwlock) mutex_spin_exit(rwlock)
117
118 #define read_lock_bh(rwlock) read_lock(rwlock)
119 #define read_unlock_bh(rwlock) read_unlock(rwlock)
120 #define write_lock_bh(rwlock) write_lock(rwlock)
121 #define write_unlock_bh(rwlock) write_unlock(rwlock)
122
123 /*
124 * Timer API
125 */
126 struct timer_list {
127 kmutex_t mtx;
128 callout_t callout;
129
130 unsigned long expires;
131 void (*function)(unsigned long);
132 unsigned long data;
133 };
134
135 void init_timer(struct timer_list *t);
136 void setup_timer(struct timer_list *t, void (*function)(unsigned long), unsigned long data);
137 void mod_timer(struct timer_list *t, unsigned long expires);
138 void add_timer(struct timer_list *t);
139 int del_timer(struct timer_list *t);
140 int del_timer_sync(struct timer_list *t);
141
142 /*
143 * Semaphore API
144 */
145 struct semaphore {
146 kmutex_t mtx;
147 kcondvar_t cv;
148 int value;
149 int waiters;
150 };
151
152 /*
153 * NB: Need to initialize these at attach time!
154 */
155 #define DEFINE_SEMAPHORE(name) struct semaphore name
156
157 void sema_sysinit(void *arg);
158 void _sema_init(struct semaphore *s, int value);
159 void _sema_destroy(struct semaphore *s);
160 void down(struct semaphore *s);
161 int down_interruptible(struct semaphore *s);
162 int down_trylock(struct semaphore *s);
163 void up(struct semaphore *s);
164
165 /*
166 * Logging and assertions API
167 */
168 void rlprintf(int pps, const char *fmt, ...)
169 __printflike(2, 3);
170
171 void
172 device_rlprintf(int pps, device_t dev, const char *fmt, ...)
173 __printflike(3, 4);
174
175 #define might_sleep()
176
177 #define WARN(condition, msg) \
178 ({ \
179 int __ret_warn_on = !!(condition); \
180 if (unlikely(__ret_warn_on)) \
181 printf((msg)); \
182 unlikely(__ret_warn_on); \
183 })
184
185
186
187 #define WARN_ON(condition) \
188 ({ \
189 int __ret_warn_on = !!(condition); \
190 if (unlikely(__ret_warn_on)) \
191 printf("WARN_ON: " #condition "\n"); \
192 unlikely(__ret_warn_on); \
193 })
194
195 #define WARN_ON_ONCE(condition) ({ \
196 static int __warned; \
197 int __ret_warn_once = !!(condition); \
198 \
199 if (unlikely(__ret_warn_once)) \
200 if (WARN_ON(!__warned)) \
201 __warned = 1; \
202 unlikely(__ret_warn_once); \
203 })
204
205 #define BUG_ON(cond) \
206 do { \
207 if (cond) \
208 panic("BUG_ON: " #cond); \
209 } while (0)
210
211 #define BUG() \
212 do { \
213 panic("BUG: %s:%d", __FILE__, __LINE__); \
214 } while (0)
215
216 #define vchiq_static_assert(cond) CTASSERT(cond)
217
218 #define KERN_EMERG "<0>" /* system is unusable */
219 #define KERN_ALERT "<1>" /* action must be taken immediately */
220 #define KERN_CRIT "<2>" /* critical conditions */
221 #define KERN_ERR "<3>" /* error conditions */
222 #define KERN_WARNING "<4>" /* warning conditions */
223 #define KERN_NOTICE "<5>" /* normal but significant condition */
224 #define KERN_INFO "<6>" /* informational */
225 #define KERN_DEBUG "<7>" /* debug-level messages */
226 #define KERN_CONT ""
227
228 #define printk(fmt, args...) printf(fmt, ##args)
229 #define vprintk(fmt, args) vprintf(fmt, args)
230
231 /*
232 * Malloc API
233 */
234 #define GFP_KERNEL 0
235 #define GFP_ATOMIC 0
236
237 MALLOC_DECLARE(M_VCHI);
238
239 #define kmalloc(size, flags) malloc((size), M_VCHI, M_NOWAIT | M_ZERO)
240 #define kcalloc(n, size, flags) malloc((n) * (size), M_VCHI, M_NOWAIT | M_ZERO)
241 #define kzalloc(a, b) kcalloc(1, (a), (b))
242 #define kfree(p) do { if (p) free(p, M_VCHI); } while (0)
243
244 /*
245 * Kernel module API
246 */
247 #define __init
248 #define __exit
249 #define __devinit
250 #define __devexit
251 #define __devinitdata
252
253 /*
254 * Time API
255 */
256 #if 1
257 /* emulate jiffies */
258 static inline unsigned long
_jiffies(void)259 _jiffies(void)
260 {
261 struct timeval tv;
262
263 microuptime(&tv);
264 return tvtohz(&tv);
265 }
266
267 static inline unsigned long
msecs_to_jiffies(unsigned long msecs)268 msecs_to_jiffies(unsigned long msecs)
269 {
270 struct timeval tv;
271
272 tv.tv_sec = msecs / 1000000UL;
273 tv.tv_usec = msecs % 1000000UL;
274 return tvtohz(&tv);
275 }
276
277 #define jiffies _jiffies()
278 #else
279 #define jiffies ticks
280 #endif
281 #define HZ hz
282
283 #define udelay(usec) DELAY(usec)
284 #define mdelay(msec) DELAY((msec) * 1000)
285
286 #define schedule_timeout(jiff) kpause("dhdslp", false, jiff, NULL)
287
288 #if defined(msleep)
289 #undef msleep
290 #endif
291 #define msleep(msec) mdelay(msec)
292
293 #define time_after(a, b) ((a) > (b))
294 #define time_after_eq(a, b) ((a) >= (b))
295 #define time_before(a, b) time_after((b), (a))
296
297 /*
298 * kthread API (we use lwp)
299 */
300 typedef lwp_t * VCHIQ_THREAD_T;
301
302 VCHIQ_THREAD_T vchiq_thread_create(int (*threadfn)(void *data),
303 void *data,
304 const char namefmt[], ...);
305 void set_user_nice(VCHIQ_THREAD_T p, int nice);
306 void wake_up_process(VCHIQ_THREAD_T p);
307
308 /*
309 * Proc APIs
310 */
311 void flush_signals(VCHIQ_THREAD_T);
312 int fatal_signal_pending(VCHIQ_THREAD_T);
313
314 /*
315 * Misc API
316 */
317
318 #define __user
319
320 #define current curlwp
321 #define EXPORT_SYMBOL(x)
322 #define PAGE_ALIGN(addr) round_page(addr)
323
324 typedef void irqreturn_t;
325 typedef off_t loff_t;
326
327 #define BCM2835_MBOX_CHAN_VCHIQ 3
328 #define bcm_mbox_write bcmmbox_write
329
330 #define rmb membar_consumer
331 #define wmb membar_producer
332 #define dsb membar_producer
333
334 #define smp_mb membar_producer
335 #define smp_rmb membar_consumer
336 #define smp_wmb membar_producer
337
338 #define device_print_prettyname(dev) device_printf((dev), "")
339
340 #endif /* __VCHI_NETBSD_H__ */
341