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_BSD_H__
29#define __VCHI_BSD_H__
30
31#include <sys/param.h>
32#include <sys/systm.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/rwlock.h>
40#include <sys/sx.h>
41#include <sys/sema.h>
42#include <sys/malloc.h>
43#include <sys/proc.h>
44#include <sys/types.h>
45#include <sys/ioccom.h>
46
47/*
48 * Copy from/to user API
49 */
50#define copy_from_user(to, from, n)	copyin((from), (to), (n))
51#define copy_to_user(to, from, n)	copyout((from), (to), (n))
52
53/*
54 * Bit API
55 */
56
57static __inline int
58test_and_set_bit(int nr, volatile void *addr)
59{
60	int val;
61
62	do {
63		val = *(volatile int *) addr;
64	} while (atomic_cmpset_int(addr, val, val | (1 << nr)) == 0);
65	return (val & (1 << nr));
66}
67
68static __inline__
69int test_and_clear_bit(int nr, volatile void *addr)
70{
71	int val;
72
73	do {
74		val = *(volatile int *) addr;
75	} while (atomic_cmpset_int(addr, val, val & ~(1 << nr)) == 0);
76	return (val & (1 << nr));
77}
78
79/*
80 * Atomic API
81 */
82typedef volatile unsigned atomic_t;
83
84#define atomic_set(p, v)	(*(p) = (v))
85#define atomic_read(p)		(*(p))
86#define atomic_inc(p)		atomic_add_int(p, 1)
87#define atomic_dec(p)		atomic_subtract_int(p, 1)
88#define atomic_dec_and_test(p)	(atomic_fetchadd_int(p, -1) == 1)
89#define	atomic_inc_return(v)	atomic_add_return(1, (v))
90#define	atomic_dec_return(v)	atomic_sub_return(1, (v))
91#define atomic_add(v, p)	atomic_add_int(p, v)
92#define atomic_sub(v, p)	atomic_subtract_int(p, v)
93
94#define ATOMIC_INIT(v)		(v)
95
96static inline int
97atomic_add_return(int i, atomic_t *v)
98{
99	return i + atomic_fetchadd_int(v, i);
100}
101
102static inline int
103atomic_sub_return(int i, atomic_t *v)
104{
105	return atomic_fetchadd_int(v, -i) - i;
106}
107
108static inline int
109atomic_cmpxchg(atomic_t *v, int oldv, int newv)
110{
111	if (atomic_cmpset_rel_int(v, oldv, newv))
112		return newv;
113	else
114		return *v;
115}
116
117static inline int
118atomic_xchg(atomic_t *v, int newv)
119{
120	int oldv;
121	if (newv == 0)
122		return atomic_readandclear_int(v);
123	else {
124		do {
125			oldv = atomic_load_acq_int(v);
126		} while (!atomic_cmpset_rel_int(v, oldv, newv));
127	}
128
129	return (oldv);
130}
131
132/*
133 * Spinlock API
134 */
135typedef struct mtx spinlock_t;
136
137#define DEFINE_SPINLOCK(name)				\
138	struct mtx name
139#define spin_lock_init(lock)	mtx_init(lock, "VCHI spinlock " # lock, NULL, MTX_DEF)
140#define spin_lock_destroy(lock)	mtx_destroy(lock)
141#define spin_lock(lock)		mtx_lock(lock)
142#define spin_unlock(lock)	mtx_unlock(lock)
143#define spin_lock_bh(lock)	spin_lock(lock)
144#define spin_unlock_bh(lock)	spin_unlock(lock)
145
146/*
147 * Mutex API
148 */
149struct mutex {
150	struct sx	mtx;
151};
152
153#define	lmutex_init(lock)	sx_init(&(lock)->mtx, #lock)
154#define lmutex_lock(lock)	sx_xlock(&(lock)->mtx)
155#define	lmutex_unlock(lock)	sx_unlock(&(lock)->mtx)
156#define	lmutex_destroy(lock)	sx_destroy(&(lock)->mtx)
157
158#define lmutex_lock_interruptible(lock)	sx_xlock_sig(&(lock)->mtx)
159
160/*
161 * Rwlock API
162 */
163typedef struct rwlock rwlock_t;
164
165#define DEFINE_RWLOCK(name)				\
166	struct rwlock name;					\
167	SX_SYSINIT(name, &name, #name)
168#define rwlock_init(rwlock)	rw_init(rwlock, "VCHI rwlock")
169#define read_lock(rwlock)	rw_rlock(rwlock)
170#define read_unlock(rwlock)	rw_unlock(rwlock)
171
172#define write_lock(rwlock)	rw_wlock(rwlock)
173#define write_unlock(rwlock)	rw_unlock(rwlock)
174#define write_lock_irqsave(rwlock, flags)		\
175	do {						\
176		rw_wlock(rwlock);			\
177		(void) &(flags);			\
178	} while (0)
179#define write_unlock_irqrestore(rwlock, flags)		\
180	rw_unlock(rwlock)
181
182#define read_lock_bh(rwlock)	rw_rlock(rwlock)
183#define read_unlock_bh(rwlock)	rw_unlock(rwlock)
184#define write_lock_bh(rwlock)	rw_wlock(rwlock)
185#define write_unlock_bh(rwlock)	rw_unlock(rwlock)
186
187/*
188 * Timer API
189 */
190struct timer_list {
191	struct mtx mtx;
192	struct callout callout;
193
194	unsigned long expires;
195	void (*function)(unsigned long);
196	unsigned long data;
197};
198
199void vchiq_init_timer(struct timer_list *t);
200void vchiq_setup_timer(struct timer_list *t, void (*function)(unsigned long), unsigned long data);
201void vchiq_mod_timer(struct timer_list *t, unsigned long expires);
202void vchiq_add_timer(struct timer_list *t);
203int vchiq_del_timer(struct timer_list *t);
204int vchiq_del_timer_sync(struct timer_list *t);
205
206/*
207 * Completion API
208 */
209struct completion {
210	struct cv cv;
211	struct mtx lock;
212	int done;
213};
214
215void init_completion(struct completion *c);
216void destroy_completion(struct completion *c);
217int try_wait_for_completion(struct completion *);
218int wait_for_completion_interruptible(struct completion *);
219int wait_for_completion_interruptible_timeout(struct completion *, unsigned long ticks);
220int wait_for_completion_killable(struct completion *);
221void wait_for_completion(struct completion *c);
222void complete(struct completion *c);
223void complete_all(struct completion *c);
224void INIT_COMPLETION_locked(struct completion *c);
225
226#define	INIT_COMPLETION(x)	INIT_COMPLETION_locked(&(x))
227
228/*
229 * Semaphore API
230 */
231struct semaphore {
232	struct mtx	mtx;
233	struct cv	cv;
234	int		value;
235	int		waiters;
236};
237
238#define	DEFINE_SEMAPHORE(name)		\
239	struct semaphore name;		\
240	SYSINIT(name##_sema_sysinit, SI_SUB_LOCK, SI_ORDER_MIDDLE,	\
241	    sema_sysinit, &name);					\
242	SYSUNINIT(name##_sema_sysuninit, SI_SUB_LOCK, SI_ORDER_MIDDLE,	\
243	    _sema_destroy, __DEVOLATILE(void *, &(name)))
244
245void sema_sysinit(void *arg);
246void _sema_init(struct semaphore *s, int value);
247void _sema_destroy(struct semaphore *s);
248void down(struct semaphore *s);
249int down_interruptible(struct semaphore *s);
250int down_trylock(struct semaphore *s);
251void up(struct semaphore *s);
252
253/*
254 * Logging and assertions API
255 */
256void rlprintf(int pps, const char *fmt, ...)
257	__printflike(2, 3);
258
259void
260device_rlprintf(int pps, device_t dev, const char *fmt, ...)
261	__printflike(3, 4);
262
263#define might_sleep()
264
265#define WARN(condition, msg)				\
266({							\
267	int __ret_warn_on = !!(condition);		\
268	if (unlikely(__ret_warn_on))			\
269		printf((msg));				\
270	unlikely(__ret_warn_on);			\
271})
272
273
274
275#define WARN_ON(condition)				\
276({							\
277	int __ret_warn_on = !!(condition);		\
278	if (unlikely(__ret_warn_on))			\
279		printf("WARN_ON: " #condition "\n");	\
280	unlikely(__ret_warn_on);			\
281})
282
283#define WARN_ON_ONCE(condition) ({			\
284	static int __warned;				\
285	int __ret_warn_once = !!(condition);		\
286							\
287	if (unlikely(__ret_warn_once))			\
288		if (WARN_ON(!__warned))			\
289			__warned = 1;			\
290	unlikely(__ret_warn_once);			\
291})
292
293#define BUG_ON(cond)					\
294	do {						\
295		if (cond)				\
296			panic("BUG_ON: " #cond);	\
297	} while (0)
298
299#define BUG()						\
300	do {						\
301		panic("BUG: %s:%d", __FILE__, __LINE__);	\
302	} while (0)
303
304#define vchiq_static_assert(cond) CTASSERT(cond)
305
306#define KERN_EMERG	"<0>"	/* system is unusable			*/
307#define KERN_ALERT	"<1>"	/* action must be taken immediately	*/
308#define KERN_CRIT	"<2>"	/* critical conditions			*/
309#define KERN_ERR	"<3>"	/* error conditions			*/
310#define KERN_WARNING	"<4>"	/* warning conditions			*/
311#define KERN_NOTICE	"<5>"	/* normal but significant condition	*/
312#define KERN_INFO	"<6>"	/* informational			*/
313#define KERN_DEBUG	"<7>"	/* debug-level messages			*/
314#define KERN_CONT	""
315
316#define printk(fmt, args...)		printf(fmt, ##args)
317#define vprintk(fmt, args)		vprintf(fmt, args)
318
319/*
320 * Malloc API
321 */
322#define GFP_KERNEL	0
323#define GFP_ATOMIC	0
324
325MALLOC_DECLARE(M_VCHI);
326
327#define kmalloc(size, flags)	malloc((size), M_VCHI, M_NOWAIT | M_ZERO)
328#define kcalloc(n, size, flags)	mallocarray((n), (size), M_VCHI, \
329				    M_NOWAIT | M_ZERO)
330#define kzalloc(a, b)		kcalloc(1, (a), (b))
331#define kfree(p)		free(p, M_VCHI)
332
333/*
334 * Kernel module API
335 */
336#define __init
337#define __exit
338#define __devinit
339#define __devexit
340#define __devinitdata
341
342/*
343 * Time API
344 */
345#if 1
346/* emulate jiffies */
347static inline unsigned long
348_jiffies(void)
349{
350	struct timeval tv;
351
352	microuptime(&tv);
353	return tvtohz(&tv);
354}
355
356static inline unsigned long
357msecs_to_jiffies(unsigned long msecs)
358{
359	struct timeval tv;
360
361	tv.tv_sec = msecs / 1000000UL;
362	tv.tv_usec = msecs % 1000000UL;
363	return tvtohz(&tv);
364}
365
366#define jiffies			_jiffies()
367#else
368#define jiffies			ticks
369#endif
370#define HZ			hz
371
372#define udelay(usec)		DELAY(usec)
373#define mdelay(msec)		DELAY((msec) * 1000)
374
375#define schedule_timeout(jiff)	pause("dhdslp", jiff)
376
377#if defined(msleep)
378#undef msleep
379#endif
380#define msleep(msec)		mdelay(msec)
381
382#define time_after(a, b)	((a) > (b))
383#define time_after_eq(a, b)	((a) >= (b))
384#define time_before(a, b)	time_after((b), (a))
385
386/*
387 * kthread API (we use proc)
388 */
389typedef struct proc * VCHIQ_THREAD_T;
390
391VCHIQ_THREAD_T vchiq_thread_create(int (*threadfn)(void *data),
392                                   void *data,
393                                   const char namefmt[], ...);
394void set_user_nice(VCHIQ_THREAD_T p, int nice);
395void wake_up_process(VCHIQ_THREAD_T p);
396
397/*
398 * Proc APIs
399 */
400void flush_signals(VCHIQ_THREAD_T);
401int fatal_signal_pending(VCHIQ_THREAD_T);
402
403/*
404 * mbox API
405 */
406void bcm_mbox_write(int channel, uint32_t data);
407
408/*
409 * Misc API
410 */
411
412#define ENODATA EINVAL
413
414#define __user
415
416#define likely(x)		__builtin_expect(!!(x), 1)
417#define unlikely(x)		__builtin_expect(!!(x), 0)
418#define	current			curproc
419#define EXPORT_SYMBOL(x)
420#define PAGE_ALIGN(addr)	round_page(addr)
421
422typedef	void	irqreturn_t;
423typedef	off_t	loff_t;
424
425#define BCM2835_MBOX_CHAN_VCHIQ	3
426
427#define smp_mb	wmb
428#define smp_rmb	rmb
429#define smp_wmb	wmb
430
431#define device_print_prettyname(dev)	device_printf((dev), "")
432
433#endif /* __VCHI_BSD_H__ */
434