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 #include <linux/types.h>
49 #include <asm/barrier.h>
50
51 /*
52 * Copy from/to user API
53 */
54 #define copy_from_user(to, from, n) copyin((from), (to), (n))
55 #define copy_to_user(to, from, n) copyout((from), (to), (n))
56
57 /*
58 * Atomic API
59 */
60 typedef volatile unsigned int atomic_t;
61
62 #define atomic_set(p, v) (*(p) = (v))
63 #define atomic_read(p) (*(volatile int *)(p))
64 #define atomic_inc(p) atomic_inc_uint(p)
65 #define atomic_dec(p) atomic_dec_uint(p)
66 #define atomic_dec_and_test(p) (atomic_dec_uint_nv(p) == 0)
67 #define atomic_inc_return(v) atomic_inc_uint_nv(v)
68 #define atomic_dec_return(v) atomic_dec_uint_nv(v)
69 #define atomic_add(v, p) atomic_add_int(p, v)
70 #define atomic_sub(v, p) atomic_add_int(p, -(v))
71 #define atomic_add_return(v, p) atomic_add_int_nv(p, v)
72 #define atomic_sub_return(v, p) atomic_add_int_nv(p, -(v))
73 #define atomic_xchg(p, v) atomic_swap_uint(p, v)
74 #define atomic_cmpxchg(p, oldv, newv) atomic_cas_uint(p, oldv, newv)
75
76 #define ATOMIC_INIT(v) (v)
77
78 /*
79 * Spinlock API
80 */
81 typedef kmutex_t spinlock_t;
82
83 /*
84 * NB: Need to initialize these at attach time!
85 */
86 #define DEFINE_SPINLOCK(name) kmutex_t name
87
88 #define spin_lock_init(lock) mutex_init(lock, MUTEX_DEFAULT, IPL_VM)
89 #define spin_lock_destroy(lock) mutex_destroy(lock)
90 #define spin_lock(lock) mutex_spin_enter(lock)
91 #define spin_unlock(lock) mutex_spin_exit(lock)
92
93 /*
94 * Mutex API
95 */
96 struct mutex {
97 kmutex_t mtx;
98 };
99
100 #define lmutex_init(lock) mutex_init(&(lock)->mtx, MUTEX_DEFAULT, IPL_NONE)
101 #define lmutex_destroy(lock) mutex_destroy(&(lock)->mtx)
102 #define lmutex_lock(lock) mutex_enter(&(lock)->mtx)
103 #define lmutex_lock_interruptible(lock) (mutex_enter(&(lock)->mtx),0)
104 #define lmutex_unlock(lock) mutex_exit(&(lock)->mtx)
105
106 /*
107 * Rwlock API
108 */
109 typedef kmutex_t rwlock_t;
110
111 #define DEFINE_RWLOCK(name) kmutex_t name
112
113 #define rwlock_init(rwlock) mutex_init(rwlock, MUTEX_DEFAULT, IPL_VM)
114 #define read_lock(rwlock) mutex_spin_enter(rwlock)
115 #define read_unlock(rwlock) mutex_spin_exit(rwlock)
116
117 #define write_lock(rwlock) mutex_spin_enter(rwlock)
118 #define write_unlock(rwlock) mutex_spin_exit(rwlock)
119
120 #define read_lock_bh(rwlock) read_lock(rwlock)
121 #define read_unlock_bh(rwlock) read_unlock(rwlock)
122 #define write_lock_bh(rwlock) write_lock(rwlock)
123 #define write_unlock_bh(rwlock) write_unlock(rwlock)
124
125 /*
126 * Timer API
127 */
128 struct timer_list {
129 kmutex_t mtx;
130 callout_t callout;
131
132 unsigned long expires;
133 void (*function)(unsigned long);
134 unsigned long data;
135 };
136
137 void init_timer(struct timer_list *t);
138 void setup_timer(struct timer_list *t, void (*function)(unsigned long), unsigned long data);
139 void mod_timer(struct timer_list *t, unsigned long expires);
140 void add_timer(struct timer_list *t);
141 int del_timer(struct timer_list *t);
142 int del_timer_sync(struct timer_list *t);
143
144 /*
145 * Semaphore API
146 */
147 struct semaphore {
148 kmutex_t mtx;
149 kcondvar_t cv;
150 int value;
151 int waiters;
152 };
153
154 /*
155 * NB: Need to initialize these at attach time!
156 */
157 #define DEFINE_SEMAPHORE(name) struct semaphore name
158
159 void sema_sysinit(void *arg);
160 void _sema_init(struct semaphore *s, int value);
161 void _sema_destroy(struct semaphore *s);
162 void down(struct semaphore *s);
163 int down_interruptible(struct semaphore *s);
164 int down_trylock(struct semaphore *s);
165 void up(struct semaphore *s);
166
167 /*
168 * Logging and assertions API
169 */
170 void rlprintf(int pps, const char *fmt, ...)
171 __printflike(2, 3);
172
173 void
174 device_rlprintf(int pps, device_t dev, const char *fmt, ...)
175 __printflike(3, 4);
176
177 #define vchiq_static_assert(cond) CTASSERT(cond)
178
179 /*
180 * Kernel module API
181 */
182 #define __init
183 #define __exit
184 #define __devinit
185 #define __devexit
186 #define __devinitdata
187
188 /*
189 * Time API
190 */
191 #if 1
192 /* emulate jiffies */
193 static inline unsigned long
_jiffies(void)194 _jiffies(void)
195 {
196 struct timeval tv;
197
198 microuptime(&tv);
199 return tvtohz(&tv);
200 }
201
202 static inline unsigned long
msecs_to_jiffies(unsigned long msecs)203 msecs_to_jiffies(unsigned long msecs)
204 {
205 struct timeval tv;
206
207 tv.tv_sec = msecs / 1000000UL;
208 tv.tv_usec = msecs % 1000000UL;
209 return tvtohz(&tv);
210 }
211
212 #define jiffies _jiffies()
213 #else
214 #define jiffies ticks
215 #endif
216 #define HZ hz
217
218 #define udelay(usec) DELAY(usec)
219 #define mdelay(msec) DELAY((msec) * 1000)
220
221 #define schedule_timeout(jiff) kpause("dhdslp", false, jiff, NULL)
222
223 #if defined(msleep)
224 #undef msleep
225 #endif
226 #define msleep(msec) mdelay(msec)
227
228 #define time_after(a, b) ((a) > (b))
229 #define time_after_eq(a, b) ((a) >= (b))
230 #define time_before(a, b) time_after((b), (a))
231
232 /*
233 * kthread API (we use lwp)
234 */
235 typedef lwp_t * VCHIQ_THREAD_T;
236
237 VCHIQ_THREAD_T vchiq_thread_create(int (*threadfn)(void *data),
238 void *data,
239 const char namefmt[], ...);
240 void set_user_nice(VCHIQ_THREAD_T p, int nice);
241 void wake_up_process(VCHIQ_THREAD_T p);
242
243 /*
244 * Proc APIs
245 */
246 void flush_signals(VCHIQ_THREAD_T);
247 int fatal_signal_pending(VCHIQ_THREAD_T);
248
249 /*
250 * Misc API
251 */
252
253 #define __user
254
255 #define current curlwp
256 #define PAGE_ALIGN(addr) round_page(addr)
257
258 typedef void irqreturn_t;
259
260 #define BCM2835_MBOX_CHAN_VCHIQ 3
261 #define bcm_mbox_write bcmmbox_write
262
263 #define device_print_prettyname(dev) device_printf((dev), "")
264
265 #endif /* __VCHI_NETBSD_H__ */
266