Deleted Added
sdiff udiff text old ( 277487 ) new ( 280183 )
full compact
drmP.h (277487) drmP.h (280183)
1/**
2 * \file drmP.h
3 * Private header for Direct Rendering Manager
4 *
5 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 * \author Gareth Hughes <gareth@valinux.com>
7 */
8

--- 19 unchanged lines hidden (view full) ---

28 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
29 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
30 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
31 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
32 * OTHER DEALINGS IN THE SOFTWARE.
33 */
34
35#include <sys/cdefs.h>
1/**
2 * \file drmP.h
3 * Private header for Direct Rendering Manager
4 *
5 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 * \author Gareth Hughes <gareth@valinux.com>
7 */
8

--- 19 unchanged lines hidden (view full) ---

28 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
29 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
30 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
31 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
32 * OTHER DEALINGS IN THE SOFTWARE.
33 */
34
35#include <sys/cdefs.h>
36__FBSDID("$FreeBSD: head/sys/dev/drm2/drmP.h 277487 2015-01-21 16:10:37Z kib $");
36__FBSDID("$FreeBSD: head/sys/dev/drm2/drmP.h 280183 2015-03-17 18:50:33Z dumbbell $");
37
38#ifndef _DRM_P_H_
39#define _DRM_P_H_
40
41#if defined(_KERNEL) || defined(__KERNEL__)
42
43#include <sys/param.h>
44#include <sys/queue.h>

--- 50 unchanged lines hidden (view full) ---

95#include <dev/pci/pcireg.h>
96#include <sys/selinfo.h>
97#include <sys/bus.h>
98
99#include <dev/drm2/drm.h>
100#include <dev/drm2/drm_sarea.h>
101
102#include <dev/drm2/drm_atomic.h>
37
38#ifndef _DRM_P_H_
39#define _DRM_P_H_
40
41#if defined(_KERNEL) || defined(__KERNEL__)
42
43#include <sys/param.h>
44#include <sys/queue.h>

--- 50 unchanged lines hidden (view full) ---

95#include <dev/pci/pcireg.h>
96#include <sys/selinfo.h>
97#include <sys/bus.h>
98
99#include <dev/drm2/drm.h>
100#include <dev/drm2/drm_sarea.h>
101
102#include <dev/drm2/drm_atomic.h>
103#include <dev/drm2/drm_internal.h>
104#include <dev/drm2/drm_linux_list.h>
105#include <dev/drm2/drm_gem_names.h>
106
103#include <dev/drm2/drm_linux_list.h>
104#include <dev/drm2/drm_gem_names.h>
105
106#include <dev/drm2/drm_os_freebsd.h>
107
108#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
109#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
110
107struct drm_file;
108struct drm_device;
109
111struct drm_file;
112struct drm_device;
113
110#include <dev/drm2/drm_os_freebsd.h>
111#include <dev/drm2/drm_hashtab.h>
112#include <dev/drm2/drm_mm.h>
113
114#include "opt_compat.h"
115#include "opt_drm.h"
116#include "opt_syscons.h"
117#ifdef DRM_DEBUG
118#undef DRM_DEBUG

--- 22 unchanged lines hidden (view full) ---

141#define DRIVER_IRQ_SHARED 0x80
142#define DRIVER_IRQ_VBL 0x100
143#define DRIVER_DMA_QUEUE 0x200
144#define DRIVER_FB_DMA 0x400
145#define DRIVER_IRQ_VBL2 0x800
146#define DRIVER_GEM 0x1000
147#define DRIVER_MODESET 0x2000
148#define DRIVER_PRIME 0x4000
114#include <dev/drm2/drm_hashtab.h>
115#include <dev/drm2/drm_mm.h>
116
117#include "opt_compat.h"
118#include "opt_drm.h"
119#include "opt_syscons.h"
120#ifdef DRM_DEBUG
121#undef DRM_DEBUG

--- 22 unchanged lines hidden (view full) ---

144#define DRIVER_IRQ_SHARED 0x80
145#define DRIVER_IRQ_VBL 0x100
146#define DRIVER_DMA_QUEUE 0x200
147#define DRIVER_FB_DMA 0x400
148#define DRIVER_IRQ_VBL2 0x800
149#define DRIVER_GEM 0x1000
150#define DRIVER_MODESET 0x2000
151#define DRIVER_PRIME 0x4000
149#define DRIVER_LOCKLESS_IRQ 0x8000
150
152
153#define DRIVER_BUS_PCI 0x1
154#define DRIVER_BUS_PLATFORM 0x2
155#define DRIVER_BUS_USB 0x3
151
156
152#define DRM_HASH_SIZE 16 /* Size of key hash table */
153#define DRM_KERNEL_CONTEXT 0 /* Change drm_resctx if changed */
154#define DRM_RESERVED_CONTEXTS 1 /* Change drm_resctx if changed */
157/***********************************************************************/
158/** \name Begin the DRM... */
159/*@{*/
155
160
156#define DRM_GEM_MAPPING_MASK (3ULL << 62)
157#define DRM_GEM_MAPPING_KEY (2ULL << 62) /* Non-canonical address form */
158#define DRM_GEM_MAX_IDX 0x3fffff
159#define DRM_GEM_MAPPING_IDX(o) (((o) >> 40) & DRM_GEM_MAX_IDX)
160#define DRM_GEM_MAPPING_OFF(i) (((uint64_t)(i)) << 40)
161#define DRM_GEM_MAPPING_MAPOFF(o) \
162 ((o) & ~(DRM_GEM_MAPPING_OFF(DRM_GEM_MAX_IDX) | DRM_GEM_MAPPING_KEY))
161#define DRM_DEBUG_CODE 2 /**< Include debugging code if > 1, then
162 also include looping detection. */
163
163
164MALLOC_DECLARE(DRM_MEM_DMA);
165MALLOC_DECLARE(DRM_MEM_SAREA);
166MALLOC_DECLARE(DRM_MEM_DRIVER);
167MALLOC_DECLARE(DRM_MEM_MAGIC);
168MALLOC_DECLARE(DRM_MEM_IOCTLS);
169MALLOC_DECLARE(DRM_MEM_MAPS);
170MALLOC_DECLARE(DRM_MEM_BUFS);
171MALLOC_DECLARE(DRM_MEM_SEGS);
172MALLOC_DECLARE(DRM_MEM_PAGES);
173MALLOC_DECLARE(DRM_MEM_FILES);
174MALLOC_DECLARE(DRM_MEM_QUEUES);
175MALLOC_DECLARE(DRM_MEM_CMDS);
176MALLOC_DECLARE(DRM_MEM_MAPPINGS);
177MALLOC_DECLARE(DRM_MEM_BUFLISTS);
178MALLOC_DECLARE(DRM_MEM_AGPLISTS);
179MALLOC_DECLARE(DRM_MEM_CTXBITMAP);
180MALLOC_DECLARE(DRM_MEM_SGLISTS);
181MALLOC_DECLARE(DRM_MEM_DRAWABLE);
182MALLOC_DECLARE(DRM_MEM_MM);
183MALLOC_DECLARE(DRM_MEM_HASHTAB);
184MALLOC_DECLARE(DRM_MEM_KMS);
164#define DRM_MAGIC_HASH_ORDER 4 /**< Size of key hash table. Must be power of 2. */
165#define DRM_KERNEL_CONTEXT 0 /**< Change drm_resctx if changed */
166#define DRM_RESERVED_CONTEXTS 1 /**< Change drm_resctx if changed */
167#define DRM_LOOPING_LIMIT 5000000
168#define DRM_TIME_SLICE (HZ/20) /**< Time slice for GLXContexts */
169#define DRM_LOCK_SLICE 1 /**< Time slice for lock, in jiffies */
185
170
186SYSCTL_DECL(_hw_drm);
171#define DRM_FLAG_DEBUG 0x01
187
188#define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
172
173#define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
174#define DRM_MAP_HASH_OFFSET 0x10000000
189
175
176/*@}*/
177
190/***********************************************************************/
178/***********************************************************************/
191/** \name Internal types and structures */
179/** \name Macros to make printk easier */
192/*@{*/
193
180/*@{*/
181
194#define DRM_ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
195#define DRM_MIN(a,b) ((a)<(b)?(a):(b))
196#define DRM_MAX(a,b) ((a)>(b)?(a):(b))
197
198#define DRM_IF_VERSION(maj, min) (maj << 16 | min)
199
200#define __OS_HAS_AGP 1
201
202#define DRM_DEV_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
203#define DRM_DEV_UID 0
204#define DRM_DEV_GID 0
205
206#define wait_queue_head_t atomic_t
207#define DRM_WAKEUP(w) wakeup((void *)w)
208#define DRM_WAKEUP_INT(w) wakeup(w)
209#define DRM_INIT_WAITQUEUE(queue) do {(void)(queue);} while (0)
210
211#define DRM_CURPROC curthread
212#define DRM_STRUCTPROC struct thread
213#define DRM_SPINTYPE struct mtx
214#define DRM_SPININIT(l,name) mtx_init(l, name, NULL, MTX_DEF)
215#define DRM_SPINUNINIT(l) mtx_destroy(l)
216#define DRM_SPINLOCK(l) mtx_lock(l)
217#define DRM_SPINUNLOCK(u) mtx_unlock(u)
218#define DRM_SPINLOCK_IRQSAVE(l, irqflags) do { \
219 mtx_lock(l); \
220 (void)irqflags; \
221} while (0)
222#define DRM_SPINUNLOCK_IRQRESTORE(u, irqflags) mtx_unlock(u)
223#define DRM_SPINLOCK_ASSERT(l) mtx_assert(l, MA_OWNED)
224#define DRM_CURRENTPID curthread->td_proc->p_pid
225#define DRM_LOCK(dev) sx_xlock(&(dev)->dev_struct_lock)
226#define DRM_UNLOCK(dev) sx_xunlock(&(dev)->dev_struct_lock)
227#define DRM_LOCK_SLEEP(dev, chan, flags, msg, timeout) \
228 (sx_sleep((chan), &(dev)->dev_struct_lock, (flags), (msg), (timeout)))
229#if defined(INVARIANTS)
230#define DRM_LOCK_ASSERT(dev) sx_assert(&(dev)->dev_struct_lock, SA_XLOCKED)
231#define DRM_UNLOCK_ASSERT(dev) sx_assert(&(dev)->dev_struct_lock, SA_UNLOCKED)
232#else
233#define DRM_LOCK_ASSERT(d)
234#define DRM_UNLOCK_ASSERT(d)
235#endif
236
237#define DRM_SYSCTL_HANDLER_ARGS (SYSCTL_HANDLER_ARGS)
238
239#define DRM_IRQ_ARGS void *arg
240typedef void irqreturn_t;
241#define IRQ_HANDLED /* nothing */
242#define IRQ_NONE /* nothing */
243
244enum {
245 DRM_IS_NOT_AGP,
246 DRM_IS_AGP,
247 DRM_MIGHT_BE_AGP
248};
249#define DRM_AGP_MEM struct agp_memory_info
250
251#define drm_get_device_from_kdev(_kdev) (_kdev->si_drv1)
252
253#define PAGE_ALIGN(addr) round_page(addr)
254/* DRM_SUSER returns true if the user is superuser */
255#define DRM_SUSER(p) (priv_check(p, PRIV_DRIVER) == 0)
256#define DRM_AGP_FIND_DEVICE() agp_find_device()
257#define DRM_MTRR_WC MDF_WRITECOMBINE
258#define jiffies ticks
259#define jiffies_to_msecs(x) (((int64_t)(x)) * 1000 / hz)
260#define msecs_to_jiffies(x) (((int64_t)(x)) * hz / 1000)
261#define time_after(a,b) ((long)(b) - (long)(a) < 0)
262#define time_after_eq(a,b) ((long)(b) - (long)(a) <= 0)
263#define drm_msleep(x, msg) pause((msg), ((int64_t)(x)) * hz / 1000)
264
265/* DRM_READMEMORYBARRIER() prevents reordering of reads.
266 * DRM_WRITEMEMORYBARRIER() prevents reordering of writes.
267 * DRM_MEMORYBARRIER() prevents reordering of reads and writes.
182/**
183 * Error output.
184 *
185 * \param fmt printf() like format string.
186 * \param arg arguments
268 */
187 */
269#define DRM_READMEMORYBARRIER() rmb()
270#define DRM_WRITEMEMORYBARRIER() wmb()
271#define DRM_MEMORYBARRIER() mb()
272
273#define DRM_READ8(map, offset) \
274 *(volatile u_int8_t *)(((vm_offset_t)(map)->virtual) + \
275 (vm_offset_t)(offset))
276#define DRM_READ16(map, offset) \
277 le16toh(*(volatile u_int16_t *)(((vm_offset_t)(map)->virtual) + \
278 (vm_offset_t)(offset)))
279#define DRM_READ32(map, offset) \
280 le32toh(*(volatile u_int32_t *)(((vm_offset_t)(map)->virtual) + \
281 (vm_offset_t)(offset)))
282#define DRM_READ64(map, offset) \
283 le64toh(*(volatile u_int64_t *)(((vm_offset_t)(map)->virtual) + \
284 (vm_offset_t)(offset)))
285#define DRM_WRITE8(map, offset, val) \
286 *(volatile u_int8_t *)(((vm_offset_t)(map)->virtual) + \
287 (vm_offset_t)(offset)) = val
288#define DRM_WRITE16(map, offset, val) \
289 *(volatile u_int16_t *)(((vm_offset_t)(map)->virtual) + \
290 (vm_offset_t)(offset)) = htole16(val)
291#define DRM_WRITE32(map, offset, val) \
292 *(volatile u_int32_t *)(((vm_offset_t)(map)->virtual) + \
293 (vm_offset_t)(offset)) = htole32(val)
294#define DRM_WRITE64(map, offset, val) \
295 *(volatile u_int64_t *)(((vm_offset_t)(map)->virtual) + \
296 (vm_offset_t)(offset)) = htole64(val)
297
298#define DRM_VERIFYAREA_READ( uaddr, size ) \
299 (!useracc(__DECONST(caddr_t, uaddr), size, VM_PROT_READ))
300
301#define DRM_COPY_TO_USER(user, kern, size) \
302 copyout(kern, user, size)
303#define DRM_COPY_FROM_USER(kern, user, size) \
304 copyin(user, kern, size)
305#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
306 copyin(arg2, arg1, arg3)
307#define DRM_COPY_TO_USER_UNCHECKED(arg1, arg2, arg3) \
308 copyout(arg2, arg1, arg3)
309#define DRM_GET_USER_UNCHECKED(val, uaddr) \
310 ((val) = fuword32(uaddr), 0)
311
312#define DRM_GET_PRIV_SAREA(_dev, _ctx, _map) do { \
313 (_map) = (_dev)->context_sareas[_ctx]; \
314} while(0)
315
316#define LOCK_TEST_WITH_RETURN(dev, file_priv) \
317do { \
318 if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock) || \
319 dev->lock.file_priv != file_priv) { \
320 DRM_ERROR("%s called without lock held\n", \
321 __FUNCTION__); \
322 return EINVAL; \
323 } \
324} while (0)
325
326/* Returns -errno to shared code */
327#define DRM_WAIT_ON( ret, queue, timeout, condition ) \
328for ( ret = 0 ; !ret && !(condition) ; ) { \
329 DRM_UNLOCK(dev); \
330 mtx_lock(&dev->irq_lock); \
331 if (!(condition)) \
332 ret = -mtx_sleep(&(queue), &dev->irq_lock, \
333 PCATCH, "drmwtq", (timeout)); \
334 mtx_unlock(&dev->irq_lock); \
335 DRM_LOCK(dev); \
336}
337
338#define DRM_ERROR(fmt, ...) \
339 printf("error: [" DRM_NAME ":pid%d:%s] *ERROR* " fmt, \
340 DRM_CURRENTPID, __func__ , ##__VA_ARGS__)
341
188#define DRM_ERROR(fmt, ...) \
189 printf("error: [" DRM_NAME ":pid%d:%s] *ERROR* " fmt, \
190 DRM_CURRENTPID, __func__ , ##__VA_ARGS__)
191
192#define DRM_WARNING(fmt, ...) printf("warning: [" DRM_NAME "] " fmt , ##__VA_ARGS__)
342#define DRM_INFO(fmt, ...) printf("info: [" DRM_NAME "] " fmt , ##__VA_ARGS__)
343
193#define DRM_INFO(fmt, ...) printf("info: [" DRM_NAME "] " fmt , ##__VA_ARGS__)
194
195/**
196 * Debug output.
197 *
198 * \param fmt printf() like format string.
199 * \param arg arguments
200 */
344#define DRM_DEBUG(fmt, ...) do { \
201#define DRM_DEBUG(fmt, ...) do { \
345 if ((drm_debug_flag & DRM_DEBUGBITS_DEBUG) != 0) \
202 if ((drm_debug & DRM_DEBUGBITS_DEBUG) != 0) \
346 printf("[" DRM_NAME ":pid%d:%s] " fmt, DRM_CURRENTPID, \
347 __func__ , ##__VA_ARGS__); \
348} while (0)
349
350#define DRM_DEBUG_KMS(fmt, ...) do { \
203 printf("[" DRM_NAME ":pid%d:%s] " fmt, DRM_CURRENTPID, \
204 __func__ , ##__VA_ARGS__); \
205} while (0)
206
207#define DRM_DEBUG_KMS(fmt, ...) do { \
351 if ((drm_debug_flag & DRM_DEBUGBITS_KMS) != 0) \
208 if ((drm_debug & DRM_DEBUGBITS_KMS) != 0) \
352 printf("[" DRM_NAME ":KMS:pid%d:%s] " fmt, DRM_CURRENTPID,\
353 __func__ , ##__VA_ARGS__); \
354} while (0)
355
356#define DRM_DEBUG_DRIVER(fmt, ...) do { \
209 printf("[" DRM_NAME ":KMS:pid%d:%s] " fmt, DRM_CURRENTPID,\
210 __func__ , ##__VA_ARGS__); \
211} while (0)
212
213#define DRM_DEBUG_DRIVER(fmt, ...) do { \
357 if ((drm_debug_flag & DRM_DEBUGBITS_KMS) != 0) \
214 if ((drm_debug & DRM_DEBUGBITS_KMS) != 0) \
358 printf("[" DRM_NAME ":KMS:pid%d:%s] " fmt, DRM_CURRENTPID,\
359 __func__ , ##__VA_ARGS__); \
360} while (0)
361
215 printf("[" DRM_NAME ":KMS:pid%d:%s] " fmt, DRM_CURRENTPID,\
216 __func__ , ##__VA_ARGS__); \
217} while (0)
218
362#define dev_err(dev, fmt, ...) \
363 device_printf((dev), "error: " fmt, ## __VA_ARGS__)
364#define dev_warn(dev, fmt, ...) \
365 device_printf((dev), "warning: " fmt, ## __VA_ARGS__)
366#define dev_info(dev, fmt, ...) \
367 device_printf((dev), "info: " fmt, ## __VA_ARGS__)
368#define dev_dbg(dev, fmt, ...) do { \
369 if ((drm_debug_flag& DRM_DEBUGBITS_KMS) != 0) { \
370 device_printf((dev), "debug: " fmt, ## __VA_ARGS__); \
371 } \
219/*@}*/
220
221/***********************************************************************/
222/** \name Internal types and structures */
223/*@{*/
224
225#define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x)
226
227#define DRM_LEFTCOUNT(x) (((x)->rp + (x)->count - (x)->wp) % ((x)->count + 1))
228#define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x))
229
230#define DRM_IF_VERSION(maj, min) (maj << 16 | min)
231
232/**
233 * Test that the hardware lock is held by the caller, returning otherwise.
234 *
235 * \param dev DRM device.
236 * \param filp file pointer of the caller.
237 */
238#define LOCK_TEST_WITH_RETURN( dev, _file_priv ) \
239do { \
240 if (!_DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock) || \
241 _file_priv->master->lock.file_priv != _file_priv) { \
242 DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\
243 __func__, _DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock),\
244 _file_priv->master->lock.file_priv, _file_priv); \
245 return -EINVAL; \
246 } \
372} while (0)
373
247} while (0)
248
374typedef struct drm_pci_id_list
375{
376 int vendor;
377 int device;
378 long driver_private;
379 char *name;
380} drm_pci_id_list_t;
249/**
250 * Ioctl function type.
251 *
252 * \param inode device inode.
253 * \param file_priv DRM file private pointer.
254 * \param cmd command.
255 * \param arg argument.
256 */
257typedef int drm_ioctl_t(struct drm_device *dev, void *data,
258 struct drm_file *file_priv);
381
259
382struct drm_msi_blacklist_entry
383{
384 int vendor;
385 int device;
386};
260#define DRM_IOCTL_NR(n) ((n) & 0xff)
261#define DRM_MAJOR 226
387
388#define DRM_AUTH 0x1
389#define DRM_MASTER 0x2
390#define DRM_ROOT_ONLY 0x4
391#define DRM_CONTROL_ALLOW 0x8
392#define DRM_UNLOCKED 0x10
393
262
263#define DRM_AUTH 0x1
264#define DRM_MASTER 0x2
265#define DRM_ROOT_ONLY 0x4
266#define DRM_CONTROL_ALLOW 0x8
267#define DRM_UNLOCKED 0x10
268
394typedef struct drm_ioctl_desc {
269struct drm_ioctl_desc {
395 unsigned long cmd;
270 unsigned long cmd;
396 int (*func)(struct drm_device *dev, void *data,
397 struct drm_file *file_priv);
398 int flags;
271 int flags;
272 drm_ioctl_t *func;
399 unsigned int cmd_drv;
273 unsigned int cmd_drv;
400} drm_ioctl_desc_t;
274};
401
402/**
403 * Creates a driver or general drm_ioctl_desc array entry for the given
404 * ioctl, for use by drm_ioctl().
405 */
275
276/**
277 * Creates a driver or general drm_ioctl_desc array entry for the given
278 * ioctl, for use by drm_ioctl().
279 */
406#define DRM_IOCTL_DEF(ioctl, func, flags) \
407 [DRM_IOCTL_NR(ioctl)] = {ioctl, func, flags}
408
280
281#define DRM_IOCTL_DEF(ioctl, _func, _flags) \
282 [DRM_IOCTL_NR(ioctl)] = {.cmd = ioctl, .func = _func, .flags = _flags, .cmd_drv = 0}
283
409#define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags) \
410 [DRM_IOCTL_NR(DRM_##ioctl)] = {.cmd = DRM_##ioctl, .func = _func, .flags = _flags, .cmd_drv = DRM_IOCTL_##ioctl}
411
284#define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags) \
285 [DRM_IOCTL_NR(DRM_##ioctl)] = {.cmd = DRM_##ioctl, .func = _func, .flags = _flags, .cmd_drv = DRM_IOCTL_##ioctl}
286
412typedef struct drm_magic_entry {
413 drm_magic_t magic;
414 struct drm_file *priv;
415 struct drm_magic_entry *next;
416} drm_magic_entry_t;
287struct drm_magic_entry {
288 struct list_head head;
289 struct drm_hash_item hash_item;
290 struct drm_file *priv;
291};
417
292
418typedef struct drm_magic_head {
419 struct drm_magic_entry *head;
420 struct drm_magic_entry *tail;
421} drm_magic_head_t;
422
423typedef struct drm_buf {
293/**
294 * DMA buffer.
295 */
296struct drm_buf {
424 int idx; /**< Index into master buflist */
425 int total; /**< Buffer size */
426 int order; /**< log-base-2(total) */
427 int used; /**< Amount of buffer in use (for DMA) */
428 unsigned long offset; /**< Byte offset (used internally) */
429 void *address; /**< Address of buffer */
430 unsigned long bus_address; /**< Bus address of buffer */
431 struct drm_buf *next; /**< Kernel-only: used for free list */

--- 8 unchanged lines hidden (view full) ---

440 DRM_LIST_WAIT = 2,
441 DRM_LIST_PEND = 3,
442 DRM_LIST_PRIO = 4,
443 DRM_LIST_RECLAIM = 5
444 } list; /**< Which list we're on */
445
446 int dev_priv_size; /**< Size of buffer private storage */
447 void *dev_private; /**< Per-buffer private storage */
297 int idx; /**< Index into master buflist */
298 int total; /**< Buffer size */
299 int order; /**< log-base-2(total) */
300 int used; /**< Amount of buffer in use (for DMA) */
301 unsigned long offset; /**< Byte offset (used internally) */
302 void *address; /**< Address of buffer */
303 unsigned long bus_address; /**< Bus address of buffer */
304 struct drm_buf *next; /**< Kernel-only: used for free list */

--- 8 unchanged lines hidden (view full) ---

313 DRM_LIST_WAIT = 2,
314 DRM_LIST_PEND = 3,
315 DRM_LIST_PRIO = 4,
316 DRM_LIST_RECLAIM = 5
317 } list; /**< Which list we're on */
318
319 int dev_priv_size; /**< Size of buffer private storage */
320 void *dev_private; /**< Per-buffer private storage */
448} drm_buf_t;
321};
449
322
450typedef struct drm_freelist {
451 int initialized; /* Freelist in use */
452 atomic_t count; /* Number of free buffers */
453 drm_buf_t *next; /* End pointer */
323struct drm_freelist {
324 int initialized; /**< Freelist in use */
325 atomic_t count; /**< Number of free buffers */
326 struct drm_buf *next; /**< End pointer */
454
327
455 int low_mark; /* Low water mark */
456 int high_mark; /* High water mark */
457} drm_freelist_t;
328#ifdef FREEBSD_NOTYET
329 wait_queue_head_t waiting; /**< Processes waiting on free bufs */
330#endif /* defined(FREEBSD_NOTYET) */
331 int low_mark; /**< Low water mark */
332 int high_mark; /**< High water mark */
333#ifdef FREEBSD_NOTYET
334 atomic_t wfh; /**< If waiting for high mark */
335 spinlock_t lock;
336#endif /* defined(FREEBSD_NOTYET) */
337};
458
459typedef struct drm_dma_handle {
460 void *vaddr;
461 bus_addr_t busaddr;
462 bus_dma_tag_t tag;
463 bus_dmamap_t map;
464} drm_dma_handle_t;
465
338
339typedef struct drm_dma_handle {
340 void *vaddr;
341 bus_addr_t busaddr;
342 bus_dma_tag_t tag;
343 bus_dmamap_t map;
344} drm_dma_handle_t;
345
466typedef struct drm_buf_entry {
467 int buf_size;
468 int buf_count;
469 drm_buf_t *buflist;
470 int seg_count;
471 drm_dma_handle_t **seglist;
472 int page_order;
346/**
347 * Buffer entry. There is one of this for each buffer size order.
348 */
349struct drm_buf_entry {
350 int buf_size; /**< size */
351 int buf_count; /**< number of buffers */
352 struct drm_buf *buflist; /**< buffer list */
353 int seg_count;
354 int page_order;
355 struct drm_dma_handle **seglist;
473
356
474 drm_freelist_t freelist;
475} drm_buf_entry_t;
357 struct drm_freelist freelist;
358};
476
477/* Event queued up for userspace to read */
478struct drm_pending_event {
479 struct drm_event *event;
480 struct list_head link;
481 struct drm_file *file_priv;
482 pid_t pid; /* pid of requester, no guarantee it's valid by the time
483 we deliver the event, for tracing only */
484 void (*destroy)(struct drm_pending_event *event);
485};
486
487/* initial implementaton using a linked list - todo hashtab */
488struct drm_prime_file_private {
489 struct list_head head;
359
360/* Event queued up for userspace to read */
361struct drm_pending_event {
362 struct drm_event *event;
363 struct list_head link;
364 struct drm_file *file_priv;
365 pid_t pid; /* pid of requester, no guarantee it's valid by the time
366 we deliver the event, for tracing only */
367 void (*destroy)(struct drm_pending_event *event);
368};
369
370/* initial implementaton using a linked list - todo hashtab */
371struct drm_prime_file_private {
372 struct list_head head;
490#ifdef DUMBBELL_WIP
491 struct mutex lock;
492#endif /* DUMBBELL_WIP */
373 struct mtx lock;
493};
494
374};
375
495typedef TAILQ_HEAD(drm_file_list, drm_file) drm_file_list_t;
496struct drm_file {
376struct drm_file {
497 TAILQ_ENTRY(drm_file) link;
498 struct drm_device *dev;
499 int authenticated;
500 int master;
501 pid_t pid;
502 uid_t uid;
503 drm_magic_t magic;
504 unsigned long ioctl_count;
377 int authenticated;
378 pid_t pid;
379 uid_t uid;
380 drm_magic_t magic;
381 unsigned long ioctl_count;
382 struct list_head lhead;
383 struct drm_minor *minor;
384 unsigned long lock_count;
505
385
506 void *driver_priv;
386 void *driver_priv;
507 struct drm_gem_names object_names;
508
387 struct drm_gem_names object_names;
388
509 int is_master;
510 struct drm_master *masterp;
389 int is_master; /* this file private is a master for a minor */
390 struct drm_master *master; /* master this node is currently associated with
391 N.B. not always minor->master */
392 struct list_head fbs;
511
393
512 struct list_head fbs;
394 struct selinfo event_poll;
395 struct list_head event_list;
396 int event_space;
513
397
514 struct list_head event_list;
515 int event_space;
516 struct selinfo event_poll;
517
518 struct drm_prime_file_private prime;
519};
520
398 struct drm_prime_file_private prime;
399};
400
521typedef struct drm_lock_data {
522 struct drm_hw_lock *hw_lock; /* Hardware lock */
523 struct drm_file *file_priv; /* Unique identifier of holding process (NULL is kernel)*/
524 int lock_queue; /* Queue of blocked processes */
525 unsigned long lock_time; /* Time of last lock in jiffies */
526} drm_lock_data_t;
401/**
402 * Lock data.
403 */
404struct drm_lock_data {
405 struct drm_hw_lock *hw_lock; /**< Hardware lock */
406 /** Private of lock holder's file (NULL=kernel) */
407 struct drm_file *file_priv;
408 wait_queue_head_t lock_queue; /**< Queue of blocked processes */
409 unsigned long lock_time; /**< Time of last lock in jiffies */
410 struct mtx spinlock;
411 uint32_t kernel_waiters;
412 uint32_t user_waiters;
413 int idle_has_lock;
414};
527
415
528/* This structure, in the struct drm_device, is always initialized while the
529 * device
530 * is open. dev->dma_lock protects the incrementing of dev->buf_use, which
531 * when set marks that no further bufs may be allocated until device teardown
532 * occurs (when the last open of the device has closed). The high/low
533 * watermarks of bufs are only touched by the X Server, and thus not
534 * concurrently accessed, so no locking is needed.
416/**
417 * DMA data.
535 */
418 */
536typedef struct drm_device_dma {
419struct drm_device_dma {
537
538 struct drm_buf_entry bufs[DRM_MAX_ORDER + 1]; /**< buffers, grouped by their size order */
539 int buf_count; /**< total number of buffers */
540 struct drm_buf **buflist; /**< Vector of pointers into drm_device_dma::bufs */
541 int seg_count;
542 int page_count; /**< number of pages */
543 unsigned long *pagelist; /**< page list */
544 unsigned long byte_count;
545 enum {
546 _DRM_DMA_USE_AGP = 0x01,
547 _DRM_DMA_USE_SG = 0x02,
548 _DRM_DMA_USE_FB = 0x04,
549 _DRM_DMA_USE_PCI_RO = 0x08
550 } flags;
551
420
421 struct drm_buf_entry bufs[DRM_MAX_ORDER + 1]; /**< buffers, grouped by their size order */
422 int buf_count; /**< total number of buffers */
423 struct drm_buf **buflist; /**< Vector of pointers into drm_device_dma::bufs */
424 int seg_count;
425 int page_count; /**< number of pages */
426 unsigned long *pagelist; /**< page list */
427 unsigned long byte_count;
428 enum {
429 _DRM_DMA_USE_AGP = 0x01,
430 _DRM_DMA_USE_SG = 0x02,
431 _DRM_DMA_USE_FB = 0x04,
432 _DRM_DMA_USE_PCI_RO = 0x08
433 } flags;
434
552} drm_device_dma_t;
435};
553
436
554typedef struct drm_agp_mem {
555 void *handle;
556 unsigned long bound; /* address */
557 int pages;
558 struct drm_agp_mem *prev;
559 struct drm_agp_mem *next;
560} drm_agp_mem_t;
437/**
438 * AGP memory entry. Stored as a doubly linked list.
439 */
440struct drm_agp_mem {
441 unsigned long handle; /**< handle */
442 DRM_AGP_MEM *memory;
443 unsigned long bound; /**< address */
444 int pages;
445 struct list_head head;
446};
561
447
562typedef struct drm_agp_head {
563 device_t agpdev;
564 struct agp_info info;
565 const char *chipset;
566 drm_agp_mem_t *memory;
567 unsigned long mode;
568 int enabled;
569 int acquired;
570 unsigned long base;
571 int mtrr;
572 int cant_use_aperture;
573 unsigned long page_mask;
574} drm_agp_head_t;
448/**
449 * AGP data.
450 *
451 * \sa drm_agp_init() and drm_device::agp.
452 */
453struct drm_agp_head {
454 DRM_AGP_KERN agp_info; /**< AGP device information */
455 struct list_head memory;
456 unsigned long mode; /**< AGP mode */
457 device_t bridge;
458 int enabled; /**< whether the AGP bus as been enabled */
459 int acquired; /**< whether the AGP device has been acquired */
460 unsigned long base;
461 int agp_mtrr;
462 int cant_use_aperture;
463};
575
464
576typedef struct drm_sg_mem {
465/**
466 * Scatter-gather memory.
467 */
468struct drm_sg_mem {
577 vm_offset_t vaddr;
578 vm_paddr_t *busaddr;
579 vm_pindex_t pages;
469 vm_offset_t vaddr;
470 vm_paddr_t *busaddr;
471 vm_pindex_t pages;
580} drm_sg_mem_t;
472};
581
473
474struct drm_sigdata {
475 int context;
476 struct drm_hw_lock *lock;
477};
478
479/**
480 * Kernel side of a mapping
481 */
582#define DRM_MAP_HANDLE_BITS (sizeof(void *) == 4 ? 4 : 24)
583#define DRM_MAP_HANDLE_SHIFT (sizeof(void *) * 8 - DRM_MAP_HANDLE_BITS)
482#define DRM_MAP_HANDLE_BITS (sizeof(void *) == 4 ? 4 : 24)
483#define DRM_MAP_HANDLE_SHIFT (sizeof(void *) * 8 - DRM_MAP_HANDLE_BITS)
584typedef TAILQ_HEAD(drm_map_list, drm_local_map) drm_map_list_t;
585
484
586typedef struct drm_local_map {
587 unsigned long offset; /* Physical address (0 for SAREA) */
588 unsigned long size; /* Physical size (bytes) */
589 enum drm_map_type type; /* Type of memory mapped */
590 enum drm_map_flags flags; /* Flags */
591 void *handle; /* User-space: "Handle" to pass to mmap */
592 /* Kernel-space: kernel-virtual address */
593 int mtrr; /* Boolean: MTRR used */
485struct drm_local_map {
486 resource_size_t offset; /**< Requested physical address (0 for SAREA)*/
487 unsigned long size; /**< Requested physical size (bytes) */
488 enum drm_map_type type; /**< Type of memory to map */
489 enum drm_map_flags flags; /**< Flags */
490 void *handle; /**< User-space: "Handle" to pass to mmap() */
491 /**< Kernel-space: kernel-virtual address */
492 int mtrr; /**< MTRR slot used */
493
594 /* Private data */
494 /* Private data */
595 int rid; /* PCI resource ID for bus_space */
596 void *virtual; /* Kernel-space: kernel-virtual address */
597 struct resource *bsr;
598 bus_space_tag_t bst;
599 bus_space_handle_t bsh;
600 drm_dma_handle_t *dmah;
495 drm_dma_handle_t *dmah;
601 TAILQ_ENTRY(drm_local_map) link;
602} drm_local_map_t;
496};
603
497
604struct drm_vblank_info {
605 wait_queue_head_t queue; /* vblank wait queue */
606 atomic_t count; /* number of VBLANK interrupts */
607 /* (driver must alloc the right number of counters) */
608 atomic_t refcount; /* number of users of vblank interrupts */
609 u32 last; /* protected by dev->vbl_lock, used */
610 /* for wraparound handling */
611 int enabled; /* so we don't call enable more than */
612 /* once per disable */
613 int inmodeset; /* Display driver is setting mode */
498typedef struct drm_local_map drm_local_map_t;
499
500/**
501 * Mappings list
502 */
503struct drm_map_list {
504 struct list_head head; /**< list head */
505 struct drm_hash_item hash;
506 struct drm_local_map *map; /**< mapping */
507 uint64_t user_token;
508 struct drm_master *master;
509 struct drm_mm_node *file_offset_node; /**< fake offset */
614};
615
510};
511
512/**
513 * Context handle list
514 */
515struct drm_ctx_list {
516 struct list_head head; /**< list head */
517 drm_context_t handle; /**< context handle */
518 struct drm_file *tag; /**< associated fd private data */
519};
520
616/* location of GART table */
617#define DRM_ATI_GART_MAIN 1
618#define DRM_ATI_GART_FB 2
619
620#define DRM_ATI_GART_PCI 1
621#define DRM_ATI_GART_PCIE 2
622#define DRM_ATI_GART_IGP 3
623
624struct drm_ati_pcigart_info {
625 int gart_table_location;
626 int gart_reg_if;
627 void *addr;
628 dma_addr_t bus_addr;
629 dma_addr_t table_mask;
521/* location of GART table */
522#define DRM_ATI_GART_MAIN 1
523#define DRM_ATI_GART_FB 2
524
525#define DRM_ATI_GART_PCI 1
526#define DRM_ATI_GART_PCIE 2
527#define DRM_ATI_GART_IGP 3
528
529struct drm_ati_pcigart_info {
530 int gart_table_location;
531 int gart_reg_if;
532 void *addr;
533 dma_addr_t bus_addr;
534 dma_addr_t table_mask;
630 dma_addr_t member_mask;
631 struct drm_dma_handle *table_handle;
535 struct drm_dma_handle *table_handle;
632 drm_local_map_t mapping;
536 struct drm_local_map mapping;
633 int table_size;
537 int table_size;
634 struct drm_dma_handle *dmah; /* handle for ATI PCIGART table */
538 struct drm_dma_handle *dmah; /* handle for ATI PCIGART table FIXME */
635};
636
539};
540
637typedef vm_paddr_t resource_size_t;
638
639/**
640 * GEM specific mm private for tracking GEM objects
641 */
642struct drm_gem_mm {
541/**
542 * GEM specific mm private for tracking GEM objects
543 */
544struct drm_gem_mm {
643 struct drm_open_hash offset_hash; /**< User token hash table for maps */
644 struct unrhdr *idxunr;
545 struct unrhdr *idxunr;
546 struct drm_open_hash offset_hash; /**< User token hash table for maps */
645};
646
547};
548
549/**
550 * This structure defines the drm_mm memory object, which will be used by the
551 * DRM for its buffer objects.
552 */
647struct drm_gem_object {
648 /** Reference count of this object */
649 u_int refcount;
650
651 /** Handle count of this object. Each handle also holds a reference */
553struct drm_gem_object {
554 /** Reference count of this object */
555 u_int refcount;
556
557 /** Handle count of this object. Each handle also holds a reference */
652 u_int handle_count; /* number of handles on this object */
558 atomic_t handle_count; /* number of handles on this object */
653
654 /** Related drm device */
655 struct drm_device *dev;
656
657 /** File representing the shmem storage: filp in Linux parlance */
658 vm_object_t vm_obj;
659
559
560 /** Related drm device */
561 struct drm_device *dev;
562
563 /** File representing the shmem storage: filp in Linux parlance */
564 vm_object_t vm_obj;
565
566 /* Mapping info for this object */
660 bool on_map;
661 struct drm_hash_item map_list;
662
663 /**
664 * Size of the object, in bytes. Immutable over the object's
665 * lifetime.
666 */
667 size_t size;

--- 19 unchanged lines hidden (view full) ---

687 * They will be transferred to the above values
688 * at the point that any cache flushing occurs
689 */
690 uint32_t pending_read_domains;
691 uint32_t pending_write_domain;
692
693 void *driver_private;
694
567 bool on_map;
568 struct drm_hash_item map_list;
569
570 /**
571 * Size of the object, in bytes. Immutable over the object's
572 * lifetime.
573 */
574 size_t size;

--- 19 unchanged lines hidden (view full) ---

594 * They will be transferred to the above values
595 * at the point that any cache flushing occurs
596 */
597 uint32_t pending_read_domains;
598 uint32_t pending_write_domain;
599
600 void *driver_private;
601
695#ifdef DUMBBELL_WIP
602#ifdef FREEBSD_NOTYET
696 /* dma buf exported from this GEM object */
697 struct dma_buf *export_dma_buf;
698
699 /* dma buf attachment backing this object */
700 struct dma_buf_attachment *import_attach;
603 /* dma buf exported from this GEM object */
604 struct dma_buf *export_dma_buf;
605
606 /* dma buf attachment backing this object */
607 struct dma_buf_attachment *import_attach;
701#endif /* DUMBBELL_WIP */
608#endif /* FREEBSD_NOTYET */
702};
703
609};
610
704#include "drm_crtc.h"
611#include <dev/drm2/drm_crtc.h>
705
706/* per-master structure */
707struct drm_master {
708
709 u_int refcount; /* refcount for this master */
710
711 struct list_head head; /**< each minor contains a list of masters */
712 struct drm_minor *minor; /**< link back to minor we are a master for */

--- 25 unchanged lines hidden (view full) ---

738#define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0)
739#define DRM_VBLANKTIME_INVBL (1 << 1)
740
741/* get_scanout_position() return flags */
742#define DRM_SCANOUTPOS_VALID (1 << 0)
743#define DRM_SCANOUTPOS_INVBL (1 << 1)
744#define DRM_SCANOUTPOS_ACCURATE (1 << 2)
745
612
613/* per-master structure */
614struct drm_master {
615
616 u_int refcount; /* refcount for this master */
617
618 struct list_head head; /**< each minor contains a list of masters */
619 struct drm_minor *minor; /**< link back to minor we are a master for */

--- 25 unchanged lines hidden (view full) ---

645#define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0)
646#define DRM_VBLANKTIME_INVBL (1 << 1)
647
648/* get_scanout_position() return flags */
649#define DRM_SCANOUTPOS_VALID (1 << 0)
650#define DRM_SCANOUTPOS_INVBL (1 << 1)
651#define DRM_SCANOUTPOS_ACCURATE (1 << 2)
652
746#ifndef DMA_BIT_MASK
747#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : (1ULL<<(n)) - 1)
748#endif
653struct drm_bus {
654 int bus_type;
655 int (*get_irq)(struct drm_device *dev);
656 void (*free_irq)(struct drm_device *dev);
657 const char *(*get_name)(struct drm_device *dev);
658 int (*set_busid)(struct drm_device *dev, struct drm_master *master);
659 int (*set_unique)(struct drm_device *dev, struct drm_master *master,
660 struct drm_unique *unique);
661 int (*irq_by_busid)(struct drm_device *dev, struct drm_irq_busid *p);
662 /* hooks that are for PCI */
663 int (*agp_init)(struct drm_device *dev);
749
664
750#define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
665};
751
666
752struct drm_driver_info {
753 int (*load)(struct drm_device *, unsigned long flags);
754 int (*use_msi)(struct drm_device *, unsigned long flags);
755 int (*firstopen)(struct drm_device *);
756 int (*open)(struct drm_device *, struct drm_file *);
757 void (*preclose)(struct drm_device *, struct drm_file *file_priv);
758 void (*postclose)(struct drm_device *, struct drm_file *);
759 void (*lastclose)(struct drm_device *);
760 int (*unload)(struct drm_device *);
761 void (*reclaim_buffers_locked)(struct drm_device *,
762 struct drm_file *file_priv);
763 int (*dma_ioctl)(struct drm_device *dev, void *data,
764 struct drm_file *file_priv);
765 void (*dma_ready)(struct drm_device *);
766 int (*dma_quiescent)(struct drm_device *);
767 int (*dma_flush_block_and_flush)(struct drm_device *, int context,
768 enum drm_lock_flags flags);
769 int (*dma_flush_unblock)(struct drm_device *, int context,
770 enum drm_lock_flags flags);
771 int (*context_ctor)(struct drm_device *dev, int context);
772 int (*context_dtor)(struct drm_device *dev, int context);
773 int (*kernel_context_switch)(struct drm_device *dev, int old,
774 int new);
775 int (*kernel_context_switch_unlock)(struct drm_device *dev);
776 void (*irq_preinstall)(struct drm_device *dev);
777 int (*irq_postinstall)(struct drm_device *dev);
778 void (*irq_uninstall)(struct drm_device *dev);
779 void (*irq_handler)(DRM_IRQ_ARGS);
667/**
668 * DRM driver structure. This structure represent the common code for
669 * a family of cards. There will one drm_device for each card present
670 * in this family
671 */
672struct drm_driver {
673 int (*load) (struct drm_device *, unsigned long flags);
674 int (*firstopen) (struct drm_device *);
675 int (*open) (struct drm_device *, struct drm_file *);
676 void (*preclose) (struct drm_device *, struct drm_file *file_priv);
677 void (*postclose) (struct drm_device *, struct drm_file *);
678 void (*lastclose) (struct drm_device *);
679 int (*unload) (struct drm_device *);
680 int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
681 int (*dma_quiescent) (struct drm_device *);
682 int (*context_dtor) (struct drm_device *dev, int context);
780
683
781 u32 (*get_vblank_counter)(struct drm_device *dev, int crtc);
782 int (*enable_vblank)(struct drm_device *dev, int crtc);
783 void (*disable_vblank)(struct drm_device *dev, int crtc);
784 int (*get_scanout_position)(struct drm_device *dev, int crtc,
785 int *vpos, int *hpos);
684 /**
685 * get_vblank_counter - get raw hardware vblank counter
686 * @dev: DRM device
687 * @crtc: counter to fetch
688 *
689 * Driver callback for fetching a raw hardware vblank counter for @crtc.
690 * If a device doesn't have a hardware counter, the driver can simply
691 * return the value of drm_vblank_count. The DRM core will account for
692 * missed vblank events while interrupts where disabled based on system
693 * timestamps.
694 *
695 * Wraparound handling and loss of events due to modesetting is dealt
696 * with in the DRM core code.
697 *
698 * RETURNS
699 * Raw vblank counter value.
700 */
701 u32 (*get_vblank_counter) (struct drm_device *dev, int crtc);
786
702
787 int (*get_vblank_timestamp)(struct drm_device *dev, int crtc,
788 int *max_error, struct timeval *vblank_time,
789 unsigned flags);
703 /**
704 * enable_vblank - enable vblank interrupt events
705 * @dev: DRM device
706 * @crtc: which irq to enable
707 *
708 * Enable vblank interrupts for @crtc. If the device doesn't have
709 * a hardware vblank counter, this routine should be a no-op, since
710 * interrupts will have to stay on to keep the count accurate.
711 *
712 * RETURNS
713 * Zero on success, appropriate errno if the given @crtc's vblank
714 * interrupt cannot be enabled.
715 */
716 int (*enable_vblank) (struct drm_device *dev, int crtc);
790
717
791 int (*gem_init_object)(struct drm_gem_object *obj);
792 void (*gem_free_object)(struct drm_gem_object *obj);
793 int (*gem_open_object)(struct drm_gem_object *, struct drm_file *);
794 void (*gem_close_object)(struct drm_gem_object *, struct drm_file *);
718 /**
719 * disable_vblank - disable vblank interrupt events
720 * @dev: DRM device
721 * @crtc: which irq to enable
722 *
723 * Disable vblank interrupts for @crtc. If the device doesn't have
724 * a hardware vblank counter, this routine should be a no-op, since
725 * interrupts will have to stay on to keep the count accurate.
726 */
727 void (*disable_vblank) (struct drm_device *dev, int crtc);
795
728
796 struct cdev_pager_ops *gem_pager_ops;
797
798 int (*dumb_create)(struct drm_file *file_priv,
799 struct drm_device *dev, struct drm_mode_create_dumb *args);
800 int (*dumb_map_offset)(struct drm_file *file_priv,
801 struct drm_device *dev, uint32_t handle, uint64_t *offset);
802 int (*dumb_destroy)(struct drm_file *file_priv,
803 struct drm_device *dev, uint32_t handle);
804
805 int (*sysctl_init)(struct drm_device *dev,
806 struct sysctl_ctx_list *ctx, struct sysctl_oid *top);
807 void (*sysctl_cleanup)(struct drm_device *dev);
808
809 drm_pci_id_list_t *id_entry; /* PCI ID, name, and chipset private */
810
811 /**
812 * Called by \c drm_device_is_agp. Typically used to determine if a
813 * card is really attached to AGP or not.
814 *
815 * \param dev DRM device handle
816 *
817 * \returns
818 * One of three values is returned depending on whether or not the
819 * card is absolutely \b not AGP (return of 0), absolutely \b is AGP
820 * (return of 1), or may or may not be AGP (return of 2).
821 */
729 /**
730 * Called by \c drm_device_is_agp. Typically used to determine if a
731 * card is really attached to AGP or not.
732 *
733 * \param dev DRM device handle
734 *
735 * \returns
736 * One of three values is returned depending on whether or not the
737 * card is absolutely \b not AGP (return of 0), absolutely \b is AGP
738 * (return of 1), or may or may not be AGP (return of 2).
739 */
822 int (*device_is_agp) (struct drm_device * dev);
740 int (*device_is_agp) (struct drm_device *dev);
823
741
824 drm_ioctl_desc_t *ioctls;
825#ifdef COMPAT_FREEBSD32
826 drm_ioctl_desc_t *compat_ioctls;
827 int *compat_ioctls_nr;
828#endif
829 int max_ioctl;
742 /**
743 * Called by vblank timestamping code.
744 *
745 * Return the current display scanout position from a crtc.
746 *
747 * \param dev DRM device.
748 * \param crtc Id of the crtc to query.
749 * \param *vpos Target location for current vertical scanout position.
750 * \param *hpos Target location for current horizontal scanout position.
751 *
752 * Returns vpos as a positive number while in active scanout area.
753 * Returns vpos as a negative number inside vblank, counting the number
754 * of scanlines to go until end of vblank, e.g., -1 means "one scanline
755 * until start of active scanout / end of vblank."
756 *
757 * \return Flags, or'ed together as follows:
758 *
759 * DRM_SCANOUTPOS_VALID = Query successful.
760 * DRM_SCANOUTPOS_INVBL = Inside vblank.
761 * DRM_SCANOUTPOS_ACCURATE = Returned position is accurate. A lack of
762 * this flag means that returned position may be offset by a constant
763 * but unknown small number of scanlines wrt. real scanout position.
764 *
765 */
766 int (*get_scanout_position) (struct drm_device *dev, int crtc,
767 int *vpos, int *hpos);
830
768
831 int buf_priv_size;
769 /**
770 * Called by \c drm_get_last_vbltimestamp. Should return a precise
771 * timestamp when the most recent VBLANK interval ended or will end.
772 *
773 * Specifically, the timestamp in @vblank_time should correspond as
774 * closely as possible to the time when the first video scanline of
775 * the video frame after the end of VBLANK will start scanning out,
776 * the time immediately after end of the VBLANK interval. If the
777 * @crtc is currently inside VBLANK, this will be a time in the future.
778 * If the @crtc is currently scanning out a frame, this will be the
779 * past start time of the current scanout. This is meant to adhere
780 * to the OpenML OML_sync_control extension specification.
781 *
782 * \param dev dev DRM device handle.
783 * \param crtc crtc for which timestamp should be returned.
784 * \param *max_error Maximum allowable timestamp error in nanoseconds.
785 * Implementation should strive to provide timestamp
786 * with an error of at most *max_error nanoseconds.
787 * Returns true upper bound on error for timestamp.
788 * \param *vblank_time Target location for returned vblank timestamp.
789 * \param flags 0 = Defaults, no special treatment needed.
790 * \param DRM_CALLED_FROM_VBLIRQ = Function is called from vblank
791 * irq handler. Some drivers need to apply some workarounds
792 * for gpu-specific vblank irq quirks if flag is set.
793 *
794 * \returns
795 * Zero if timestamping isn't supported in current display mode or a
796 * negative number on failure. A positive status code on success,
797 * which describes how the vblank_time timestamp was computed.
798 */
799 int (*get_vblank_timestamp) (struct drm_device *dev, int crtc,
800 int *max_error,
801 struct timeval *vblank_time,
802 unsigned flags);
832
803
833 int major;
834 int minor;
835 int patchlevel;
836 const char *name; /* Simple driver name */
837 const char *desc; /* Longer driver name */
838 const char *date; /* Date of last major changes. */
804 /* these have to be filled in */
839
805
806 irqreturn_t(*irq_handler) (DRM_IRQ_ARGS);
807 void (*irq_preinstall) (struct drm_device *dev);
808 int (*irq_postinstall) (struct drm_device *dev);
809 void (*irq_uninstall) (struct drm_device *dev);
810 void (*set_version) (struct drm_device *dev,
811 struct drm_set_version *sv);
812
813 /* Master routines */
814 int (*master_create)(struct drm_device *dev, struct drm_master *master);
815 void (*master_destroy)(struct drm_device *dev, struct drm_master *master);
816 /**
817 * master_set is called whenever the minor master is set.
818 * master_drop is called whenever the minor master is dropped.
819 */
820
821 int (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
822 bool from_open);
823 void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv,
824 bool from_release);
825
826 /**
827 * Driver-specific constructor for drm_gem_objects, to set up
828 * obj->driver_private.
829 *
830 * Returns 0 on success.
831 */
832 int (*gem_init_object) (struct drm_gem_object *obj);
833 void (*gem_free_object) (struct drm_gem_object *obj);
834 int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
835 void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
836
837#ifdef FREEBSD_NOTYET
838 /* prime: */
839 /* export handle -> fd (see drm_gem_prime_handle_to_fd() helper) */
840 int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
841 uint32_t handle, uint32_t flags, int *prime_fd);
842 /* import fd -> handle (see drm_gem_prime_fd_to_handle() helper) */
843 int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
844 int prime_fd, uint32_t *handle);
845 /* export GEM -> dmabuf */
846 struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
847 struct drm_gem_object *obj, int flags);
848 /* import dmabuf -> GEM */
849 struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
850 struct dma_buf *dma_buf);
851#endif /* defined(FREEBSD_NOTYET) */
852
853 /* dumb alloc support */
854 int (*dumb_create)(struct drm_file *file_priv,
855 struct drm_device *dev,
856 struct drm_mode_create_dumb *args);
857 int (*dumb_map_offset)(struct drm_file *file_priv,
858 struct drm_device *dev, uint32_t handle,
859 uint64_t *offset);
860 int (*dumb_destroy)(struct drm_file *file_priv,
861 struct drm_device *dev,
862 uint32_t handle);
863
864 /* Driver private ops for this object */
865 struct cdev_pager_ops *gem_pager_ops;
866
867 int (*sysctl_init)(struct drm_device *dev,
868 struct sysctl_ctx_list *ctx, struct sysctl_oid *top);
869 void (*sysctl_cleanup)(struct drm_device *dev);
870
871 int major;
872 int minor;
873 int patchlevel;
874 char *name;
875 char *desc;
876 char *date;
877
840 u32 driver_features;
878 u32 driver_features;
879 int dev_priv_size;
880 struct drm_ioctl_desc *ioctls;
881 int num_ioctls;
882 struct drm_bus *bus;
883#ifdef COMPAT_FREEBSD32
884 struct drm_ioctl_desc *compat_ioctls;
885 int *num_compat_ioctls;
886#endif
887
888 int buf_priv_size;
841};
842
889};
890
891#define DRM_MINOR_UNASSIGNED 0
892#define DRM_MINOR_LEGACY 1
893#define DRM_MINOR_CONTROL 2
894#define DRM_MINOR_RENDER 3
895
843/**
844 * DRM minor structure. This structure represents a drm minor number.
845 */
846struct drm_minor {
847 int index; /**< Minor device number */
848 int type; /**< Control or render */
896/**
897 * DRM minor structure. This structure represents a drm minor number.
898 */
899struct drm_minor {
900 int index; /**< Minor device number */
901 int type; /**< Control or render */
902 struct cdev *device; /**< Device number for mknod */
849 device_t kdev; /**< OS device */
850 struct drm_device *dev;
851
852 struct drm_master *master; /* currently active master for this node */
853 struct list_head master_list;
854 struct drm_mode_group mode_group;
903 device_t kdev; /**< OS device */
904 struct drm_device *dev;
905
906 struct drm_master *master; /* currently active master for this node */
907 struct list_head master_list;
908 struct drm_mode_group mode_group;
909
910 struct sigio *buf_sigio; /* Processes waiting for SIGIO */
855};
856
857/* mode specified on the command line */
858struct drm_cmdline_mode {
859 bool specified;
860 bool refresh_specified;
861 bool bpp_specified;
862 int xres, yres;

--- 8 unchanged lines hidden (view full) ---

871
872
873struct drm_pending_vblank_event {
874 struct drm_pending_event base;
875 int pipe;
876 struct drm_event_vblank event;
877};
878
911};
912
913/* mode specified on the command line */
914struct drm_cmdline_mode {
915 bool specified;
916 bool refresh_specified;
917 bool bpp_specified;
918 int xres, yres;

--- 8 unchanged lines hidden (view full) ---

927
928
929struct drm_pending_vblank_event {
930 struct drm_pending_event base;
931 int pipe;
932 struct drm_event_vblank event;
933};
934
879/* Length for the array of resource pointers for drm_get_resource_*. */
880#define DRM_MAX_PCI_RESOURCE 6
881
882/**
883 * DRM device structure. This structure represent a complete card that
884 * may contain multiple heads.
885 */
886struct drm_device {
935/**
936 * DRM device structure. This structure represent a complete card that
937 * may contain multiple heads.
938 */
939struct drm_device {
887 struct drm_driver_info *driver;
888 drm_pci_id_list_t *id_entry; /* PCI ID, name, and chipset private */
940 int if_version; /**< Highest interface version set */
889
941
890 uint16_t pci_device; /* PCI device id */
891 uint16_t pci_vendor; /* PCI vendor id */
892 uint16_t pci_subdevice; /* PCI subsystem device id */
893 uint16_t pci_subvendor; /* PCI subsystem vendor id */
942 /** \name Locks */
943 /*@{ */
944 struct mtx count_lock; /**< For inuse, drm_device::open_count, drm_device::buf_use */
945 struct sx dev_struct_lock; /**< For others */
946 /*@} */
894
947
895 char *unique; /* Unique identifier: e.g., busid */
896 int unique_len; /* Length of unique field */
897 device_t device; /* Device instance from newbus */
898 struct cdev *devnode; /* Device number for mknod */
899 int if_version; /* Highest interface version set */
948 /** \name Usage Counters */
949 /*@{ */
950 int open_count; /**< Outstanding files open */
951 atomic_t ioctl_count; /**< Outstanding IOCTLs pending */
952 atomic_t vma_count; /**< Outstanding vma areas open */
953 int buf_use; /**< Buffers in use -- cannot alloc */
954 atomic_t buf_alloc; /**< Buffer allocation in progress */
955 /*@} */
900
956
901 int flags; /* Flags to open(2) */
957 /** \name Performance counters */
958 /*@{ */
959 unsigned long counters;
960 enum drm_stat_type types[15];
961 atomic_t counts[15];
962 /*@} */
902
963
903 /* Locks */
904 struct mtx dma_lock; /* protects dev->dma */
905 struct mtx irq_lock; /* protects irq condition checks */
906 struct mtx dev_lock; /* protects everything else */
907 struct sx dev_struct_lock;
908 DRM_SPINTYPE drw_lock;
964 struct list_head filelist;
909
965
910 /* Usage Counters */
911 int open_count; /* Outstanding files open */
912 int buf_use; /* Buffers in use -- cannot alloc */
966 /** \name Memory management */
967 /*@{ */
968 struct list_head maplist; /**< Linked list of regions */
969 int map_count; /**< Number of mappable regions */
970 struct drm_open_hash map_hash; /**< User token hash table for maps */
913
971
914 /* Performance counters */
915 unsigned long counters;
916 enum drm_stat_type types[15];
917 atomic_t counts[15];
972 /** \name Context handle management */
973 /*@{ */
974 struct list_head ctxlist; /**< Linked list of context handles */
975 int ctx_count; /**< Number of context handles */
976 struct mtx ctxlist_mutex; /**< For ctxlist */
977 drm_local_map_t **context_sareas;
978 int max_context;
979 unsigned long *ctx_bitmap;
918
980
919 /* Authentication */
920 drm_file_list_t files;
921 drm_magic_head_t magiclist[DRM_HASH_SIZE];
981 /*@} */
922
982
923 /* Linked list of mappable regions. Protected by dev_lock */
924 drm_map_list_t maplist;
925 struct unrhdr *map_unrhdr;
983 /** \name DMA support */
984 /*@{ */
985 struct drm_device_dma *dma; /**< Optional pointer for DMA support */
986 /*@} */
926
987
927 drm_local_map_t **context_sareas;
928 int max_context;
988 /** \name Context support */
989 /*@{ */
990 int irq_enabled; /**< True if irq handler is enabled */
991 atomic_t context_flag; /**< Context swapping flag */
992 atomic_t interrupt_flag; /**< Interruption handler flag */
993 atomic_t dma_flag; /**< DMA dispatch flag */
994 wait_queue_head_t context_wait; /**< Processes waiting on ctx switch */
995 int last_checked; /**< Last context checked for DMA */
996 int last_context; /**< Last current context */
997 unsigned long last_switch; /**< jiffies at last context switch */
998 /*@} */
929
999
930 drm_lock_data_t lock; /* Information on hardware lock */
1000 /** \name VBLANK IRQ support */
1001 /*@{ */
931
1002
932 /* DMA queues (contexts) */
933 drm_device_dma_t *dma; /* Optional pointer for DMA support */
934
935 /* Context support */
936 int irq; /* Interrupt used by board */
937 int irq_enabled; /* True if the irq handler is enabled */
938 int msi_enabled; /* MSI enabled */
939 int irqrid; /* Interrupt used by board */
940 struct resource *irqr; /* Resource for interrupt used by board */
941 void *irqh; /* Handle from bus_setup_intr */
942
943 /* Storage of resource pointers for drm_get_resource_* */
944 struct resource *pcir[DRM_MAX_PCI_RESOURCE];
945 int pcirid[DRM_MAX_PCI_RESOURCE];
946
947 int pci_domain;
948 int pci_bus;
949 int pci_slot;
950 int pci_func;
951
952 atomic_t context_flag; /* Context swapping flag */
953 int last_context; /* Last current context */
954
955 int num_crtcs;
956
957 struct sigio *buf_sigio; /* Processes waiting for SIGIO */
958
959 /* Sysctl support */
960 struct drm_sysctl_info *sysctl;
961 int sysctl_node_idx;
962
963 drm_agp_head_t *agp;
964 drm_sg_mem_t *sg; /* Scatter gather memory */
965 unsigned long *ctx_bitmap;
966 void *dev_private;
967 unsigned int agp_buffer_token;
968 drm_local_map_t *agp_buffer_map;
969
970 struct drm_minor *control; /**< Control node for card */
971 struct drm_minor *primary; /**< render type primary screen head */
972
973 void *drm_ttm_bdev;
974 struct unrhdr *drw_unrhdr;
975 /* RB tree of drawable infos */
976 RB_HEAD(drawable_tree, bsd_drm_drawable_info) drw_head;
977
1003 /*
1004 * At load time, disabling the vblank interrupt won't be allowed since
1005 * old clients may not call the modeset ioctl and therefore misbehave.
1006 * Once the modeset ioctl *has* been called though, we can safely
1007 * disable them when unused.
1008 */
978 int vblank_disable_allowed;
979
980 atomic_t *_vblank_count; /**< number of VBLANK interrupts (driver must alloc the right number of counters) */
981 struct timeval *_vblank_time; /**< timestamp of current vblank_count (drivers must alloc right number of fields) */
982 struct mtx vblank_time_lock; /**< Protects vblank count and time updates during vblank enable/disable */
983 struct mtx vbl_lock;
984 atomic_t *vblank_refcount; /* number of users of vblank interruptsper crtc */
985 u32 *last_vblank; /* protected by dev->vbl_lock, used */
986 /* for wraparound handling */
987 int *vblank_enabled; /* so we don't call enable more than
988 once per disable */
989 int *vblank_inmodeset; /* Display driver is setting mode */
990 u32 *last_vblank_wait; /* Last vblank seqno waited per CRTC */
991 struct callout vblank_disable_callout;
992
993 u32 max_vblank_count; /**< size of vblank counter register */
994
1009 int vblank_disable_allowed;
1010
1011 atomic_t *_vblank_count; /**< number of VBLANK interrupts (driver must alloc the right number of counters) */
1012 struct timeval *_vblank_time; /**< timestamp of current vblank_count (drivers must alloc right number of fields) */
1013 struct mtx vblank_time_lock; /**< Protects vblank count and time updates during vblank enable/disable */
1014 struct mtx vbl_lock;
1015 atomic_t *vblank_refcount; /* number of users of vblank interruptsper crtc */
1016 u32 *last_vblank; /* protected by dev->vbl_lock, used */
1017 /* for wraparound handling */
1018 int *vblank_enabled; /* so we don't call enable more than
1019 once per disable */
1020 int *vblank_inmodeset; /* Display driver is setting mode */
1021 u32 *last_vblank_wait; /* Last vblank seqno waited per CRTC */
1022 struct callout vblank_disable_callout;
1023
1024 u32 max_vblank_count; /**< size of vblank counter register */
1025
1026 /**
1027 * List of events
1028 */
995 struct list_head vblank_event_list;
1029 struct list_head vblank_event_list;
996 struct mtx event_lock;
1030 struct mtx event_lock;
997
1031
1032 /*@} */
1033
1034 struct drm_agp_head *agp; /**< AGP data */
1035
1036 device_t dev; /* Device instance from newbus */
1037 uint16_t pci_device; /* PCI device id */
1038 uint16_t pci_vendor; /* PCI vendor id */
1039 uint16_t pci_subdevice; /* PCI subsystem device id */
1040 uint16_t pci_subvendor; /* PCI subsystem vendor id */
1041
1042 struct drm_sg_mem *sg; /**< Scatter gather memory */
1043 unsigned int num_crtcs; /**< Number of CRTCs on this device */
1044 void *dev_private; /**< device private data */
1045 void *mm_private;
1046 struct drm_sigdata sigdata; /**< For block_all_signals */
1047 sigset_t sigmask;
1048
1049 struct drm_driver *driver;
1050 struct drm_local_map *agp_buffer_map;
1051 unsigned int agp_buffer_token;
1052 struct drm_minor *control; /**< Control node for card */
1053 struct drm_minor *primary; /**< render type primary screen head */
1054
998 struct drm_mode_config mode_config; /**< Current mode config */
999
1055 struct drm_mode_config mode_config; /**< Current mode config */
1056
1000 /* GEM part */
1001 struct sx object_name_lock;
1057 /** \name GEM information */
1058 /*@{ */
1059 struct sx object_name_lock;
1002 struct drm_gem_names object_names;
1060 struct drm_gem_names object_names;
1003 void *mm_private;
1061 /*@} */
1062 int switch_power_state;
1004
1063
1064 atomic_t unplugged; /* device has been unplugged or gone away */
1065
1066 /* Locks */
1067 struct mtx dma_lock; /* protects dev->dma */
1068 struct mtx irq_lock; /* protects irq condition checks */
1069
1070 /* Context support */
1071 int irq; /* Interrupt used by board */
1072 int msi_enabled; /* MSI enabled */
1073 int irqrid; /* Interrupt used by board */
1074 struct resource *irqr; /* Resource for interrupt used by board */
1075 void *irqh; /* Handle from bus_setup_intr */
1076
1077 /* Storage of resource pointers for drm_get_resource_* */
1078#define DRM_MAX_PCI_RESOURCE 6
1079 struct resource *pcir[DRM_MAX_PCI_RESOURCE];
1080 int pcirid[DRM_MAX_PCI_RESOURCE];
1081 struct mtx pcir_lock;
1082
1083 int pci_domain;
1084 int pci_bus;
1085 int pci_slot;
1086 int pci_func;
1087
1088 /* Sysctl support */
1089 struct drm_sysctl_info *sysctl;
1090 int sysctl_node_idx;
1091
1092 void *drm_ttm_bdev;
1093
1005 void *sysctl_private;
1006 char busid_str[128];
1007 int modesetting;
1008
1094 void *sysctl_private;
1095 char busid_str[128];
1096 int modesetting;
1097
1009 int switch_power_state;
1098 drm_pci_id_list_t *id_entry; /* PCI ID, name, and chipset private */
1010};
1011
1012#define DRM_SWITCH_POWER_ON 0
1013#define DRM_SWITCH_POWER_OFF 1
1014#define DRM_SWITCH_POWER_CHANGING 2
1015
1016static __inline__ int drm_core_check_feature(struct drm_device *dev,
1017 int feature)
1018{
1019 return ((dev->driver->driver_features & feature) ? 1 : 0);
1020}
1021
1099};
1100
1101#define DRM_SWITCH_POWER_ON 0
1102#define DRM_SWITCH_POWER_OFF 1
1103#define DRM_SWITCH_POWER_CHANGING 2
1104
1105static __inline__ int drm_core_check_feature(struct drm_device *dev,
1106 int feature)
1107{
1108 return ((dev->driver->driver_features & feature) ? 1 : 0);
1109}
1110
1111static inline int drm_dev_to_irq(struct drm_device *dev)
1112{
1113 return dev->driver->bus->get_irq(dev);
1114}
1115
1116
1022#if __OS_HAS_AGP
1023static inline int drm_core_has_AGP(struct drm_device *dev)
1024{
1025 return drm_core_check_feature(dev, DRIVER_USE_AGP);
1026}
1027#else
1028#define drm_core_has_AGP(dev) (0)
1029#endif
1030
1117#if __OS_HAS_AGP
1118static inline int drm_core_has_AGP(struct drm_device *dev)
1119{
1120 return drm_core_check_feature(dev, DRIVER_USE_AGP);
1121}
1122#else
1123#define drm_core_has_AGP(dev) (0)
1124#endif
1125
1031enum dmi_field {
1032 DMI_NONE,
1033 DMI_BIOS_VENDOR,
1034 DMI_BIOS_VERSION,
1035 DMI_BIOS_DATE,
1036 DMI_SYS_VENDOR,
1037 DMI_PRODUCT_NAME,
1038 DMI_PRODUCT_VERSION,
1039 DMI_PRODUCT_SERIAL,
1040 DMI_PRODUCT_UUID,
1041 DMI_BOARD_VENDOR,
1042 DMI_BOARD_NAME,
1043 DMI_BOARD_VERSION,
1044 DMI_BOARD_SERIAL,
1045 DMI_BOARD_ASSET_TAG,
1046 DMI_CHASSIS_VENDOR,
1047 DMI_CHASSIS_TYPE,
1048 DMI_CHASSIS_VERSION,
1049 DMI_CHASSIS_SERIAL,
1050 DMI_CHASSIS_ASSET_TAG,
1051 DMI_STRING_MAX,
1052};
1126#if __OS_HAS_MTRR
1127static inline int drm_core_has_MTRR(struct drm_device *dev)
1128{
1129 return drm_core_check_feature(dev, DRIVER_USE_MTRR);
1130}
1053
1131
1054struct dmi_strmatch {
1055 unsigned char slot;
1056 char substr[79];
1057};
1132#define DRM_MTRR_WC MDF_WRITECOMBINE
1058
1133
1059struct dmi_system_id {
1060 int (*callback)(const struct dmi_system_id *);
1061 const char *ident;
1062 struct dmi_strmatch matches[4];
1063};
1064#define DMI_MATCH(a, b) {(a), (b)}
1065bool dmi_check_system(const struct dmi_system_id *);
1134int drm_mtrr_add(unsigned long offset, unsigned long size, unsigned int flags);
1135int drm_mtrr_del(int handle, unsigned long offset, unsigned long size, unsigned int flags);
1066
1136
1067extern int drm_debug_flag;
1068extern int drm_notyet_flag;
1069extern unsigned int drm_vblank_offdelay;
1070extern unsigned int drm_timestamp_precision;
1071extern unsigned int drm_timestamp_monotonic;
1137#else
1138#define drm_core_has_MTRR(dev) (0)
1072
1139
1073/* Device setup support (drm_drv.c) */
1074int drm_probe(device_t kdev, drm_pci_id_list_t *idlist);
1075int drm_attach(device_t kdev, drm_pci_id_list_t *idlist);
1076int drm_create_cdevs(device_t kdev);
1077void drm_close(void *data);
1078int drm_detach(device_t kdev);
1079d_ioctl_t drm_ioctl;
1080d_open_t drm_open;
1081d_read_t drm_read;
1082d_poll_t drm_poll;
1083d_mmap_t drm_mmap;
1084extern drm_local_map_t *drm_getsarea(struct drm_device *dev);
1140#define DRM_MTRR_WC 0
1085
1141
1086void drm_event_wakeup(struct drm_pending_event *e);
1142static inline int drm_mtrr_add(unsigned long offset, unsigned long size,
1143 unsigned int flags)
1144{
1145 return 0;
1146}
1087
1147
1088int drm_add_busid_modesetting(struct drm_device *dev,
1089 struct sysctl_ctx_list *ctx, struct sysctl_oid *top);
1148static inline int drm_mtrr_del(int handle, unsigned long offset,
1149 unsigned long size, unsigned int flags)
1150{
1151 return 0;
1152}
1153#endif
1090
1154
1091/* File operations helpers (drm_fops.c) */
1092extern int drm_open_helper(struct cdev *kdev, int flags, int fmt,
1093 DRM_STRUCTPROC *p,
1094 struct drm_device *dev);
1155/******************************************************************/
1156/** \name Internal function definitions */
1157/*@{*/
1095
1158
1096#ifdef DUMBBELL_WIP
1097extern int drm_gem_prime_handle_to_fd(struct drm_device *dev,
1098 struct drm_file *file_priv, uint32_t handle, uint32_t flags,
1099 int *prime_fd);
1100extern int drm_gem_prime_fd_to_handle(struct drm_device *dev,
1101 struct drm_file *file_priv, int prime_fd, uint32_t *handle);
1159 /* Driver support (drm_drv.h) */
1160d_ioctl_t drm_ioctl;
1161extern int drm_lastclose(struct drm_device *dev);
1102
1162
1103extern int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
1104 struct drm_file *file_priv);
1105extern int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data,
1106 struct drm_file *file_priv);
1163 /* Device support (drm_fops.h) */
1164extern struct sx drm_global_mutex;
1165d_open_t drm_open;
1166d_read_t drm_read;
1167extern void drm_release(void *data);
1107
1168
1108#ifdef DUMBBELL_WIP
1109/*
1110 * See drm_prime.c
1111 * -- dumbbell@
1112 */
1113extern int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, vm_page_t *pages,
1114 dma_addr_t *addrs, int max_pages);
1115#endif /* DUMBBELL_WIP */
1116extern struct sg_table *drm_prime_pages_to_sg(vm_page_t *pages, int nr_pages);
1117extern void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg);
1169 /* Mapping support (drm_vm.h) */
1170d_mmap_t drm_mmap;
1171int drm_mmap_single(struct cdev *kdev, vm_ooffset_t *offset,
1172 vm_size_t size, struct vm_object **obj_res, int nprot);
1173d_poll_t drm_poll;
1118
1174
1175 /* Memory management support (drm_memory.h) */
1176extern void drm_free_agp(DRM_AGP_MEM * handle, int pages);
1177extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start);
1178#ifdef FREEBSD_NOTYET
1179extern DRM_AGP_MEM *drm_agp_bind_pages(struct drm_device *dev,
1180 struct page **pages,
1181 unsigned long num_pages,
1182 uint32_t gtt_offset,
1183 uint32_t type);
1184#endif /* FREEBSD_NOTYET */
1185extern int drm_unbind_agp(DRM_AGP_MEM * handle);
1119
1186
1120void drm_prime_init_file_private(struct drm_prime_file_private *prime_fpriv);
1121void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv);
1122int drm_prime_add_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t handle);
1123int drm_prime_lookup_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t *handle);
1124void drm_prime_remove_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf);
1187 /* Misc. IOCTL support (drm_ioctl.h) */
1188extern int drm_irq_by_busid(struct drm_device *dev, void *data,
1189 struct drm_file *file_priv);
1190extern int drm_getunique(struct drm_device *dev, void *data,
1191 struct drm_file *file_priv);
1192extern int drm_setunique(struct drm_device *dev, void *data,
1193 struct drm_file *file_priv);
1194extern int drm_getmap(struct drm_device *dev, void *data,
1195 struct drm_file *file_priv);
1196extern int drm_getclient(struct drm_device *dev, void *data,
1197 struct drm_file *file_priv);
1198extern int drm_getstats(struct drm_device *dev, void *data,
1199 struct drm_file *file_priv);
1200extern int drm_getcap(struct drm_device *dev, void *data,
1201 struct drm_file *file_priv);
1202extern int drm_setversion(struct drm_device *dev, void *data,
1203 struct drm_file *file_priv);
1204extern int drm_noop(struct drm_device *dev, void *data,
1205 struct drm_file *file_priv);
1125
1206
1126int drm_prime_add_dma_buf(struct drm_device *dev, struct drm_gem_object *obj);
1127int drm_prime_lookup_obj(struct drm_device *dev, struct dma_buf *buf,
1128 struct drm_gem_object **obj);
1129#endif /* DUMBBELL_WIP */
1207 /* Context IOCTL support (drm_context.h) */
1208extern int drm_resctx(struct drm_device *dev, void *data,
1209 struct drm_file *file_priv);
1210extern int drm_addctx(struct drm_device *dev, void *data,
1211 struct drm_file *file_priv);
1212extern int drm_modctx(struct drm_device *dev, void *data,
1213 struct drm_file *file_priv);
1214extern int drm_getctx(struct drm_device *dev, void *data,
1215 struct drm_file *file_priv);
1216extern int drm_switchctx(struct drm_device *dev, void *data,
1217 struct drm_file *file_priv);
1218extern int drm_newctx(struct drm_device *dev, void *data,
1219 struct drm_file *file_priv);
1220extern int drm_rmctx(struct drm_device *dev, void *data,
1221 struct drm_file *file_priv);
1130
1222
1131/* Memory management support (drm_memory.c) */
1132void drm_mem_init(void);
1133void drm_mem_uninit(void);
1134void *drm_ioremap_wc(struct drm_device *dev, drm_local_map_t *map);
1135void *drm_ioremap(struct drm_device *dev, drm_local_map_t *map);
1136void drm_ioremapfree(drm_local_map_t *map);
1137int drm_mtrr_add(unsigned long offset, size_t size, int flags);
1138int drm_mtrr_del(int handle, unsigned long offset, size_t size, int flags);
1223extern int drm_ctxbitmap_init(struct drm_device *dev);
1224extern void drm_ctxbitmap_cleanup(struct drm_device *dev);
1225extern void drm_ctxbitmap_free(struct drm_device *dev, int ctx_handle);
1139
1226
1140int drm_context_switch(struct drm_device *dev, int old, int new);
1141int drm_context_switch_complete(struct drm_device *dev, int new);
1227extern int drm_setsareactx(struct drm_device *dev, void *data,
1228 struct drm_file *file_priv);
1229extern int drm_getsareactx(struct drm_device *dev, void *data,
1230 struct drm_file *file_priv);
1142
1231
1143int drm_ctxbitmap_init(struct drm_device *dev);
1144void drm_ctxbitmap_cleanup(struct drm_device *dev);
1145void drm_ctxbitmap_free(struct drm_device *dev, int ctx_handle);
1146int drm_ctxbitmap_next(struct drm_device *dev);
1232 /* Authentication IOCTL support (drm_auth.h) */
1233extern int drm_getmagic(struct drm_device *dev, void *data,
1234 struct drm_file *file_priv);
1235extern int drm_authmagic(struct drm_device *dev, void *data,
1236 struct drm_file *file_priv);
1237extern int drm_remove_magic(struct drm_master *master, drm_magic_t magic);
1147
1238
1148/* Locking IOCTL support (drm_lock.c) */
1149int drm_lock_take(struct drm_lock_data *lock_data,
1150 unsigned int context);
1151int drm_lock_transfer(struct drm_lock_data *lock_data,
1152 unsigned int context);
1153int drm_lock_free(struct drm_lock_data *lock_data,
1154 unsigned int context);
1239/* Cache management (drm_cache.c) */
1240void drm_clflush_pages(vm_page_t *pages, unsigned long num_pages);
1241void drm_clflush_virt_range(char *addr, unsigned long length);
1155
1242
1156/* Buffer management support (drm_bufs.c) */
1157unsigned long drm_get_resource_start(struct drm_device *dev,
1158 unsigned int resource);
1159unsigned long drm_get_resource_len(struct drm_device *dev,
1160 unsigned int resource);
1161void drm_rmmap(struct drm_device *dev, drm_local_map_t *map);
1162int drm_order(unsigned long size);
1163int drm_addmap(struct drm_device *dev, unsigned long offset,
1164 unsigned long size,
1165 enum drm_map_type type, enum drm_map_flags flags,
1166 drm_local_map_t **map_ptr);
1167int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc *request);
1168int drm_addbufs_sg(struct drm_device *dev, struct drm_buf_desc *request);
1169int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc *request);
1243 /* Locking IOCTL support (drm_lock.h) */
1244extern int drm_lock(struct drm_device *dev, void *data,
1245 struct drm_file *file_priv);
1246extern int drm_unlock(struct drm_device *dev, void *data,
1247 struct drm_file *file_priv);
1248extern int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context);
1249extern void drm_idlelock_take(struct drm_lock_data *lock_data);
1250extern void drm_idlelock_release(struct drm_lock_data *lock_data);
1170
1251
1171/* DMA support (drm_dma.c) */
1172int drm_dma_setup(struct drm_device *dev);
1173void drm_dma_takedown(struct drm_device *dev);
1174void drm_free_buffer(struct drm_device *dev, drm_buf_t *buf);
1175void drm_reclaim_buffers(struct drm_device *dev, struct drm_file *file_priv);
1176#define drm_core_reclaim_buffers drm_reclaim_buffers
1252/*
1253 * These are exported to drivers so that they can implement fencing using
1254 * DMA quiscent + idle. DMA quiescent usually requires the hardware lock.
1255 */
1177
1256
1178/* IRQ support (drm_irq.c) */
1179int drm_irq_install(struct drm_device *dev);
1180int drm_irq_uninstall(struct drm_device *dev);
1181irqreturn_t drm_irq_handler(DRM_IRQ_ARGS);
1182void drm_driver_irq_preinstall(struct drm_device *dev);
1183void drm_driver_irq_postinstall(struct drm_device *dev);
1184void drm_driver_irq_uninstall(struct drm_device *dev);
1257extern int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv);
1185
1258
1186void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
1187void drm_vblank_post_modeset(struct drm_device *dev, int crtc);
1188int drm_modeset_ctl(struct drm_device *dev, void *data,
1259 /* Buffer management support (drm_bufs.h) */
1260extern int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request);
1261extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request);
1262extern int drm_addmap(struct drm_device *dev, resource_size_t offset,
1263 unsigned int size, enum drm_map_type type,
1264 enum drm_map_flags flags, struct drm_local_map **map_ptr);
1265extern int drm_addmap_ioctl(struct drm_device *dev, void *data,
1266 struct drm_file *file_priv);
1267extern int drm_rmmap(struct drm_device *dev, struct drm_local_map *map);
1268extern int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map);
1269extern int drm_rmmap_ioctl(struct drm_device *dev, void *data,
1270 struct drm_file *file_priv);
1271extern int drm_addbufs(struct drm_device *dev, void *data,
1272 struct drm_file *file_priv);
1273extern int drm_infobufs(struct drm_device *dev, void *data,
1189 struct drm_file *file_priv);
1274 struct drm_file *file_priv);
1275extern int drm_markbufs(struct drm_device *dev, void *data,
1276 struct drm_file *file_priv);
1277extern int drm_freebufs(struct drm_device *dev, void *data,
1278 struct drm_file *file_priv);
1279extern int drm_mapbufs(struct drm_device *dev, void *data,
1280 struct drm_file *file_priv);
1281extern int drm_order(unsigned long size);
1190
1282
1283 /* DMA support (drm_dma.h) */
1284extern int drm_dma_setup(struct drm_device *dev);
1285extern void drm_dma_takedown(struct drm_device *dev);
1286extern void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf);
1287extern void drm_core_reclaim_buffers(struct drm_device *dev,
1288 struct drm_file *filp);
1289
1290 /* IRQ support (drm_irq.h) */
1291extern int drm_control(struct drm_device *dev, void *data,
1292 struct drm_file *file_priv);
1293extern int drm_irq_install(struct drm_device *dev);
1294extern int drm_irq_uninstall(struct drm_device *dev);
1295
1191extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);
1192extern int drm_wait_vblank(struct drm_device *dev, void *data,
1193 struct drm_file *filp);
1194extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq);
1195extern u32 drm_vblank_count(struct drm_device *dev, int crtc);
1196extern u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc,
1197 struct timeval *vblanktime);
1296extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);
1297extern int drm_wait_vblank(struct drm_device *dev, void *data,
1298 struct drm_file *filp);
1299extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq);
1300extern u32 drm_vblank_count(struct drm_device *dev, int crtc);
1301extern u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc,
1302 struct timeval *vblanktime);
1303extern void drm_send_vblank_event(struct drm_device *dev, int crtc,
1304 struct drm_pending_vblank_event *e);
1198extern bool drm_handle_vblank(struct drm_device *dev, int crtc);
1305extern bool drm_handle_vblank(struct drm_device *dev, int crtc);
1199void drm_handle_vblank_events(struct drm_device *dev, int crtc);
1200extern int drm_vblank_get(struct drm_device *dev, int crtc);
1201extern void drm_vblank_put(struct drm_device *dev, int crtc);
1202extern void drm_vblank_off(struct drm_device *dev, int crtc);
1203extern void drm_vblank_cleanup(struct drm_device *dev);
1204extern u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
1205 struct timeval *tvblank, unsigned flags);
1206extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
1207 int crtc, int *max_error,
1208 struct timeval *vblank_time,
1209 unsigned flags,
1210 struct drm_crtc *refcrtc);
1211extern void drm_calc_timestamping_constants(struct drm_crtc *crtc);
1212
1306extern int drm_vblank_get(struct drm_device *dev, int crtc);
1307extern void drm_vblank_put(struct drm_device *dev, int crtc);
1308extern void drm_vblank_off(struct drm_device *dev, int crtc);
1309extern void drm_vblank_cleanup(struct drm_device *dev);
1310extern u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
1311 struct timeval *tvblank, unsigned flags);
1312extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
1313 int crtc, int *max_error,
1314 struct timeval *vblank_time,
1315 unsigned flags,
1316 struct drm_crtc *refcrtc);
1317extern void drm_calc_timestamping_constants(struct drm_crtc *crtc);
1318
1213struct timeval ns_to_timeval(const int64_t nsec);
1214int64_t timeval_to_ns(const struct timeval *tv);
1319extern bool
1320drm_mode_parse_command_line_for_connector(const char *mode_option,
1321 struct drm_connector *connector,
1322 struct drm_cmdline_mode *mode);
1215
1323
1216/* AGP/PCI Express/GART support (drm_agpsupport.c) */
1217int drm_device_is_agp(struct drm_device *dev);
1218int drm_device_is_pcie(struct drm_device *dev);
1219drm_agp_head_t *drm_agp_init(void);
1220int drm_agp_acquire(struct drm_device *dev);
1221int drm_agp_release(struct drm_device *dev);
1222int drm_agp_info(struct drm_device * dev, struct drm_agp_info *info);
1223int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode);
1224void *drm_agp_allocate_memory(size_t pages, u32 type);
1225int drm_agp_free_memory(void *handle);
1226int drm_agp_bind_memory(void *handle, off_t start);
1227int drm_agp_unbind_memory(void *handle);
1228int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request);
1229int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request);
1230int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request);
1231int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request);
1324extern struct drm_display_mode *
1325drm_mode_create_from_cmdline_mode(struct drm_device *dev,
1326 struct drm_cmdline_mode *cmd);
1232
1327
1233/* Scatter Gather Support (drm_scatter.c) */
1234void drm_sg_cleanup(drm_sg_mem_t *entry);
1235int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request);
1328/* Modesetting support */
1329extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
1330extern void drm_vblank_post_modeset(struct drm_device *dev, int crtc);
1331extern int drm_modeset_ctl(struct drm_device *dev, void *data,
1332 struct drm_file *file_priv);
1236
1333
1237/* sysctl support (drm_sysctl.h) */
1238extern int drm_sysctl_init(struct drm_device *dev);
1239extern int drm_sysctl_cleanup(struct drm_device *dev);
1334 /* AGP/GART support (drm_agpsupport.h) */
1335extern struct drm_agp_head *drm_agp_init(struct drm_device *dev);
1336extern int drm_agp_acquire(struct drm_device *dev);
1337extern int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
1338 struct drm_file *file_priv);
1339extern int drm_agp_release(struct drm_device *dev);
1340extern int drm_agp_release_ioctl(struct drm_device *dev, void *data,
1341 struct drm_file *file_priv);
1342extern int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode);
1343extern int drm_agp_enable_ioctl(struct drm_device *dev, void *data,
1344 struct drm_file *file_priv);
1345extern int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info);
1346extern int drm_agp_info_ioctl(struct drm_device *dev, void *data,
1347 struct drm_file *file_priv);
1348extern int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request);
1349extern int drm_agp_alloc_ioctl(struct drm_device *dev, void *data,
1350 struct drm_file *file_priv);
1351extern int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request);
1352extern int drm_agp_free_ioctl(struct drm_device *dev, void *data,
1353 struct drm_file *file_priv);
1354extern int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request);
1355extern int drm_agp_unbind_ioctl(struct drm_device *dev, void *data,
1356 struct drm_file *file_priv);
1357extern int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request);
1358extern int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
1359 struct drm_file *file_priv);
1240
1360
1241/* ATI PCIGART support (ati_pcigart.c) */
1242int drm_ati_pcigart_init(struct drm_device *dev,
1243 struct drm_ati_pcigart_info *gart_info);
1244int drm_ati_pcigart_cleanup(struct drm_device *dev,
1245 struct drm_ati_pcigart_info *gart_info);
1361 /* Stub support (drm_stub.h) */
1362extern int drm_setmaster_ioctl(struct drm_device *dev, void *data,
1363 struct drm_file *file_priv);
1364extern int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
1365 struct drm_file *file_priv);
1366struct drm_master *drm_master_create(struct drm_minor *minor);
1367extern struct drm_master *drm_master_get(struct drm_master *master);
1368extern void drm_master_put(struct drm_master **master);
1246
1369
1247/* Cache management (drm_memory.c) */
1248void drm_clflush_pages(vm_page_t *pages, unsigned long num_pages);
1249void drm_clflush_virt_range(char *addr, unsigned long length);
1370extern void drm_put_dev(struct drm_device *dev);
1371extern int drm_put_minor(struct drm_minor **minor);
1372extern void drm_unplug_dev(struct drm_device *dev);
1373extern unsigned int drm_debug;
1374extern unsigned int drm_notyet;
1250
1375
1251/* Locking IOCTL support (drm_drv.c) */
1252int drm_lock(struct drm_device *dev, void *data,
1253 struct drm_file *file_priv);
1254int drm_unlock(struct drm_device *dev, void *data,
1255 struct drm_file *file_priv);
1256int drm_version(struct drm_device *dev, void *data,
1257 struct drm_file *file_priv);
1258int drm_setversion(struct drm_device *dev, void *data,
1259 struct drm_file *file_priv);
1376extern unsigned int drm_vblank_offdelay;
1377extern unsigned int drm_timestamp_precision;
1378extern unsigned int drm_timestamp_monotonic;
1260
1379
1261/* Misc. IOCTL support (drm_ioctl.c) */
1262int drm_irq_by_busid(struct drm_device *dev, void *data,
1263 struct drm_file *file_priv);
1264int drm_getunique(struct drm_device *dev, void *data,
1265 struct drm_file *file_priv);
1266int drm_setunique(struct drm_device *dev, void *data,
1267 struct drm_file *file_priv);
1268int drm_getmap(struct drm_device *dev, void *data,
1269 struct drm_file *file_priv);
1270int drm_getclient(struct drm_device *dev, void *data,
1271 struct drm_file *file_priv);
1272int drm_getstats(struct drm_device *dev, void *data,
1273 struct drm_file *file_priv);
1274int drm_getcap(struct drm_device *dev, void *data,
1275 struct drm_file *file_priv);
1276int drm_noop(struct drm_device *dev, void *data,
1277 struct drm_file *file_priv);
1380extern struct drm_local_map *drm_getsarea(struct drm_device *dev);
1278
1381
1279/* Context IOCTL support (drm_context.c) */
1280int drm_resctx(struct drm_device *dev, void *data,
1281 struct drm_file *file_priv);
1282int drm_addctx(struct drm_device *dev, void *data,
1283 struct drm_file *file_priv);
1284int drm_modctx(struct drm_device *dev, void *data,
1285 struct drm_file *file_priv);
1286int drm_getctx(struct drm_device *dev, void *data,
1287 struct drm_file *file_priv);
1288int drm_switchctx(struct drm_device *dev, void *data,
1289 struct drm_file *file_priv);
1290int drm_newctx(struct drm_device *dev, void *data,
1291 struct drm_file *file_priv);
1292int drm_rmctx(struct drm_device *dev, void *data,
1293 struct drm_file *file_priv);
1294int drm_setsareactx(struct drm_device *dev, void *data,
1295 struct drm_file *file_priv);
1296int drm_getsareactx(struct drm_device *dev, void *data,
1297 struct drm_file *file_priv);
1298
1382
1299/* Drawable IOCTL support (drm_drawable.c) */
1300int drm_adddraw(struct drm_device *dev, void *data,
1301 struct drm_file *file_priv);
1302int drm_rmdraw(struct drm_device *dev, void *data,
1303 struct drm_file *file_priv);
1304int drm_update_draw(struct drm_device *dev, void *data,
1305 struct drm_file *file_priv);
1306struct drm_drawable_info *drm_get_drawable_info(struct drm_device *dev,
1307 int handle);
1383#ifdef FREEBSD_NOTYET
1384extern int drm_gem_prime_handle_to_fd(struct drm_device *dev,
1385 struct drm_file *file_priv, uint32_t handle, uint32_t flags,
1386 int *prime_fd);
1387extern int drm_gem_prime_fd_to_handle(struct drm_device *dev,
1388 struct drm_file *file_priv, int prime_fd, uint32_t *handle);
1308
1389
1309/* Drawable support (drm_drawable.c) */
1310void drm_drawable_free_all(struct drm_device *dev);
1390extern int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
1391 struct drm_file *file_priv);
1392extern int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data,
1393 struct drm_file *file_priv);
1311
1394
1312/* Authentication IOCTL support (drm_auth.c) */
1313int drm_getmagic(struct drm_device *dev, void *data,
1314 struct drm_file *file_priv);
1315int drm_authmagic(struct drm_device *dev, void *data,
1316 struct drm_file *file_priv);
1395extern int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, vm_page_t *pages,
1396 dma_addr_t *addrs, int max_pages);
1397extern struct sg_table *drm_prime_pages_to_sg(vm_page_t *pages, int nr_pages);
1398extern void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg);
1317
1399
1318/* Buffer management support (drm_bufs.c) */
1319int drm_addmap_ioctl(struct drm_device *dev, void *data,
1320 struct drm_file *file_priv);
1321int drm_rmmap_ioctl(struct drm_device *dev, void *data,
1322 struct drm_file *file_priv);
1323int drm_addbufs(struct drm_device *dev, void *data,
1324 struct drm_file *file_priv);
1325int drm_infobufs(struct drm_device *dev, void *data,
1326 struct drm_file *file_priv);
1327int drm_markbufs(struct drm_device *dev, void *data,
1328 struct drm_file *file_priv);
1329int drm_freebufs(struct drm_device *dev, void *data,
1330 struct drm_file *file_priv);
1331int drm_mapbufs(struct drm_device *dev, void *data,
1332 struct drm_file *file_priv);
1333
1400
1334/* DMA support (drm_dma.c) */
1335int drm_dma(struct drm_device *dev, void *data, struct drm_file *file_priv);
1401void drm_prime_init_file_private(struct drm_prime_file_private *prime_fpriv);
1402void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv);
1403int drm_prime_add_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t handle);
1404int drm_prime_lookup_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t *handle);
1405void drm_prime_remove_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf);
1336
1406
1337/* IRQ support (drm_irq.c) */
1338int drm_control(struct drm_device *dev, void *data,
1339 struct drm_file *file_priv);
1407int drm_prime_add_dma_buf(struct drm_device *dev, struct drm_gem_object *obj);
1408int drm_prime_lookup_obj(struct drm_device *dev, struct dma_buf *buf,
1409 struct drm_gem_object **obj);
1410#endif /* FREEBSD_NOTYET */
1340
1411
1341/* AGP/GART support (drm_agpsupport.c) */
1342int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
1343 struct drm_file *file_priv);
1344int drm_agp_release_ioctl(struct drm_device *dev, void *data,
1345 struct drm_file *file_priv);
1346int drm_agp_enable_ioctl(struct drm_device *dev, void *data,
1347 struct drm_file *file_priv);
1348int drm_agp_info_ioctl(struct drm_device *dev, void *data,
1349 struct drm_file *file_priv);
1350int drm_agp_alloc_ioctl(struct drm_device *dev, void *data,
1351 struct drm_file *file_priv);
1352int drm_agp_free_ioctl(struct drm_device *dev, void *data,
1353 struct drm_file *file_priv);
1354int drm_agp_unbind_ioctl(struct drm_device *dev, void *data,
1355 struct drm_file *file_priv);
1356int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
1357 struct drm_file *file_priv);
1412 /* Scatter Gather Support (drm_scatter.h) */
1413extern void drm_sg_cleanup(struct drm_sg_mem * entry);
1414extern int drm_sg_alloc_ioctl(struct drm_device *dev, void *data,
1415 struct drm_file *file_priv);
1416extern int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request);
1417extern int drm_sg_free(struct drm_device *dev, void *data,
1418 struct drm_file *file_priv);
1358
1419
1359 /* Stub support (drm_stub.h) */
1360extern int drm_setmaster_ioctl(struct drm_device *dev, void *data,
1361 struct drm_file *file_priv);
1362extern int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
1363 struct drm_file *file_priv);
1420 /* ATI PCIGART support (ati_pcigart.h) */
1421extern int drm_ati_pcigart_init(struct drm_device *dev,
1422 struct drm_ati_pcigart_info * gart_info);
1423extern int drm_ati_pcigart_cleanup(struct drm_device *dev,
1424 struct drm_ati_pcigart_info * gart_info);
1364
1425
1365/* Scatter Gather Support (drm_scatter.c) */
1366int drm_sg_alloc_ioctl(struct drm_device *dev, void *data,
1367 struct drm_file *file_priv);
1368int drm_sg_free(struct drm_device *dev, void *data,
1369 struct drm_file *file_priv);
1426extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
1427 size_t align, dma_addr_t maxaddr);
1428extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
1429extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
1370
1430
1371/* consistent PCI memory functions (drm_pci.c) */
1372drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
1373 size_t align, dma_addr_t maxaddr);
1374void drm_pci_free(struct drm_device *dev, drm_dma_handle_t *dmah);
1375
1376/* Graphics Execution Manager library functions (drm_gem.c) */
1377int drm_gem_init(struct drm_device *dev);
1378void drm_gem_destroy(struct drm_device *dev);
1431/* Graphics Execution Manager library functions (drm_gem.c) */
1432int drm_gem_init(struct drm_device *dev);
1433void drm_gem_destroy(struct drm_device *dev);
1379
1380int drm_gem_close_ioctl(struct drm_device *dev, void *data,
1381 struct drm_file *file_priv);
1382int drm_gem_flink_ioctl(struct drm_device *dev, void *data,
1383 struct drm_file *file_priv);
1384int drm_gem_open_ioctl(struct drm_device *dev, void *data,
1385 struct drm_file *file_priv);
1386int drm_gem_handle_create(struct drm_file *file_priv,
1387 struct drm_gem_object *obj,
1388 u32 *handlep);
1389int drm_gem_handle_delete(struct drm_file *file_priv, uint32_t handle);
1390void drm_gem_object_handle_reference(struct drm_gem_object *obj);
1391void drm_gem_object_handle_unreference(struct drm_gem_object *obj);
1392void drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj);
1393void drm_gem_object_handle_free(struct drm_gem_object *obj);
1394void drm_gem_object_reference(struct drm_gem_object *obj);
1395void drm_gem_object_unreference(struct drm_gem_object *obj);
1396void drm_gem_object_unreference_unlocked(struct drm_gem_object *obj);
1397void drm_gem_object_release(struct drm_gem_object *obj);
1398void drm_gem_object_free(struct drm_gem_object *obj);
1434void drm_gem_object_release(struct drm_gem_object *obj);
1435void drm_gem_object_free(struct drm_gem_object *obj);
1399int drm_gem_object_init(struct drm_device *dev, struct drm_gem_object *obj,
1400 size_t size);
1401int drm_gem_private_object_init(struct drm_device *dev,
1402 struct drm_gem_object *obj, size_t size);
1403struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev,
1436struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev,
1404 size_t size);
1405struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev,
1406 struct drm_file *file_priv, uint32_t handle);
1407
1408void drm_gem_open(struct drm_device *dev, struct drm_file *file_priv);
1409void drm_gem_release(struct drm_device *dev, struct drm_file *file_priv);
1410
1411int drm_gem_create_mmap_offset(struct drm_gem_object *obj);
1412void drm_gem_free_mmap_offset(struct drm_gem_object *obj);
1437 size_t size);
1438int drm_gem_object_init(struct drm_device *dev,
1439 struct drm_gem_object *obj, size_t size);
1440int drm_gem_private_object_init(struct drm_device *dev,
1441 struct drm_gem_object *obj, size_t size);
1442void drm_gem_object_handle_free(struct drm_gem_object *obj);
1413int drm_gem_mmap_single(struct drm_device *dev, vm_ooffset_t *offset,
1414 vm_size_t size, struct vm_object **obj_res, int nprot);
1415void drm_gem_pager_dtr(void *obj);
1416
1443int drm_gem_mmap_single(struct drm_device *dev, vm_ooffset_t *offset,
1444 vm_size_t size, struct vm_object **obj_res, int nprot);
1445void drm_gem_pager_dtr(void *obj);
1446
1417struct ttm_bo_device;
1418int ttm_bo_mmap_single(struct ttm_bo_device *bdev, vm_ooffset_t *offset,
1419 vm_size_t size, struct vm_object **obj_res, int nprot);
1420struct ttm_buffer_object;
1421void ttm_bo_release_mmap(struct ttm_buffer_object *bo);
1447#include <dev/drm2/drm_global.h>
1422
1448
1423void drm_device_lock_mtx(struct drm_device *dev);
1424void drm_device_unlock_mtx(struct drm_device *dev);
1425int drm_device_sleep_mtx(struct drm_device *dev, void *chan, int flags,
1426 const char *msg, int timeout);
1427void drm_device_assert_mtx_locked(struct drm_device *dev);
1428void drm_device_assert_mtx_unlocked(struct drm_device *dev);
1449static inline void
1450drm_gem_object_reference(struct drm_gem_object *obj)
1451{
1429
1452
1430void drm_device_lock_struct(struct drm_device *dev);
1431void drm_device_unlock_struct(struct drm_device *dev);
1432int drm_device_sleep_struct(struct drm_device *dev, void *chan, int flags,
1433 const char *msg, int timeout);
1434void drm_device_assert_struct_locked(struct drm_device *dev);
1435void drm_device_assert_struct_unlocked(struct drm_device *dev);
1453 KASSERT(obj->refcount > 0, ("Dangling obj %p", obj));
1454 refcount_acquire(&obj->refcount);
1455}
1436
1456
1437void drm_compat_locking_init(struct drm_device *dev);
1438void drm_sleep_locking_init(struct drm_device *dev);
1439
1440/* drm_modes.c */
1441bool drm_mode_parse_command_line_for_connector(const char *mode_option,
1442 struct drm_connector *connector, struct drm_cmdline_mode *mode);
1443struct drm_display_mode *drm_mode_create_from_cmdline_mode(
1444 struct drm_device *dev, struct drm_cmdline_mode *cmd);
1445
1446/* drm_edid.c */
1447u8 *drm_find_cea_extension(struct edid *edid);
1448
1449/* Inline replacements for drm_alloc and friends */
1450static __inline__ void *
1451drm_alloc(size_t size, struct malloc_type *area)
1457static inline void
1458drm_gem_object_unreference(struct drm_gem_object *obj)
1452{
1459{
1453 return malloc(size, area, M_NOWAIT);
1460
1461 if (obj == NULL)
1462 return;
1463 if (refcount_release(&obj->refcount))
1464 drm_gem_object_free(obj);
1454}
1455
1465}
1466
1456static __inline__ void *
1457drm_calloc(size_t nmemb, size_t size, struct malloc_type *area)
1467static inline void
1468drm_gem_object_unreference_unlocked(struct drm_gem_object *obj)
1458{
1469{
1459 return malloc(size * nmemb, area, M_NOWAIT | M_ZERO);
1470 if (obj != NULL) {
1471 struct drm_device *dev = obj->dev;
1472 DRM_LOCK(dev);
1473 drm_gem_object_unreference(obj);
1474 DRM_UNLOCK(dev);
1475 }
1460}
1461
1476}
1477
1462static __inline__ void *
1463drm_realloc(void *oldpt, size_t oldsize, size_t size,
1464 struct malloc_type *area)
1478int drm_gem_handle_create(struct drm_file *file_priv,
1479 struct drm_gem_object *obj,
1480 u32 *handlep);
1481int drm_gem_handle_delete(struct drm_file *filp, u32 handle);
1482
1483static inline void
1484drm_gem_object_handle_reference(struct drm_gem_object *obj)
1465{
1485{
1466 return reallocf(oldpt, size, area, M_NOWAIT);
1486 drm_gem_object_reference(obj);
1487 atomic_inc(&obj->handle_count);
1467}
1468
1488}
1489
1469static __inline__ void
1470drm_free(void *pt, size_t size, struct malloc_type *area)
1490static inline void
1491drm_gem_object_handle_unreference(struct drm_gem_object *obj)
1471{
1492{
1472 free(pt, area);
1493 if (obj == NULL)
1494 return;
1495
1496 if (atomic_read(&obj->handle_count) == 0)
1497 return;
1498 /*
1499 * Must bump handle count first as this may be the last
1500 * ref, in which case the object would disappear before we
1501 * checked for a name
1502 */
1503 if (atomic_dec_and_test(&obj->handle_count))
1504 drm_gem_object_handle_free(obj);
1505 drm_gem_object_unreference(obj);
1473}
1474
1506}
1507
1475/* Inline replacements for DRM_IOREMAP macros */
1476static __inline__ void
1477drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev)
1508static inline void
1509drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj)
1478{
1510{
1479 map->virtual = drm_ioremap_wc(dev, map);
1511 if (obj == NULL)
1512 return;
1513
1514 if (atomic_read(&obj->handle_count) == 0)
1515 return;
1516
1517 /*
1518 * Must bump handle count first as this may be the last
1519 * ref, in which case the object would disappear before we
1520 * checked for a name
1521 */
1522
1523 if (atomic_dec_and_test(&obj->handle_count))
1524 drm_gem_object_handle_free(obj);
1525 drm_gem_object_unreference_unlocked(obj);
1480}
1526}
1481static __inline__ void
1482drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev)
1483{
1484 map->virtual = drm_ioremap(dev, map);
1485}
1486static __inline__ void
1487drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev)
1488{
1489 if ( map->virtual && map->size )
1490 drm_ioremapfree(map);
1491}
1492
1527
1493static __inline__ struct drm_local_map *
1494drm_core_findmap(struct drm_device *dev, unsigned long offset)
1495{
1496 drm_local_map_t *map;
1528void drm_gem_free_mmap_offset(struct drm_gem_object *obj);
1529int drm_gem_create_mmap_offset(struct drm_gem_object *obj);
1497
1530
1498 DRM_LOCK_ASSERT(dev);
1499 TAILQ_FOREACH(map, &dev->maplist, link) {
1500 if (offset == (unsigned long)map->handle)
1501 return map;
1502 }
1531struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev,
1532 struct drm_file *filp,
1533 u32 handle);
1534int drm_gem_close_ioctl(struct drm_device *dev, void *data,
1535 struct drm_file *file_priv);
1536int drm_gem_flink_ioctl(struct drm_device *dev, void *data,
1537 struct drm_file *file_priv);
1538int drm_gem_open_ioctl(struct drm_device *dev, void *data,
1539 struct drm_file *file_priv);
1540void drm_gem_open(struct drm_device *dev, struct drm_file *file_private);
1541void drm_gem_release(struct drm_device *dev, struct drm_file *file_private);
1542
1543extern void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev);
1544extern void drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev);
1545extern void drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev);
1546
1547static __inline__ struct drm_local_map *drm_core_findmap(struct drm_device *dev,
1548 unsigned int token)
1549{
1550 struct drm_map_list *_entry;
1551 list_for_each_entry(_entry, &dev->maplist, head)
1552 if (_entry->user_token == token)
1553 return _entry->map;
1503 return NULL;
1504}
1505
1554 return NULL;
1555}
1556
1506static __inline__ void drm_core_dropmap(struct drm_map *map)
1557static __inline__ void drm_core_dropmap(struct drm_local_map *map)
1507{
1508}
1509
1558{
1559}
1560
1561extern int drm_fill_in_dev(struct drm_device *dev,
1562 struct drm_driver *driver);
1563extern void drm_cancel_fill_in_dev(struct drm_device *dev);
1564int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type);
1565/*@}*/
1566
1567/* PCI section */
1568int drm_pci_device_is_agp(struct drm_device *dev);
1569int drm_pci_device_is_pcie(struct drm_device *dev);
1570
1571extern int drm_get_pci_dev(device_t kdev, struct drm_device *dev,
1572 struct drm_driver *driver);
1573
1510#define DRM_PCIE_SPEED_25 1
1511#define DRM_PCIE_SPEED_50 2
1512#define DRM_PCIE_SPEED_80 4
1513
1514extern int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *speed_mask);
1515
1516#define drm_can_sleep() (DRM_HZ & 1)
1517
1574#define DRM_PCIE_SPEED_25 1
1575#define DRM_PCIE_SPEED_50 2
1576#define DRM_PCIE_SPEED_80 4
1577
1578extern int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *speed_mask);
1579
1580#define drm_can_sleep() (DRM_HZ & 1)
1581
1518#endif /* __KERNEL__ */
1519#endif /* _DRM_P_H_ */
1582/* FreeBSD specific -- should be moved to drm_os_freebsd.h */
1583
1584#define DRM_GEM_MAPPING_MASK (3ULL << 62)
1585#define DRM_GEM_MAPPING_KEY (2ULL << 62) /* Non-canonical address form */
1586#define DRM_GEM_MAX_IDX 0x3fffff
1587#define DRM_GEM_MAPPING_IDX(o) (((o) >> 40) & DRM_GEM_MAX_IDX)
1588#define DRM_GEM_MAPPING_OFF(i) (((uint64_t)(i)) << 40)
1589#define DRM_GEM_MAPPING_MAPOFF(o) \
1590 ((o) & ~(DRM_GEM_MAPPING_OFF(DRM_GEM_MAX_IDX) | DRM_GEM_MAPPING_KEY))
1591
1592SYSCTL_DECL(_hw_drm);
1593
1594#define DRM_DEV_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
1595#define DRM_DEV_UID 0
1596#define DRM_DEV_GID 0
1597
1598#define DRM_WAKEUP(w) wakeup((void *)w)
1599#define DRM_WAKEUP_INT(w) wakeup(w)
1600#define DRM_INIT_WAITQUEUE(queue) do {(void)(queue);} while (0)
1601
1602#define DRM_CURPROC curthread
1603#define DRM_STRUCTPROC struct thread
1604#define DRM_SPINTYPE struct mtx
1605#define DRM_SPININIT(l,name) mtx_init(l, name, NULL, MTX_DEF)
1606#define DRM_SPINUNINIT(l) mtx_destroy(l)
1607#define DRM_SPINLOCK(l) mtx_lock(l)
1608#define DRM_SPINUNLOCK(u) mtx_unlock(u)
1609#define DRM_SPINLOCK_IRQSAVE(l, irqflags) do { \
1610 mtx_lock(l); \
1611 (void)irqflags; \
1612} while (0)
1613#define DRM_SPINUNLOCK_IRQRESTORE(u, irqflags) mtx_unlock(u)
1614#define DRM_SPINLOCK_ASSERT(l) mtx_assert(l, MA_OWNED)
1615#define DRM_LOCK_SLEEP(dev, chan, flags, msg, timeout) \
1616 (sx_sleep((chan), &(dev)->dev_struct_lock, (flags), (msg), (timeout)))
1617#if defined(INVARIANTS)
1618#define DRM_LOCK_ASSERT(dev) sx_assert(&(dev)->dev_struct_lock, SA_XLOCKED)
1619#define DRM_UNLOCK_ASSERT(dev) sx_assert(&(dev)->dev_struct_lock, SA_UNLOCKED)
1620#else
1621#define DRM_LOCK_ASSERT(d)
1622#define DRM_UNLOCK_ASSERT(d)
1623#endif
1624
1625#define DRM_SYSCTL_HANDLER_ARGS (SYSCTL_HANDLER_ARGS)
1626
1627enum {
1628 DRM_IS_NOT_AGP,
1629 DRM_IS_AGP,
1630 DRM_MIGHT_BE_AGP
1631};
1632
1633#define DRM_VERIFYAREA_READ( uaddr, size ) \
1634 (!useracc(__DECONST(caddr_t, uaddr), size, VM_PROT_READ))
1635
1636#define DRM_COPY_TO_USER(user, kern, size) \
1637 copyout(kern, user, size)
1638#define DRM_COPY_FROM_USER(kern, user, size) \
1639 copyin(user, kern, size)
1640#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
1641 copyin(arg2, arg1, arg3)
1642#define DRM_COPY_TO_USER_UNCHECKED(arg1, arg2, arg3) \
1643 copyout(arg2, arg1, arg3)
1644#define DRM_GET_USER_UNCHECKED(val, uaddr) \
1645 ((val) = fuword32(uaddr), 0)
1646
1647#define DRM_GET_PRIV_SAREA(_dev, _ctx, _map) do { \
1648 (_map) = (_dev)->context_sareas[_ctx]; \
1649} while(0)
1650
1651/* Returns -errno to shared code */
1652#define DRM_WAIT_ON( ret, queue, timeout, condition ) \
1653for ( ret = 0 ; !ret && !(condition) ; ) { \
1654 DRM_UNLOCK(dev); \
1655 mtx_lock(&dev->irq_lock); \
1656 if (!(condition)) \
1657 ret = -mtx_sleep(&(queue), &dev->irq_lock, \
1658 PCATCH, "drmwtq", (timeout)); \
1659 if (ret == -ERESTART) \
1660 ret = -ERESTARTSYS; \
1661 mtx_unlock(&dev->irq_lock); \
1662 DRM_LOCK(dev); \
1663}
1664
1665#define dev_err(dev, fmt, ...) \
1666 device_printf((dev), "error: " fmt, ## __VA_ARGS__)
1667#define dev_warn(dev, fmt, ...) \
1668 device_printf((dev), "warning: " fmt, ## __VA_ARGS__)
1669#define dev_info(dev, fmt, ...) \
1670 device_printf((dev), "info: " fmt, ## __VA_ARGS__)
1671#define dev_dbg(dev, fmt, ...) do { \
1672 if ((drm_debug& DRM_DEBUGBITS_KMS) != 0) { \
1673 device_printf((dev), "debug: " fmt, ## __VA_ARGS__); \
1674 } \
1675} while (0)
1676
1677struct drm_msi_blacklist_entry
1678{
1679 int vendor;
1680 int device;
1681};
1682
1683struct drm_vblank_info {
1684 wait_queue_head_t queue; /* vblank wait queue */
1685 atomic_t count; /* number of VBLANK interrupts */
1686 /* (driver must alloc the right number of counters) */
1687 atomic_t refcount; /* number of users of vblank interrupts */
1688 u32 last; /* protected by dev->vbl_lock, used */
1689 /* for wraparound handling */
1690 int enabled; /* so we don't call enable more than */
1691 /* once per disable */
1692 int inmodeset; /* Display driver is setting mode */
1693};
1694
1695#ifndef DMA_BIT_MASK
1696#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : (1ULL<<(n)) - 1)
1697#endif
1698
1699#define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
1700
1701enum dmi_field {
1702 DMI_NONE,
1703 DMI_BIOS_VENDOR,
1704 DMI_BIOS_VERSION,
1705 DMI_BIOS_DATE,
1706 DMI_SYS_VENDOR,
1707 DMI_PRODUCT_NAME,
1708 DMI_PRODUCT_VERSION,
1709 DMI_PRODUCT_SERIAL,
1710 DMI_PRODUCT_UUID,
1711 DMI_BOARD_VENDOR,
1712 DMI_BOARD_NAME,
1713 DMI_BOARD_VERSION,
1714 DMI_BOARD_SERIAL,
1715 DMI_BOARD_ASSET_TAG,
1716 DMI_CHASSIS_VENDOR,
1717 DMI_CHASSIS_TYPE,
1718 DMI_CHASSIS_VERSION,
1719 DMI_CHASSIS_SERIAL,
1720 DMI_CHASSIS_ASSET_TAG,
1721 DMI_STRING_MAX,
1722};
1723
1724struct dmi_strmatch {
1725 unsigned char slot;
1726 char substr[79];
1727};
1728
1729struct dmi_system_id {
1730 int (*callback)(const struct dmi_system_id *);
1731 const char *ident;
1732 struct dmi_strmatch matches[4];
1733};
1734#define DMI_MATCH(a, b) {(a), (b)}
1735bool dmi_check_system(const struct dmi_system_id *);
1736
1737/* Device setup support (drm_drv.c) */
1738int drm_probe_helper(device_t kdev, drm_pci_id_list_t *idlist);
1739int drm_attach_helper(device_t kdev, drm_pci_id_list_t *idlist,
1740 struct drm_driver *driver);
1741int drm_generic_detach(device_t kdev);
1742
1743void drm_event_wakeup(struct drm_pending_event *e);
1744
1745int drm_add_busid_modesetting(struct drm_device *dev,
1746 struct sysctl_ctx_list *ctx, struct sysctl_oid *top);
1747
1748/* Buffer management support (drm_bufs.c) */
1749unsigned long drm_get_resource_start(struct drm_device *dev,
1750 unsigned int resource);
1751unsigned long drm_get_resource_len(struct drm_device *dev,
1752 unsigned int resource);
1753
1754/* IRQ support (drm_irq.c) */
1755irqreturn_t drm_irq_handler(DRM_IRQ_ARGS);
1756void drm_driver_irq_preinstall(struct drm_device *dev);
1757void drm_driver_irq_postinstall(struct drm_device *dev);
1758void drm_driver_irq_uninstall(struct drm_device *dev);
1759
1760/* AGP/PCI Express/GART support (drm_agpsupport.c) */
1761void *drm_agp_allocate_memory(size_t pages, u32 type);
1762int drm_agp_free_memory(void *handle);
1763int drm_agp_bind_memory(void *handle, off_t start);
1764int drm_agp_unbind_memory(void *handle);
1765
1766/* sysctl support (drm_sysctl.h) */
1767extern int drm_sysctl_init(struct drm_device *dev);
1768extern int drm_sysctl_cleanup(struct drm_device *dev);
1769
1770int drm_version(struct drm_device *dev, void *data,
1771 struct drm_file *file_priv);
1772
1773/* consistent PCI memory functions (drm_pci.c) */
1774int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master);
1775int drm_pci_set_unique(struct drm_device *dev, struct drm_master *master,
1776 struct drm_unique *u);
1777int drm_pci_agp_init(struct drm_device *dev);
1778int drm_pci_enable_msi(struct drm_device *dev);
1779void drm_pci_disable_msi(struct drm_device *dev);
1780
1781struct ttm_bo_device;
1782int ttm_bo_mmap_single(struct ttm_bo_device *bdev, vm_ooffset_t *offset,
1783 vm_size_t size, struct vm_object **obj_res, int nprot);
1784struct ttm_buffer_object;
1785void ttm_bo_release_mmap(struct ttm_buffer_object *bo);
1786
1787#endif /* __KERNEL__ */
1788#endif