Rename printf -> kprintf in sys/ and add some defines where necessary
[dragonfly.git] / sys / dev / drm / drm_os_freebsd.h
CommitLineData
984263bc
MD
1/*
2 * $FreeBSD: src/sys/dev/drm/drm_os_freebsd.h,v 1.10.2.1 2003/04/26 07:05:28 anholt Exp $
e3869ec7 3 * $DragonFly: src/sys/dev/drm/Attic/drm_os_freebsd.h,v 1.23 2006/12/22 23:26:17 swildner Exp $
984263bc
MD
4 */
5#include <sys/param.h>
6#include <sys/queue.h>
7#include <sys/malloc.h>
8#include <sys/kernel.h>
9#include <sys/module.h>
10#include <sys/systm.h>
11#include <sys/conf.h>
fef8985e 12#include <sys/device.h>
984263bc
MD
13#include <sys/stat.h>
14#include <sys/proc.h>
15#include <sys/lock.h>
16#include <sys/fcntl.h>
17#include <sys/uio.h>
18#include <sys/filio.h>
19#include <sys/sysctl.h>
20#include <sys/bus.h>
21#include <sys/signalvar.h>
22#include <sys/poll.h>
23#include <vm/vm.h>
24#include <vm/pmap.h>
25#include <vm/vm_extern.h>
26#include <vm/vm_map.h>
27#include <vm/vm_param.h>
28#include <machine/param.h>
29#include <machine/pmap.h>
984263bc
MD
30#include <sys/mman.h>
31#include <sys/rman.h>
32#include <sys/memrange.h>
1f2de5d4 33#include <bus/pci/pcivar.h>
4637ddfb 34#if defined(__FreeBSD__) && __FreeBSD_version >= 500000
984263bc
MD
35#include <sys/selinfo.h>
36#else
37#include <sys/select.h>
38#endif
39#include <sys/bus.h>
4637ddfb 40#if defined(__DragonFly__) || __FreeBSD_version >= 400005
984263bc 41#include <sys/taskqueue.h>
5efd5c8c 42#include <sys/thread2.h>
984263bc 43#endif
4637ddfb 44#if defined(__FreeBSD__) && __FreeBSD_version >= 500000
984263bc
MD
45#include <sys/mutex.h>
46#endif
47
4637ddfb 48#if defined(__DragonFly__) || __FreeBSD_version >= 400006
984263bc
MD
49#define __REALLY_HAVE_AGP __HAVE_AGP
50#endif
51
52#ifdef __i386__
4637ddfb 53#define __REALLY_HAVE_MTRR ((__HAVE_MTRR) && defined(__FreeBSD__) && __FreeBSD_version >= 500000)
984263bc
MD
54#else
55#define __REALLY_HAVE_MTRR 0
56#endif
57#define __REALLY_HAVE_SG (__HAVE_SG)
58
59#if __REALLY_HAVE_AGP
1f2de5d4 60#include <dev/agp/agpvar.h>
984263bc
MD
61#include <sys/agpio.h>
62#endif
63
64#include <opt_drm.h>
65#if DRM_DEBUG
66#undef DRM_DEBUG_CODE
67#define DRM_DEBUG_CODE 2
68#endif
69#undef DRM_DEBUG
70
71#if DRM_LINUX
72#include <sys/file.h>
73#include <sys/proc.h>
3930af25
JS
74#include <emulation/linux/i386/linux.h>
75#include <emulation/linux/i386/linux_proto.h>
984263bc
MD
76#endif
77
78#define DRM_TIME_SLICE (hz/20) /* Time slice for GLXContexts */
79
80#define DRM_DEV_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
81#define DRM_DEV_UID 0
82#define DRM_DEV_GID 0
83#define CDEV_MAJOR 145
84
4637ddfb 85#if defined(__FreeBSD__) && __FreeBSD_version >= 500000
984263bc
MD
86#define DRM_CURPROC curthread
87#define DRM_STRUCTPROC struct thread
88#define DRM_SPINTYPE struct mtx
89#define DRM_SPININIT(l,name) mtx_init(&l, name, NULL, MTX_DEF)
90#define DRM_SPINUNINIT(l) mtx_destroy(&l)
91#define DRM_SPINLOCK(l) mtx_lock(l)
92#define DRM_SPINUNLOCK(u) mtx_unlock(u);
93#define DRM_CURRENTPID curthread->td_proc->p_pid
94#else
7b95be2a
MD
95#define DRM_CURPROC curthread
96#define DRM_STRUCTPROC struct thread
7cd8d145
MD
97#define DRM_SPINTYPE struct lock
98#define DRM_SPININIT(l,name) lockinit(&l, name, 0, 0)
984263bc 99#define DRM_SPINUNINIT(l)
7cd8d145
MD
100#define DRM_SPINLOCK(l) lockmgr(l, LK_EXCLUSIVE|LK_RETRY)
101#define DRM_SPINUNLOCK(u) lockmgr(u, LK_RELEASE);
7b95be2a 102#define DRM_CURRENTPID curthread->td_proc->p_pid
984263bc
MD
103#endif
104
105/* Currently our DRMFILE (filp) is a void * which is actually the pid
106 * of the current process. It should be a per-open unique pointer, but
107 * code for that is not yet written */
108#define DRMFILE void *
b13267a5 109#define DRM_IOCTL_ARGS cdev_t kdev, u_long cmd, caddr_t data, int flags, DRM_STRUCTPROC *p, DRMFILE filp
7cd8d145 110#define DRM_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE | LK_RETRY)
df4f70a6 111#define DRM_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE)
dadab5e9 112#define DRM_SUSER(td) suser(td)
984263bc
MD
113#define DRM_TASKQUEUE_ARGS void *arg, int pending
114#define DRM_IRQ_ARGS void *arg
115#define DRM_DEVICE drm_device_t *dev = kdev->si_drv1
77652cad
MD
116#define DRM_MALLOC(size) kmalloc( size, DRM(M_DRM), M_NOWAIT )
117#define DRM_FREE(pt,size) kfree( pt, DRM(M_DRM) )
984263bc
MD
118#define DRM_VTOPHYS(addr) vtophys(addr)
119
120/* Read/write from bus space, with byteswapping to le if necessary */
121#define DRM_READ8(map, offset) *(volatile u_int8_t *) (((unsigned long)(map)->handle) + (offset))
122#define DRM_READ32(map, offset) *(volatile u_int32_t *)(((unsigned long)(map)->handle) + (offset))
123#define DRM_WRITE8(map, offset, val) *(volatile u_int8_t *) (((unsigned long)(map)->handle) + (offset)) = val
124#define DRM_WRITE32(map, offset, val) *(volatile u_int32_t *)(((unsigned long)(map)->handle) + (offset)) = val
125/*
126#define DRM_READ8(map, offset) bus_space_read_1( (map)->iot, (map)->ioh, (offset) )
127#define DRM_READ32(map, offset) bus_space_read_4( (map)->iot, (map)->ioh, (offset) )
128#define DRM_WRITE8(map, offset, val) bus_space_write_1( (map)->iot, (map)->ioh, (offset), (val) )
129#define DRM_WRITE32(map, offset, val) bus_space_write_4( (map)->iot, (map)->ioh, (offset), (val) )
130*/
131#define DRM_AGP_FIND_DEVICE() agp_find_device()
132#define DRM_ERR(v) v
133
134#define DRM_PRIV \
fef8985e 135 drm_file_t *priv = (drm_file_t *) DRM(find_file_by_proc)(dev, curthread); \
984263bc
MD
136 if (!priv) { \
137 DRM_DEBUG("can't find authenticator\n"); \
138 return EINVAL; \
139 }
140
141#define LOCK_TEST_WITH_RETURN(dev, filp) \
142do { \
143 if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock) || \
144 dev->lock.filp != filp) { \
145 DRM_ERROR("%s called without lock held\n", \
5e2195bf 146 __func__); \
984263bc
MD
147 return EINVAL; \
148 } \
149} while (0)
150
151#define DRM_UDELAY( udelay ) \
152do { \
153 struct timeval tv1, tv2; \
154 microtime(&tv1); \
155 do { \
156 microtime(&tv2); \
157 } \
158 while (((tv2.tv_sec-tv1.tv_sec)*1000000 + tv2.tv_usec - tv1.tv_usec) < udelay ); \
159} while (0)
160
161#define DRM_GETSAREA() \
162do { \
163 drm_map_list_entry_t *listentry; \
164 TAILQ_FOREACH(listentry, dev->maplist, link) { \
165 drm_local_map_t *map = listentry->map; \
166 if (map->type == _DRM_SHM && \
167 map->flags & _DRM_CONTAINS_LOCK) { \
168 dev_priv->sarea = map; \
169 break; \
170 } \
171 } \
172} while (0)
173
174#define DRM_HZ hz
175
176#define DRM_WAIT_ON( ret, queue, timeout, condition ) \
177while (!condition) { \
377d4740 178 ret = tsleep( &(queue), PCATCH, "drmwtq", (timeout) ); \
984263bc
MD
179 if ( ret ) \
180 return ret; \
181}
182
183#define DRM_WAKEUP( queue ) wakeup( queue )
184#define DRM_WAKEUP_INT( queue ) wakeup( queue )
185#define DRM_INIT_WAITQUEUE( queue ) do {} while (0)
186
187#define DRM_COPY_TO_USER_IOCTL(user, kern, size) \
188 if ( IOCPARM_LEN(cmd) != size) \
189 return EINVAL; \
190 *user = kern;
191#define DRM_COPY_FROM_USER_IOCTL(kern, user, size) \
192 if ( IOCPARM_LEN(cmd) != size) \
193 return EINVAL; \
194 kern = *user;
195#define DRM_COPY_TO_USER(user, kern, size) \
196 copyout(kern, user, size)
197#define DRM_COPY_FROM_USER(kern, user, size) \
198 copyin(user, kern, size)
199/* Macros for userspace access with checking readability once */
200/* FIXME: can't find equivalent functionality for nocheck yet.
201 * It'll be slower than linux, but should be correct.
202 */
203#define DRM_VERIFYAREA_READ( uaddr, size ) \
204 (!useracc((caddr_t)uaddr, size, VM_PROT_READ))
205#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
206 copyin(arg2, arg1, arg3)
207#define DRM_GET_USER_UNCHECKED(val, uaddr) \
208 ((val) = fuword(uaddr), 0)
209
210#define DRM_WRITEMEMORYBARRIER( map ) \
211 bus_space_barrier((map)->iot, (map)->ioh, 0, (map)->size, 0);
212#define DRM_READMEMORYBARRIER( map ) \
213 bus_space_barrier((map)->iot, (map)->ioh, 0, (map)->size, BUS_SPACE_BARRIER_READ);
214
215#define PAGE_ALIGN(addr) round_page(addr)
216
217#ifndef M_WAITOK /* M_WAITOK (=0) name removed in -current */
218#define M_WAITOK 0
219#endif
220
221#define malloctype DRM(M_DRM)
222/* The macros conflicted in the MALLOC_DEFINE */
223MALLOC_DECLARE(malloctype);
224#undef malloctype
225
226typedef struct drm_chipinfo
227{
228 int vendor;
229 int device;
230 int supported;
231 char *name;
232} drm_chipinfo_t;
233
234#define cpu_to_le32(x) (x) /* FIXME */
235
236typedef unsigned long dma_addr_t;
237typedef u_int32_t atomic_t;
238typedef u_int32_t u32;
239typedef u_int16_t u16;
240typedef u_int8_t u8;
241#define atomic_set(p, v) (*(p) = (v))
242#define atomic_read(p) (*(p))
243#define atomic_inc(p) atomic_add_int(p, 1)
244#define atomic_dec(p) atomic_subtract_int(p, 1)
245#define atomic_add(n, p) atomic_add_int(p, n)
246#define atomic_sub(n, p) atomic_subtract_int(p, n)
247
248/* Fake this */
249
984263bc
MD
250static __inline atomic_t
251test_and_set_bit(int b, volatile void *p)
252{
5efd5c8c
MD
253 unsigned int m;
254 unsigned int r;
255
256 crit_enter();
257 m = 1<<b;
258 r = *(volatile int *)p & m;
984263bc 259 *(volatile int *)p |= m;
5efd5c8c 260 crit_exit();
984263bc
MD
261 return r;
262}
263
264static __inline void
265clear_bit(int b, volatile void *p)
266{
267 atomic_clear_int(((volatile int *)p) + (b >> 5), 1 << (b & 0x1f));
268}
269
270static __inline void
271set_bit(int b, volatile void *p)
272{
273 atomic_set_int(((volatile int *)p) + (b >> 5), 1 << (b & 0x1f));
274}
275
276static __inline int
277test_bit(int b, volatile void *p)
278{
279 return ((volatile int *)p)[b >> 5] & (1 << (b & 0x1f));
280}
281
282static __inline int
283find_first_zero_bit(volatile void *p, int max)
284{
285 int b;
286
287 for (b = 0; b < max; b += 32) {
288 if (((volatile int *)p)[b >> 5] != ~0) {
289 for (;;) {
290 if ((((volatile int *)p)[b >> 5] & (1 << (b & 0x1f))) == 0)
291 return b;
292 b++;
293 }
294 }
295 }
296 return max;
297}
298
299#define spldrm() spltty()
300
301#define memset(p, v, s) bzero(p, s)
302
303/*
304 * Fake out the module macros for versions of FreeBSD where they don't
305 * exist.
306 */
4637ddfb 307#if defined(__FreeBSD__) && ((__FreeBSD_version < 500002 && __FreeBSD_version > 500000) || __FreeBSD_version < 420000)
984263bc
MD
308#define MODULE_VERSION(a,b) struct __hack
309#define MODULE_DEPEND(a,b,c,d,e) struct __hack
310#endif
311
312/* Redefinitions to make templating easy */
313#define wait_queue_head_t atomic_t
314#define agp_memory void
315#define jiffies ticks
316
e3869ec7 317 /* Macros to make kprintf easier */
984263bc 318#define DRM_ERROR(fmt, arg...) \
e3869ec7 319 kprintf("error: " "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ## arg)
984263bc 320#define DRM_MEM_ERROR(area, fmt, arg...) \
e3869ec7 321 kprintf("error: " "[" DRM_NAME ":%s:%s] *ERROR* " fmt , \
984263bc 322 __func__, DRM(mem_stats)[area].name , ##arg)
e3869ec7 323#define DRM_INFO(fmt, arg...) kprintf("info: " "[" DRM_NAME "] " fmt , ## arg)
984263bc
MD
324
325#if DRM_DEBUG_CODE
326#define DRM_DEBUG(fmt, arg...) \
327 do { \
328 if (DRM(flags) & DRM_FLAG_DEBUG) \
e3869ec7 329 kprintf("[" DRM_NAME ":%s] " fmt , __func__ , ## arg); \
984263bc
MD
330 } while (0)
331#else
332#define DRM_DEBUG(fmt, arg...) do { } while (0)
333#endif
334
b49909da
EN
335#if (__FreeBSD_version >= 500000) || \
336 ((__FreeBSD_version < 500000) && (__FreeBSD_version >= 410002)) || \
337 defined(__DragonFly__)
984263bc
MD
338#define DRM_SYSCTL_HANDLER_ARGS (SYSCTL_HANDLER_ARGS)
339#else
340#define DRM_SYSCTL_HANDLER_ARGS SYSCTL_HANDLER_ARGS
341#endif
342
343#define DRM_SYSCTL_PRINT(fmt, arg...) \
f8c7a42d 344 ksnprintf(buf, sizeof(buf), fmt, ##arg); \
984263bc
MD
345 error = SYSCTL_OUT(req, buf, strlen(buf)); \
346 if (error) return error;
347
348#define DRM_SYSCTL_PRINT_RET(ret, fmt, arg...) \
f8c7a42d 349 ksnprintf(buf, sizeof(buf), fmt, ##arg); \
984263bc
MD
350 error = SYSCTL_OUT(req, buf, strlen(buf)); \
351 if (error) { ret; return error; }
352
353
354#define DRM_FIND_MAP(dest, o) \
355 do { \
356 drm_map_list_entry_t *listentry; \
357 TAILQ_FOREACH(listentry, dev->maplist, link) { \
358 if ( listentry->map->offset == o ) { \
359 dest = listentry->map; \
360 break; \
361 } \
362 } \
363 } while (0)
364
365
366/* Internal functions */
367
368/* drm_drv.h */
369extern d_ioctl_t DRM(ioctl);
370extern d_open_t DRM(open);
371extern d_close_t DRM(close);
372extern d_read_t DRM(read);
373extern d_poll_t DRM(poll);
374extern d_mmap_t DRM(mmap);
b13267a5 375extern int DRM(open_helper)(cdev_t kdev, int flags, int fmt,
984263bc
MD
376 DRM_STRUCTPROC *p, drm_device_t *dev);
377extern drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev,
378 DRM_STRUCTPROC *p);
379
380/* sysctl support (drm_sysctl.h) */
381extern int DRM(sysctl_init)(drm_device_t *dev);
382extern int DRM(sysctl_cleanup)(drm_device_t *dev);
383
384/* Memory info sysctl (drm_memory.h) */
385extern int DRM(mem_info) DRM_SYSCTL_HANDLER_ARGS;