2005-04-17 00:20:36 +02:00
|
|
|
/**
|
2005-09-25 06:28:13 +02:00
|
|
|
* \file drmP.h
|
2005-04-17 00:20:36 +02:00
|
|
|
* Private header for Direct Rendering Manager
|
2005-09-25 06:28:13 +02:00
|
|
|
*
|
2005-04-17 00:20:36 +02:00
|
|
|
* \author Rickard E. (Rik) Faith <faith@valinux.com>
|
|
|
|
* \author Gareth Hughes <gareth@valinux.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
|
|
|
|
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _DRM_P_H_
|
|
|
|
#define _DRM_P_H_
|
|
|
|
|
|
|
|
/* If you want the memory alloc debug functionality, change define below */
|
|
|
|
/* #define DEBUG_MEMORY */
|
|
|
|
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
#ifdef __alpha__
|
|
|
|
/* add include of current.h so that "current" is defined
|
|
|
|
* before static inline funcs in wait.h. Doing this so we
|
|
|
|
* can build the DRM (part of PI DRI). 4/21/2000 S + B */
|
|
|
|
#include <asm/current.h>
|
2005-09-25 06:28:13 +02:00
|
|
|
#endif /* __alpha__ */
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/miscdevice.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/smp_lock.h> /* For (un)lock_kernel */
|
2008-03-17 01:24:24 +01:00
|
|
|
#include <linux/dma-mapping.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/cdev.h>
|
2006-02-02 09:37:46 +01:00
|
|
|
#include <linux/mutex.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#if defined(__alpha__) || defined(__powerpc__)
|
2005-09-25 06:28:13 +02:00
|
|
|
#include <asm/pgtable.h> /* For pte_wrprotect */
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/mman.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#ifdef CONFIG_MTRR
|
|
|
|
#include <asm/mtrr.h>
|
|
|
|
#endif
|
|
|
|
#if defined(CONFIG_AGP) || defined(CONFIG_AGP_MODULE)
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/agp_backend.h>
|
|
|
|
#endif
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <asm/pgalloc.h>
|
|
|
|
#include "drm.h"
|
|
|
|
|
2007-07-17 02:46:52 +02:00
|
|
|
#include <linux/idr.h>
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
|
|
|
|
#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
|
|
|
|
|
2007-09-03 04:06:45 +02:00
|
|
|
struct drm_file;
|
|
|
|
struct drm_device;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#include "drm_os_linux.h"
|
2006-08-07 13:30:28 +02:00
|
|
|
#include "drm_hashtab.h"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/***********************************************************************/
|
|
|
|
/** \name DRM template customization defaults */
|
|
|
|
/*@{*/
|
|
|
|
|
|
|
|
/* driver capabilities and requirements mask */
|
|
|
|
#define DRIVER_USE_AGP 0x1
|
|
|
|
#define DRIVER_REQUIRE_AGP 0x2
|
|
|
|
#define DRIVER_USE_MTRR 0x4
|
|
|
|
#define DRIVER_PCI_DMA 0x8
|
|
|
|
#define DRIVER_SG 0x10
|
|
|
|
#define DRIVER_HAVE_DMA 0x20
|
|
|
|
#define DRIVER_HAVE_IRQ 0x40
|
|
|
|
#define DRIVER_IRQ_SHARED 0x80
|
2008-05-07 04:15:39 +02:00
|
|
|
#define DRIVER_IRQ_VBL 0x100
|
2005-04-17 00:20:36 +02:00
|
|
|
#define DRIVER_DMA_QUEUE 0x200
|
2005-07-10 06:46:12 +02:00
|
|
|
#define DRIVER_FB_DMA 0x400
|
2008-05-07 04:15:39 +02:00
|
|
|
#define DRIVER_IRQ_VBL2 0x800
|
2008-07-30 21:06:12 +02:00
|
|
|
#define DRIVER_GEM 0x1000
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/***********************************************************************/
|
|
|
|
/** \name Begin the DRM... */
|
|
|
|
/*@{*/
|
|
|
|
|
|
|
|
#define DRM_DEBUG_CODE 2 /**< Include debugging code if > 1, then
|
|
|
|
also include looping detection. */
|
|
|
|
|
2006-08-07 14:22:10 +02:00
|
|
|
#define DRM_MAGIC_HASH_ORDER 4 /**< Size of key hash table. Must be power of 2. */
|
2005-04-17 00:20:36 +02:00
|
|
|
#define DRM_KERNEL_CONTEXT 0 /**< Change drm_resctx if changed */
|
|
|
|
#define DRM_RESERVED_CONTEXTS 1 /**< Change drm_resctx if changed */
|
|
|
|
#define DRM_LOOPING_LIMIT 5000000
|
|
|
|
#define DRM_TIME_SLICE (HZ/20) /**< Time slice for GLXContexts */
|
|
|
|
#define DRM_LOCK_SLICE 1 /**< Time slice for lock, in jiffies */
|
|
|
|
|
|
|
|
#define DRM_FLAG_DEBUG 0x01
|
|
|
|
|
|
|
|
#define DRM_MEM_DMA 0
|
|
|
|
#define DRM_MEM_SAREA 1
|
|
|
|
#define DRM_MEM_DRIVER 2
|
|
|
|
#define DRM_MEM_MAGIC 3
|
|
|
|
#define DRM_MEM_IOCTLS 4
|
|
|
|
#define DRM_MEM_MAPS 5
|
|
|
|
#define DRM_MEM_VMAS 6
|
|
|
|
#define DRM_MEM_BUFS 7
|
|
|
|
#define DRM_MEM_SEGS 8
|
|
|
|
#define DRM_MEM_PAGES 9
|
|
|
|
#define DRM_MEM_FILES 10
|
|
|
|
#define DRM_MEM_QUEUES 11
|
|
|
|
#define DRM_MEM_CMDS 12
|
|
|
|
#define DRM_MEM_MAPPINGS 13
|
|
|
|
#define DRM_MEM_BUFLISTS 14
|
|
|
|
#define DRM_MEM_AGPLISTS 15
|
|
|
|
#define DRM_MEM_TOTALAGP 16
|
|
|
|
#define DRM_MEM_BOUNDAGP 17
|
|
|
|
#define DRM_MEM_CTXBITMAP 18
|
|
|
|
#define DRM_MEM_STUB 19
|
|
|
|
#define DRM_MEM_SGLISTS 20
|
2006-08-07 13:30:28 +02:00
|
|
|
#define DRM_MEM_CTXLIST 21
|
|
|
|
#define DRM_MEM_MM 22
|
|
|
|
#define DRM_MEM_HASHTAB 23
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
|
2006-08-07 14:36:47 +02:00
|
|
|
#define DRM_MAP_HASH_OFFSET 0x10000000
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@}*/
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/***********************************************************************/
|
|
|
|
/** \name Macros to make printk easier */
|
|
|
|
/*@{*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Error output.
|
|
|
|
*
|
|
|
|
* \param fmt printf() like format string.
|
|
|
|
* \param arg arguments
|
|
|
|
*/
|
|
|
|
#define DRM_ERROR(fmt, arg...) \
|
2008-04-30 09:55:10 +02:00
|
|
|
printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ##arg)
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Memory error output.
|
|
|
|
*
|
|
|
|
* \param area memory area where the error occurred.
|
|
|
|
* \param fmt printf() like format string.
|
|
|
|
* \param arg arguments
|
|
|
|
*/
|
|
|
|
#define DRM_MEM_ERROR(area, fmt, arg...) \
|
2008-04-30 09:55:10 +02:00
|
|
|
printk(KERN_ERR "[" DRM_NAME ":%s:%s] *ERROR* " fmt , __func__, \
|
2005-04-17 00:20:36 +02:00
|
|
|
drm_mem_stats[area].name , ##arg)
|
|
|
|
|
|
|
|
#define DRM_INFO(fmt, arg...) printk(KERN_INFO "[" DRM_NAME "] " fmt , ##arg)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Debug output.
|
2005-09-25 06:28:13 +02:00
|
|
|
*
|
2005-04-17 00:20:36 +02:00
|
|
|
* \param fmt printf() like format string.
|
|
|
|
* \param arg arguments
|
|
|
|
*/
|
|
|
|
#if DRM_DEBUG_CODE
|
|
|
|
#define DRM_DEBUG(fmt, arg...) \
|
|
|
|
do { \
|
|
|
|
if ( drm_debug ) \
|
|
|
|
printk(KERN_DEBUG \
|
|
|
|
"[" DRM_NAME ":%s] " fmt , \
|
2008-04-30 09:55:10 +02:00
|
|
|
__func__ , ##arg); \
|
2005-04-17 00:20:36 +02:00
|
|
|
} while (0)
|
|
|
|
#else
|
|
|
|
#define DRM_DEBUG(fmt, arg...) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define DRM_PROC_LIMIT (PAGE_SIZE-80)
|
|
|
|
|
|
|
|
#define DRM_PROC_PRINT(fmt, arg...) \
|
|
|
|
len += sprintf(&buf[len], fmt , ##arg); \
|
|
|
|
if (len > DRM_PROC_LIMIT) { *eof = 1; return len - offset; }
|
|
|
|
|
|
|
|
#define DRM_PROC_PRINT_RET(ret, fmt, arg...) \
|
|
|
|
len += sprintf(&buf[len], fmt , ##arg); \
|
|
|
|
if (len > DRM_PROC_LIMIT) { ret; *eof = 1; return len - offset; }
|
|
|
|
|
|
|
|
/*@}*/
|
|
|
|
|
|
|
|
/***********************************************************************/
|
|
|
|
/** \name Internal types and structures */
|
|
|
|
/*@{*/
|
|
|
|
|
2005-09-25 05:25:41 +02:00
|
|
|
#define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x)
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#define DRM_LEFTCOUNT(x) (((x)->rp + (x)->count - (x)->wp) % ((x)->count + 1))
|
|
|
|
#define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x))
|
|
|
|
#define DRM_WAITCOUNT(dev,idx) DRM_BUFCOUNT(&dev->queuelist[idx]->waitlist)
|
|
|
|
|
|
|
|
#define DRM_IF_VERSION(maj, min) (maj << 16 | min)
|
|
|
|
/**
|
|
|
|
* Get the private SAREA mapping.
|
|
|
|
*
|
|
|
|
* \param _dev DRM device.
|
|
|
|
* \param _ctx context number.
|
|
|
|
* \param _map output mapping.
|
|
|
|
*/
|
|
|
|
#define DRM_GET_PRIV_SAREA(_dev, _ctx, _map) do { \
|
|
|
|
(_map) = (_dev)->context_sareas[_ctx]; \
|
|
|
|
} while(0)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Test that the hardware lock is held by the caller, returning otherwise.
|
|
|
|
*
|
|
|
|
* \param dev DRM device.
|
|
|
|
* \param filp file pointer of the caller.
|
|
|
|
*/
|
2007-09-03 04:06:45 +02:00
|
|
|
#define LOCK_TEST_WITH_RETURN( dev, file_priv ) \
|
2005-04-17 00:20:36 +02:00
|
|
|
do { \
|
|
|
|
if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \
|
2007-09-03 04:06:45 +02:00
|
|
|
dev->lock.file_priv != file_priv ) { \
|
|
|
|
DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\
|
2008-04-30 09:55:10 +02:00
|
|
|
__func__, _DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ),\
|
2007-09-03 04:06:45 +02:00
|
|
|
dev->lock.file_priv, file_priv ); \
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Copy and IOCTL return string to user space
|
|
|
|
*/
|
|
|
|
#define DRM_COPY( name, value ) \
|
|
|
|
len = strlen( value ); \
|
|
|
|
if ( len > name##_len ) len = name##_len; \
|
|
|
|
name##_len = strlen( value ); \
|
|
|
|
if ( len && name ) { \
|
|
|
|
if ( copy_to_user( name, value, len ) ) \
|
|
|
|
return -EFAULT; \
|
|
|
|
}
|
2005-09-25 06:28:13 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* Ioctl function type.
|
|
|
|
*
|
|
|
|
* \param inode device inode.
|
2007-08-25 12:23:09 +02:00
|
|
|
* \param file_priv DRM file private pointer.
|
2005-04-17 00:20:36 +02:00
|
|
|
* \param cmd command.
|
|
|
|
* \param arg argument.
|
|
|
|
*/
|
2007-09-03 04:06:45 +02:00
|
|
|
typedef int drm_ioctl_t(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
drm: 32/64-bit DRM ioctl compatibility patch
The patch is against a 2.6.11 kernel tree. I am running this with a
32-bit X server (compiled up from X.org CVS as of a couple of weeks
ago) and 32-bit DRI libraries and clients. All the userland stuff is
identical to what I am using under a 32-bit kernel on my G4 powerbook
(which is a 32-bit machine of course). I haven't tried compiling up a
64-bit X server or clients yet.
In the compatibility routines I have assumed that the kernel can
safely access user addresses after set_fs(KERNEL_DS). That is, where
an ioctl argument structure contains pointers to other structures, and
those other structures are already compatible between the 32-bit and
64-bit ABIs (i.e. they only contain things like chars, shorts or
ints), I just check the address with access_ok() and then pass it
through to the 64-bit ioctl code. I believe this approach may not
work on sparc64, but it does work on ppc64 and x86_64 at least.
One tricky area which may need to be revisited is the question of how
to handle the handles which we pass back to userspace to identify
mappings. These handles are generated in the ADDMAP ioctl and then
passed in as the offset value to mmap. However, offset values for
mmap seem to be generated in other ways as well, particularly for AGP
mappings.
The approach I have ended up with is to generate a fake 32-bit handle
only for _DRM_SHM mappings. The handles for other mappings (AGP, REG,
FB) are physical addresses which are already limited to 32 bits, and
generating fake handles for them created all sorts of problems in the
mmap/nopage code.
This patch has been updated to use the new compatibility ioctls.
From: Paul Mackerras <paulus@samba.org>
Signed-off-by: Dave Airlie <airlied@linux.ie>
2005-06-23 13:29:18 +02:00
|
|
|
typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd,
|
|
|
|
unsigned long arg);
|
|
|
|
|
2006-01-02 03:54:04 +01:00
|
|
|
#define DRM_AUTH 0x1
|
|
|
|
#define DRM_MASTER 0x2
|
|
|
|
#define DRM_ROOT_ONLY 0x4
|
|
|
|
|
2007-09-03 04:06:45 +02:00
|
|
|
struct drm_ioctl_desc {
|
|
|
|
unsigned int cmd;
|
2005-09-25 06:28:13 +02:00
|
|
|
drm_ioctl_t *func;
|
2006-01-02 03:54:04 +01:00
|
|
|
int flags;
|
2007-09-03 04:06:45 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a driver or general drm_ioctl_desc array entry for the given
|
|
|
|
* ioctl, for use by drm_ioctl().
|
|
|
|
*/
|
|
|
|
#define DRM_IOCTL_DEF(ioctl, func, flags) \
|
|
|
|
[DRM_IOCTL_NR(ioctl)] = {ioctl, func, flags}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-11 08:21:47 +02:00
|
|
|
struct drm_magic_entry {
|
2006-08-07 14:22:10 +02:00
|
|
|
struct list_head head;
|
2007-07-12 02:26:44 +02:00
|
|
|
struct drm_hash_item hash_item;
|
2005-09-25 06:28:13 +02:00
|
|
|
struct drm_file *priv;
|
2007-07-11 08:21:47 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-11 08:21:47 +02:00
|
|
|
struct drm_vma_entry {
|
2007-05-25 21:01:51 +02:00
|
|
|
struct list_head head;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct vm_area_struct *vma;
|
2005-09-25 06:28:13 +02:00
|
|
|
pid_t pid;
|
2007-07-11 08:21:47 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* DMA buffer.
|
|
|
|
*/
|
2007-07-11 08:17:42 +02:00
|
|
|
struct drm_buf {
|
2005-09-25 06:28:13 +02:00
|
|
|
int idx; /**< Index into master buflist */
|
|
|
|
int total; /**< Buffer size */
|
|
|
|
int order; /**< log-base-2(total) */
|
|
|
|
int used; /**< Amount of buffer in use (for DMA) */
|
|
|
|
unsigned long offset; /**< Byte offset (used internally) */
|
|
|
|
void *address; /**< Address of buffer */
|
|
|
|
unsigned long bus_address; /**< Bus address of buffer */
|
|
|
|
struct drm_buf *next; /**< Kernel-only: used for free list */
|
|
|
|
__volatile__ int waiting; /**< On kernel DMA queue */
|
|
|
|
__volatile__ int pending; /**< On hardware DMA queue */
|
2005-04-17 00:20:36 +02:00
|
|
|
wait_queue_head_t dma_wait; /**< Processes waiting */
|
2007-08-25 12:23:09 +02:00
|
|
|
struct drm_file *file_priv; /**< Private of holding file descr */
|
2005-09-25 06:28:13 +02:00
|
|
|
int context; /**< Kernel queue for this buffer */
|
|
|
|
int while_locked; /**< Dispatch this buffer while locked */
|
2005-04-17 00:20:36 +02:00
|
|
|
enum {
|
2005-09-25 06:28:13 +02:00
|
|
|
DRM_LIST_NONE = 0,
|
|
|
|
DRM_LIST_FREE = 1,
|
|
|
|
DRM_LIST_WAIT = 2,
|
|
|
|
DRM_LIST_PEND = 3,
|
|
|
|
DRM_LIST_PRIO = 4,
|
2005-04-17 00:20:36 +02:00
|
|
|
DRM_LIST_RECLAIM = 5
|
2005-09-25 06:28:13 +02:00
|
|
|
} list; /**< Which list we're on */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
int dev_priv_size; /**< Size of buffer private storage */
|
|
|
|
void *dev_private; /**< Per-buffer private storage */
|
2007-07-11 08:17:42 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** bufs is one longer than it has to be */
|
2007-07-11 08:32:08 +02:00
|
|
|
struct drm_waitlist {
|
2005-09-25 06:28:13 +02:00
|
|
|
int count; /**< Number of possible buffers */
|
2007-07-11 08:17:42 +02:00
|
|
|
struct drm_buf **bufs; /**< List of pointers to buffers */
|
|
|
|
struct drm_buf **rp; /**< Read pointer */
|
|
|
|
struct drm_buf **wp; /**< Write pointer */
|
|
|
|
struct drm_buf **end; /**< End pointer */
|
2005-09-25 06:28:13 +02:00
|
|
|
spinlock_t read_lock;
|
|
|
|
spinlock_t write_lock;
|
2007-07-11 08:32:08 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-11 08:32:08 +02:00
|
|
|
struct drm_freelist {
|
2005-09-25 06:28:13 +02:00
|
|
|
int initialized; /**< Freelist in use */
|
|
|
|
atomic_t count; /**< Number of free buffers */
|
2007-07-11 08:17:42 +02:00
|
|
|
struct drm_buf *next; /**< End pointer */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
wait_queue_head_t waiting; /**< Processes waiting on free bufs */
|
2005-09-25 06:28:13 +02:00
|
|
|
int low_mark; /**< Low water mark */
|
|
|
|
int high_mark; /**< High water mark */
|
|
|
|
atomic_t wfh; /**< If waiting for high mark */
|
|
|
|
spinlock_t lock;
|
2007-07-11 08:32:08 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-19 08:56:12 +01:00
|
|
|
typedef struct drm_dma_handle {
|
|
|
|
dma_addr_t busaddr;
|
|
|
|
void *vaddr;
|
|
|
|
size_t size;
|
|
|
|
} drm_dma_handle_t;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* Buffer entry. There is one of this for each buffer size order.
|
|
|
|
*/
|
2007-07-11 08:32:08 +02:00
|
|
|
struct drm_buf_entry {
|
2005-09-25 06:28:13 +02:00
|
|
|
int buf_size; /**< size */
|
|
|
|
int buf_count; /**< number of buffers */
|
2007-07-11 08:17:42 +02:00
|
|
|
struct drm_buf *buflist; /**< buffer list */
|
2005-09-25 06:28:13 +02:00
|
|
|
int seg_count;
|
|
|
|
int page_order;
|
2007-07-11 08:32:08 +02:00
|
|
|
struct drm_dma_handle **seglist;
|
2005-09-25 06:28:13 +02:00
|
|
|
|
2007-07-11 08:32:08 +02:00
|
|
|
struct drm_freelist freelist;
|
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** File private data */
|
2007-07-11 07:53:27 +02:00
|
|
|
struct drm_file {
|
2005-09-25 06:28:13 +02:00
|
|
|
int authenticated;
|
2006-01-02 03:54:04 +01:00
|
|
|
int master;
|
2005-09-25 06:28:13 +02:00
|
|
|
pid_t pid;
|
|
|
|
uid_t uid;
|
|
|
|
drm_magic_t magic;
|
|
|
|
unsigned long ioctl_count;
|
2007-05-25 21:01:51 +02:00
|
|
|
struct list_head lhead;
|
2008-04-21 08:47:32 +02:00
|
|
|
struct drm_minor *minor;
|
2005-09-25 06:28:13 +02:00
|
|
|
int remove_auth_on_close;
|
|
|
|
unsigned long lock_count;
|
2008-07-30 21:06:12 +02:00
|
|
|
/** Mapping of mm object handles to object pointers. */
|
|
|
|
struct idr object_idr;
|
|
|
|
/** Lock for synchronization of access to object_idr. */
|
|
|
|
spinlock_t table_lock;
|
2007-08-25 12:23:09 +02:00
|
|
|
struct file *filp;
|
2007-11-05 03:37:41 +01:00
|
|
|
void *driver_priv;
|
2007-07-11 07:53:27 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** Wait queue */
|
2007-07-11 08:32:08 +02:00
|
|
|
struct drm_queue {
|
2005-09-25 06:28:13 +02:00
|
|
|
atomic_t use_count; /**< Outstanding uses (+1) */
|
|
|
|
atomic_t finalization; /**< Finalization in progress */
|
|
|
|
atomic_t block_count; /**< Count of processes waiting */
|
|
|
|
atomic_t block_read; /**< Queue blocked for reads */
|
2005-04-17 00:20:36 +02:00
|
|
|
wait_queue_head_t read_queue; /**< Processes waiting on block_read */
|
2005-09-25 06:28:13 +02:00
|
|
|
atomic_t block_write; /**< Queue blocked for writes */
|
2005-04-17 00:20:36 +02:00
|
|
|
wait_queue_head_t write_queue; /**< Processes waiting on block_write */
|
2005-09-25 06:28:13 +02:00
|
|
|
atomic_t total_queued; /**< Total queued statistic */
|
|
|
|
atomic_t total_flushed; /**< Total flushes statistic */
|
|
|
|
atomic_t total_locks; /**< Total locks statistics */
|
2007-07-11 07:27:12 +02:00
|
|
|
enum drm_ctx_flags flags; /**< Context preserving and 2D-only */
|
2007-07-11 08:32:08 +02:00
|
|
|
struct drm_waitlist waitlist; /**< Pending buffers */
|
2005-04-17 00:20:36 +02:00
|
|
|
wait_queue_head_t flush_queue; /**< Processes waiting until flush */
|
2007-07-11 08:32:08 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Lock data.
|
|
|
|
*/
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_lock_data {
|
2007-07-11 07:27:12 +02:00
|
|
|
struct drm_hw_lock *hw_lock; /**< Hardware lock */
|
2007-11-05 03:37:41 +01:00
|
|
|
/** Private of lock holder's file (NULL=kernel) */
|
|
|
|
struct drm_file *file_priv;
|
2005-04-17 00:20:36 +02:00
|
|
|
wait_queue_head_t lock_queue; /**< Queue of blocked processes */
|
2005-09-25 06:28:13 +02:00
|
|
|
unsigned long lock_time; /**< Time of last lock in jiffies */
|
2007-03-23 03:28:33 +01:00
|
|
|
spinlock_t spinlock;
|
|
|
|
uint32_t kernel_waiters;
|
|
|
|
uint32_t user_waiters;
|
|
|
|
int idle_has_lock;
|
2007-07-11 08:53:40 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* DMA data.
|
|
|
|
*/
|
2007-07-11 08:32:08 +02:00
|
|
|
struct drm_device_dma {
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-11 08:32:08 +02:00
|
|
|
struct drm_buf_entry bufs[DRM_MAX_ORDER + 1]; /**< buffers, grouped by their size order */
|
2005-09-25 06:28:13 +02:00
|
|
|
int buf_count; /**< total number of buffers */
|
2007-07-11 08:17:42 +02:00
|
|
|
struct drm_buf **buflist; /**< Vector of pointers into drm_device_dma::bufs */
|
2005-09-25 06:28:13 +02:00
|
|
|
int seg_count;
|
|
|
|
int page_count; /**< number of pages */
|
|
|
|
unsigned long *pagelist; /**< page list */
|
|
|
|
unsigned long byte_count;
|
2005-04-17 00:20:36 +02:00
|
|
|
enum {
|
|
|
|
_DRM_DMA_USE_AGP = 0x01,
|
2005-09-25 06:28:13 +02:00
|
|
|
_DRM_DMA_USE_SG = 0x02,
|
2006-10-24 21:03:04 +02:00
|
|
|
_DRM_DMA_USE_FB = 0x04,
|
|
|
|
_DRM_DMA_USE_PCI_RO = 0x08
|
2005-04-17 00:20:36 +02:00
|
|
|
} flags;
|
|
|
|
|
2007-07-11 08:32:08 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
/**
|
2005-04-17 00:20:36 +02:00
|
|
|
* AGP memory entry. Stored as a doubly linked list.
|
|
|
|
*/
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_agp_mem {
|
2005-09-25 06:28:13 +02:00
|
|
|
unsigned long handle; /**< handle */
|
|
|
|
DRM_AGP_MEM *memory;
|
|
|
|
unsigned long bound; /**< address */
|
|
|
|
int pages;
|
2007-05-25 21:01:51 +02:00
|
|
|
struct list_head head;
|
2007-07-11 08:53:40 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* AGP data.
|
|
|
|
*
|
|
|
|
* \sa drm_agp_init() and drm_device::agp.
|
|
|
|
*/
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_agp_head {
|
2005-09-25 06:28:13 +02:00
|
|
|
DRM_AGP_KERN agp_info; /**< AGP device information */
|
2007-05-25 21:01:51 +02:00
|
|
|
struct list_head memory;
|
2005-09-25 06:28:13 +02:00
|
|
|
unsigned long mode; /**< AGP mode */
|
|
|
|
struct agp_bridge_data *bridge;
|
|
|
|
int enabled; /**< whether the AGP bus as been enabled */
|
|
|
|
int acquired; /**< whether the AGP device has been acquired */
|
|
|
|
unsigned long base;
|
|
|
|
int agp_mtrr;
|
|
|
|
int cant_use_aperture;
|
|
|
|
unsigned long page_mask;
|
2007-07-11 08:53:40 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Scatter-gather memory.
|
|
|
|
*/
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_sg_mem {
|
2005-09-25 06:28:13 +02:00
|
|
|
unsigned long handle;
|
|
|
|
void *virtual;
|
|
|
|
int pages;
|
|
|
|
struct page **pagelist;
|
|
|
|
dma_addr_t *busaddr;
|
2007-07-11 08:53:40 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_sigdata {
|
2005-09-25 06:28:13 +02:00
|
|
|
int context;
|
2007-07-11 07:27:12 +02:00
|
|
|
struct drm_hw_lock *lock;
|
2007-07-11 08:53:40 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-11-05 03:37:41 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Generic memory manager structs
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct drm_mm_node {
|
|
|
|
struct list_head fl_entry;
|
|
|
|
struct list_head ml_entry;
|
|
|
|
int free;
|
|
|
|
unsigned long start;
|
|
|
|
unsigned long size;
|
|
|
|
struct drm_mm *mm;
|
|
|
|
void *private;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct drm_mm {
|
|
|
|
struct list_head fl_entry;
|
|
|
|
struct list_head ml_entry;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* Mappings list
|
|
|
|
*/
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_map_list {
|
2005-09-25 06:28:13 +02:00
|
|
|
struct list_head head; /**< list head */
|
2007-07-12 02:26:44 +02:00
|
|
|
struct drm_hash_item hash;
|
2007-07-11 07:27:12 +02:00
|
|
|
struct drm_map *map; /**< mapping */
|
2007-11-05 03:37:41 +01:00
|
|
|
uint64_t user_token;
|
2007-07-11 08:53:40 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-11 07:27:12 +02:00
|
|
|
typedef struct drm_map drm_local_map_t;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Context handle list
|
|
|
|
*/
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_ctx_list {
|
2005-09-25 06:28:13 +02:00
|
|
|
struct list_head head; /**< list head */
|
|
|
|
drm_context_t handle; /**< context handle */
|
2007-07-11 07:53:27 +02:00
|
|
|
struct drm_file *tag; /**< associated fd private data */
|
2007-07-11 08:53:40 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_vbl_sig {
|
2005-09-25 06:28:13 +02:00
|
|
|
struct list_head head;
|
|
|
|
unsigned int sequence;
|
|
|
|
struct siginfo info;
|
|
|
|
struct task_struct *task;
|
2007-07-11 08:53:40 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-11 12:28:11 +02:00
|
|
|
/* location of GART table */
|
|
|
|
#define DRM_ATI_GART_MAIN 1
|
|
|
|
#define DRM_ATI_GART_FB 2
|
|
|
|
|
2007-05-08 07:19:23 +02:00
|
|
|
#define DRM_ATI_GART_PCI 1
|
|
|
|
#define DRM_ATI_GART_PCIE 2
|
|
|
|
#define DRM_ATI_GART_IGP 3
|
|
|
|
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_ati_pcigart_info {
|
2005-09-11 12:28:11 +02:00
|
|
|
int gart_table_location;
|
2007-05-08 07:19:23 +02:00
|
|
|
int gart_reg_if;
|
2006-01-02 07:18:39 +01:00
|
|
|
void *addr;
|
2005-09-11 12:28:11 +02:00
|
|
|
dma_addr_t bus_addr;
|
2008-03-17 01:24:24 +01:00
|
|
|
dma_addr_t table_mask;
|
|
|
|
struct drm_dma_handle *table_handle;
|
2006-01-02 07:18:39 +01:00
|
|
|
drm_local_map_t mapping;
|
2007-05-08 07:19:23 +02:00
|
|
|
int table_size;
|
2007-07-11 08:53:40 +02:00
|
|
|
};
|
2005-09-11 12:28:11 +02:00
|
|
|
|
2008-07-30 21:06:12 +02:00
|
|
|
/**
|
|
|
|
* This structure defines the drm_mm memory object, which will be used by the
|
|
|
|
* DRM for its buffer objects.
|
|
|
|
*/
|
|
|
|
struct drm_gem_object {
|
|
|
|
/** Reference count of this object */
|
|
|
|
struct kref refcount;
|
|
|
|
|
|
|
|
/** Handle count of this object. Each handle also holds a reference */
|
|
|
|
struct kref handlecount;
|
|
|
|
|
|
|
|
/** Related drm device */
|
|
|
|
struct drm_device *dev;
|
|
|
|
|
|
|
|
/** File representing the shmem storage */
|
|
|
|
struct file *filp;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Size of the object, in bytes. Immutable over the object's
|
|
|
|
* lifetime.
|
|
|
|
*/
|
|
|
|
size_t size;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Global name for this object, starts at 1. 0 means unnamed.
|
|
|
|
* Access is covered by the object_name_lock in the related drm_device
|
|
|
|
*/
|
|
|
|
int name;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Memory domains. These monitor which caches contain read/write data
|
|
|
|
* related to the object. When transitioning from one set of domains
|
|
|
|
* to another, the driver is called to ensure that caches are suitably
|
|
|
|
* flushed and invalidated
|
|
|
|
*/
|
|
|
|
uint32_t read_domains;
|
|
|
|
uint32_t write_domain;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* While validating an exec operation, the
|
|
|
|
* new read/write domain values are computed here.
|
|
|
|
* They will be transferred to the above values
|
|
|
|
* at the point that any cache flushing occurs
|
|
|
|
*/
|
|
|
|
uint32_t pending_read_domains;
|
|
|
|
uint32_t pending_write_domain;
|
|
|
|
|
|
|
|
void *driver_private;
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
|
|
|
* DRM driver structure. This structure represent the common code for
|
|
|
|
* a family of cards. There will one drm_device for each card present
|
|
|
|
* in this family
|
|
|
|
*/
|
|
|
|
struct drm_driver {
|
2005-11-10 12:16:34 +01:00
|
|
|
int (*load) (struct drm_device *, unsigned long flags);
|
|
|
|
int (*firstopen) (struct drm_device *);
|
2007-07-11 07:53:27 +02:00
|
|
|
int (*open) (struct drm_device *, struct drm_file *);
|
2007-08-25 12:23:09 +02:00
|
|
|
void (*preclose) (struct drm_device *, struct drm_file *file_priv);
|
2007-07-11 07:53:27 +02:00
|
|
|
void (*postclose) (struct drm_device *, struct drm_file *);
|
2005-11-10 12:16:34 +01:00
|
|
|
void (*lastclose) (struct drm_device *);
|
|
|
|
int (*unload) (struct drm_device *);
|
2008-02-20 01:02:20 +01:00
|
|
|
int (*suspend) (struct drm_device *, pm_message_t state);
|
2007-11-22 05:02:38 +01:00
|
|
|
int (*resume) (struct drm_device *);
|
2007-09-03 04:06:45 +02:00
|
|
|
int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
|
2005-09-25 06:28:13 +02:00
|
|
|
void (*dma_ready) (struct drm_device *);
|
|
|
|
int (*dma_quiescent) (struct drm_device *);
|
2007-07-11 07:53:27 +02:00
|
|
|
int (*context_ctor) (struct drm_device *dev, int context);
|
|
|
|
int (*context_dtor) (struct drm_device *dev, int context);
|
|
|
|
int (*kernel_context_switch) (struct drm_device *dev, int old,
|
2005-09-25 06:28:13 +02:00
|
|
|
int new);
|
2008-05-07 04:15:39 +02:00
|
|
|
void (*kernel_context_switch_unlock) (struct drm_device *dev);
|
|
|
|
int (*dri_library_name) (struct drm_device *dev, char *buf);
|
2005-09-25 06:28:13 +02:00
|
|
|
|
2008-09-30 21:14:26 +02:00
|
|
|
/**
|
|
|
|
* get_vblank_counter - get raw hardware vblank counter
|
|
|
|
* @dev: DRM device
|
|
|
|
* @crtc: counter to fetch
|
|
|
|
*
|
|
|
|
* Driver callback for fetching a raw hardware vblank counter
|
|
|
|
* for @crtc. If a device doesn't have a hardware counter, the
|
|
|
|
* driver can simply return the value of drm_vblank_count and
|
|
|
|
* make the enable_vblank() and disable_vblank() hooks into no-ops,
|
|
|
|
* leaving interrupts enabled at all times.
|
|
|
|
*
|
|
|
|
* Wraparound handling and loss of events due to modesetting is dealt
|
|
|
|
* with in the DRM core code.
|
|
|
|
*
|
|
|
|
* RETURNS
|
|
|
|
* Raw vblank counter value.
|
|
|
|
*/
|
|
|
|
u32 (*get_vblank_counter) (struct drm_device *dev, int crtc);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* enable_vblank - enable vblank interrupt events
|
|
|
|
* @dev: DRM device
|
|
|
|
* @crtc: which irq to enable
|
|
|
|
*
|
|
|
|
* Enable vblank interrupts for @crtc. If the device doesn't have
|
|
|
|
* a hardware vblank counter, this routine should be a no-op, since
|
|
|
|
* interrupts will have to stay on to keep the count accurate.
|
|
|
|
*
|
|
|
|
* RETURNS
|
|
|
|
* Zero on success, appropriate errno if the given @crtc's vblank
|
|
|
|
* interrupt cannot be enabled.
|
|
|
|
*/
|
|
|
|
int (*enable_vblank) (struct drm_device *dev, int crtc);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* disable_vblank - disable vblank interrupt events
|
|
|
|
* @dev: DRM device
|
|
|
|
* @crtc: which irq to enable
|
|
|
|
*
|
|
|
|
* Disable vblank interrupts for @crtc. If the device doesn't have
|
|
|
|
* a hardware vblank counter, this routine should be a no-op, since
|
|
|
|
* interrupts will have to stay on to keep the count accurate.
|
|
|
|
*/
|
|
|
|
void (*disable_vblank) (struct drm_device *dev, int crtc);
|
|
|
|
|
2005-07-10 09:31:26 +02:00
|
|
|
/**
|
|
|
|
* Called by \c drm_device_is_agp. Typically used to determine if a
|
|
|
|
* card is really attached to AGP or not.
|
|
|
|
*
|
|
|
|
* \param dev DRM device handle
|
|
|
|
*
|
|
|
|
* \returns
|
|
|
|
* One of three values is returned depending on whether or not the
|
|
|
|
* card is absolutely \b not AGP (return of 0), absolutely \b is AGP
|
|
|
|
* (return of 1), or may or may not be AGP (return of 2).
|
|
|
|
*/
|
2007-07-11 07:53:27 +02:00
|
|
|
int (*device_is_agp) (struct drm_device *dev);
|
2005-07-10 09:31:26 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* these have to be filled in */
|
2005-09-25 06:28:13 +02:00
|
|
|
|
2005-11-10 12:16:34 +01:00
|
|
|
irqreturn_t(*irq_handler) (DRM_IRQ_ARGS);
|
2007-07-11 07:53:27 +02:00
|
|
|
void (*irq_preinstall) (struct drm_device *dev);
|
2008-09-30 21:14:26 +02:00
|
|
|
int (*irq_postinstall) (struct drm_device *dev);
|
2007-07-11 07:53:27 +02:00
|
|
|
void (*irq_uninstall) (struct drm_device *dev);
|
2007-08-25 12:23:09 +02:00
|
|
|
void (*reclaim_buffers) (struct drm_device *dev,
|
|
|
|
struct drm_file * file_priv);
|
2006-01-02 11:32:48 +01:00
|
|
|
void (*reclaim_buffers_locked) (struct drm_device *dev,
|
2007-08-25 12:23:09 +02:00
|
|
|
struct drm_file *file_priv);
|
2007-03-23 03:28:33 +01:00
|
|
|
void (*reclaim_buffers_idlelocked) (struct drm_device *dev,
|
2007-08-25 12:23:09 +02:00
|
|
|
struct drm_file *file_priv);
|
2007-07-11 07:27:12 +02:00
|
|
|
unsigned long (*get_map_ofs) (struct drm_map * map);
|
2007-07-11 07:53:27 +02:00
|
|
|
unsigned long (*get_reg_ofs) (struct drm_device *dev);
|
|
|
|
void (*set_version) (struct drm_device *dev,
|
2007-07-11 07:27:12 +02:00
|
|
|
struct drm_set_version *sv);
|
2005-11-10 12:16:34 +01:00
|
|
|
|
2008-07-30 21:06:12 +02:00
|
|
|
int (*proc_init)(struct drm_minor *minor);
|
|
|
|
void (*proc_cleanup)(struct drm_minor *minor);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Driver-specific constructor for drm_gem_objects, to set up
|
|
|
|
* obj->driver_private.
|
|
|
|
*
|
|
|
|
* Returns 0 on success.
|
|
|
|
*/
|
|
|
|
int (*gem_init_object) (struct drm_gem_object *obj);
|
|
|
|
void (*gem_free_object) (struct drm_gem_object *obj);
|
|
|
|
|
2005-11-10 12:16:34 +01:00
|
|
|
int major;
|
|
|
|
int minor;
|
|
|
|
int patchlevel;
|
|
|
|
char *name;
|
|
|
|
char *desc;
|
|
|
|
char *date;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
u32 driver_features;
|
|
|
|
int dev_priv_size;
|
2007-09-03 04:06:45 +02:00
|
|
|
struct drm_ioctl_desc *ioctls;
|
2005-04-17 00:20:36 +02:00
|
|
|
int num_ioctls;
|
|
|
|
struct file_operations fops;
|
|
|
|
struct pci_driver pci_driver;
|
|
|
|
};
|
|
|
|
|
2008-04-21 08:47:32 +02:00
|
|
|
#define DRM_MINOR_UNASSIGNED 0
|
|
|
|
#define DRM_MINOR_LEGACY 1
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/**
|
2008-04-21 08:47:32 +02:00
|
|
|
* DRM minor structure. This structure represents a drm minor number.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2008-04-21 08:47:32 +02:00
|
|
|
struct drm_minor {
|
|
|
|
int index; /**< Minor device number */
|
|
|
|
int type; /**< Control or render */
|
|
|
|
dev_t device; /**< Device number for mknod */
|
|
|
|
struct device kdev; /**< Linux device */
|
2005-04-17 00:20:36 +02:00
|
|
|
struct drm_device *dev;
|
|
|
|
struct proc_dir_entry *dev_root; /**< proc directory entry */
|
2007-07-11 07:53:27 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* DRM device structure. This structure represent a complete card that
|
|
|
|
* may contain multiple heads.
|
|
|
|
*/
|
2007-07-11 07:53:27 +02:00
|
|
|
struct drm_device {
|
2005-09-25 06:28:13 +02:00
|
|
|
char *unique; /**< Unique identifier: e.g., busid */
|
|
|
|
int unique_len; /**< Length of unique field */
|
|
|
|
char *devname; /**< For /proc/interrupts */
|
|
|
|
int if_version; /**< Highest interface version set */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
int blocked; /**< Blocked due to VC switch? */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** \name Locks */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@{ */
|
|
|
|
spinlock_t count_lock; /**< For inuse, drm_device::open_count, drm_device::buf_use */
|
2006-02-02 09:37:46 +01:00
|
|
|
struct mutex struct_mutex; /**< For others */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@} */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** \name Usage Counters */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@{ */
|
|
|
|
int open_count; /**< Outstanding files open */
|
|
|
|
atomic_t ioctl_count; /**< Outstanding IOCTLs pending */
|
|
|
|
atomic_t vma_count; /**< Outstanding vma areas open */
|
|
|
|
int buf_use; /**< Buffers in use -- cannot alloc */
|
|
|
|
atomic_t buf_alloc; /**< Buffer allocation in progress */
|
|
|
|
/*@} */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** \name Performance counters */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@{ */
|
|
|
|
unsigned long counters;
|
2007-07-11 07:27:12 +02:00
|
|
|
enum drm_stat_type types[15];
|
2005-09-25 06:28:13 +02:00
|
|
|
atomic_t counts[15];
|
|
|
|
/*@} */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** \name Authentication */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@{ */
|
2007-05-25 21:01:51 +02:00
|
|
|
struct list_head filelist;
|
2007-07-12 02:26:44 +02:00
|
|
|
struct drm_open_hash magiclist; /**< magic hash table */
|
2006-08-07 14:22:10 +02:00
|
|
|
struct list_head magicfree;
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@} */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** \name Memory management */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@{ */
|
2007-05-25 21:01:51 +02:00
|
|
|
struct list_head maplist; /**< Linked list of regions */
|
2005-09-25 06:28:13 +02:00
|
|
|
int map_count; /**< Number of mappable regions */
|
2007-07-12 02:26:44 +02:00
|
|
|
struct drm_open_hash map_hash; /**< User token hash table for maps */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** \name Context handle management */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@{ */
|
2007-05-25 21:01:51 +02:00
|
|
|
struct list_head ctxlist; /**< Linked list of context handles */
|
2005-09-25 06:28:13 +02:00
|
|
|
int ctx_count; /**< Number of context handles */
|
2006-02-02 09:37:46 +01:00
|
|
|
struct mutex ctxlist_mutex; /**< For ctxlist */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-17 02:46:52 +02:00
|
|
|
struct idr ctx_idr;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-25 21:01:51 +02:00
|
|
|
struct list_head vmalist; /**< List of vmas (for debugging) */
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_lock_data lock; /**< Information on hardware lock */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@} */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** \name DMA queues (contexts) */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@{ */
|
|
|
|
int queue_count; /**< Number of active DMA queues */
|
|
|
|
int queue_reserved; /**< Number of reserved DMA queues */
|
|
|
|
int queue_slots; /**< Actual length of queuelist */
|
2007-07-11 08:32:08 +02:00
|
|
|
struct drm_queue **queuelist; /**< Vector of pointers to DMA queues */
|
|
|
|
struct drm_device_dma *dma; /**< Optional pointer for DMA support */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@} */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/** \name Context support */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@{ */
|
|
|
|
int irq; /**< Interrupt used by board */
|
|
|
|
int irq_enabled; /**< True if irq handler is enabled */
|
2005-04-17 00:20:36 +02:00
|
|
|
__volatile__ long context_flag; /**< Context swapping flag */
|
|
|
|
__volatile__ long interrupt_flag; /**< Interruption handler flag */
|
|
|
|
__volatile__ long dma_flag; /**< DMA dispatch flag */
|
|
|
|
struct timer_list timer; /**< Timer for delaying ctx switch */
|
2005-09-25 06:28:13 +02:00
|
|
|
wait_queue_head_t context_wait; /**< Processes waiting on ctx switch */
|
|
|
|
int last_checked; /**< Last context checked for DMA */
|
|
|
|
int last_context; /**< Last current context */
|
|
|
|
unsigned long last_switch; /**< jiffies at last context switch */
|
|
|
|
/*@} */
|
|
|
|
|
|
|
|
struct work_struct work;
|
2005-04-17 00:20:36 +02:00
|
|
|
/** \name VBLANK IRQ support */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@{ */
|
|
|
|
|
2008-09-30 21:14:26 +02:00
|
|
|
/*
|
|
|
|
* At load time, disabling the vblank interrupt won't be allowed since
|
|
|
|
* old clients may not call the modeset ioctl and therefore misbehave.
|
|
|
|
* Once the modeset ioctl *has* been called though, we can safely
|
|
|
|
* disable them when unused.
|
|
|
|
*/
|
|
|
|
int vblank_disable_allowed;
|
|
|
|
|
|
|
|
wait_queue_head_t *vbl_queue; /**< VBLANK wait queue */
|
|
|
|
atomic_t *_vblank_count; /**< number of VBLANK interrupts (driver must alloc the right number of counters) */
|
2005-09-25 06:28:13 +02:00
|
|
|
spinlock_t vbl_lock;
|
2008-09-30 21:14:26 +02:00
|
|
|
struct list_head *vbl_sigs; /**< signal list to send on VBLANK */
|
|
|
|
atomic_t vbl_signal_pending; /* number of signals pending on all crtcs*/
|
|
|
|
atomic_t *vblank_refcount; /* number of users of vblank interruptsper crtc */
|
|
|
|
u32 *last_vblank; /* protected by dev->vbl_lock, used */
|
|
|
|
/* for wraparound handling */
|
|
|
|
int *vblank_enabled; /* so we don't call enable more than
|
|
|
|
once per disable */
|
|
|
|
int *vblank_inmodeset; /* Display driver is setting mode */
|
|
|
|
struct timer_list vblank_disable_timer;
|
|
|
|
|
|
|
|
u32 max_vblank_count; /**< size of vblank counter register */
|
2006-10-24 15:08:16 +02:00
|
|
|
spinlock_t tasklet_lock; /**< For drm_locked_tasklet */
|
|
|
|
void (*locked_tasklet_func)(struct drm_device *dev);
|
2005-09-25 06:28:13 +02:00
|
|
|
|
|
|
|
/*@} */
|
|
|
|
cycles_t ctx_start;
|
|
|
|
cycles_t lck_start;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
struct fasync_struct *buf_async;/**< Processes waiting for SIGIO */
|
|
|
|
wait_queue_head_t buf_readers; /**< Processes waiting to read */
|
|
|
|
wait_queue_head_t buf_writers; /**< Processes waiting to ctx switch */
|
|
|
|
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_agp_head *agp; /**< AGP data */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
struct pci_dev *pdev; /**< PCI device structure */
|
2006-09-21 20:19:34 +02:00
|
|
|
int pci_vendor; /**< PCI vendor id */
|
|
|
|
int pci_device; /**< PCI device id */
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef __alpha__
|
|
|
|
struct pci_controller *hose;
|
|
|
|
#endif
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_sg_mem *sg; /**< Scatter gather memory */
|
2008-09-30 21:14:26 +02:00
|
|
|
int num_crtcs; /**< Number of CRTCs on this device */
|
2005-09-25 06:28:13 +02:00
|
|
|
void *dev_private; /**< device private data */
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_sigdata sigdata; /**< For block_all_signals */
|
2005-09-25 06:28:13 +02:00
|
|
|
sigset_t sigmask;
|
|
|
|
|
|
|
|
struct drm_driver *driver;
|
|
|
|
drm_local_map_t *agp_buffer_map;
|
2005-08-05 14:11:22 +02:00
|
|
|
unsigned int agp_buffer_token;
|
2008-04-21 08:47:32 +02:00
|
|
|
struct drm_minor *primary; /**< render type primary screen head */
|
2006-10-24 15:04:19 +02:00
|
|
|
|
|
|
|
/** \name Drawable information */
|
|
|
|
/*@{ */
|
|
|
|
spinlock_t drw_lock;
|
2007-07-17 02:55:47 +02:00
|
|
|
struct idr drw_idr;
|
2006-10-24 15:04:19 +02:00
|
|
|
/*@} */
|
2008-07-30 21:06:12 +02:00
|
|
|
|
|
|
|
/** \name GEM information */
|
|
|
|
/*@{ */
|
|
|
|
spinlock_t object_name_lock;
|
|
|
|
struct idr object_name_idr;
|
|
|
|
atomic_t object_count;
|
|
|
|
atomic_t object_memory;
|
|
|
|
atomic_t pin_count;
|
|
|
|
atomic_t pin_memory;
|
|
|
|
atomic_t gtt_count;
|
|
|
|
atomic_t gtt_memory;
|
|
|
|
uint32_t gtt_total;
|
|
|
|
uint32_t invalidate_domains; /* domains pending invalidation */
|
|
|
|
uint32_t flush_domains; /* domains pending flush */
|
|
|
|
/*@} */
|
|
|
|
|
2007-07-11 07:53:27 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
static __inline__ int drm_core_check_feature(struct drm_device *dev,
|
|
|
|
int feature)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
return ((dev->driver->driver_features & feature) ? 1 : 0);
|
|
|
|
}
|
|
|
|
|
2006-08-07 12:23:42 +02:00
|
|
|
#ifdef __alpha__
|
2007-03-11 01:46:27 +01:00
|
|
|
#define drm_get_pci_domain(dev) dev->hose->index
|
2006-08-07 12:23:42 +02:00
|
|
|
#else
|
2006-09-21 19:37:19 +02:00
|
|
|
#define drm_get_pci_domain(dev) 0
|
2006-08-07 12:23:42 +02:00
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#if __OS_HAS_AGP
|
|
|
|
static inline int drm_core_has_AGP(struct drm_device *dev)
|
|
|
|
{
|
2005-09-25 06:28:13 +02:00
|
|
|
return drm_core_check_feature(dev, DRIVER_USE_AGP);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define drm_core_has_AGP(dev) (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if __OS_HAS_MTRR
|
|
|
|
static inline int drm_core_has_MTRR(struct drm_device *dev)
|
|
|
|
{
|
2005-09-25 06:28:13 +02:00
|
|
|
return drm_core_check_feature(dev, DRIVER_USE_MTRR);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-01-02 06:23:01 +01:00
|
|
|
|
|
|
|
#define DRM_MTRR_WC MTRR_TYPE_WRCOMB
|
|
|
|
|
|
|
|
static inline int drm_mtrr_add(unsigned long offset, unsigned long size,
|
|
|
|
unsigned int flags)
|
|
|
|
{
|
|
|
|
return mtrr_add(offset, size, flags, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int drm_mtrr_del(int handle, unsigned long offset,
|
|
|
|
unsigned long size, unsigned int flags)
|
|
|
|
{
|
|
|
|
return mtrr_del(handle, offset, size);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#else
|
|
|
|
#define drm_core_has_MTRR(dev) (0)
|
2006-01-12 10:44:30 +01:00
|
|
|
|
|
|
|
#define DRM_MTRR_WC 0
|
|
|
|
|
|
|
|
static inline int drm_mtrr_add(unsigned long offset, unsigned long size,
|
|
|
|
unsigned int flags)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int drm_mtrr_del(int handle, unsigned long offset,
|
|
|
|
unsigned long size, unsigned int flags)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/******************************************************************/
|
|
|
|
/** \name Internal function definitions */
|
|
|
|
/*@{*/
|
|
|
|
|
|
|
|
/* Driver support (drm_drv.h) */
|
2005-09-25 06:28:13 +02:00
|
|
|
extern int drm_init(struct drm_driver *driver);
|
|
|
|
extern void drm_exit(struct drm_driver *driver);
|
|
|
|
extern int drm_ioctl(struct inode *inode, struct file *filp,
|
|
|
|
unsigned int cmd, unsigned long arg);
|
|
|
|
extern long drm_compat_ioctl(struct file *filp,
|
|
|
|
unsigned int cmd, unsigned long arg);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_lastclose(struct drm_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Device support (drm_fops.h) */
|
2005-09-25 06:28:13 +02:00
|
|
|
extern int drm_open(struct inode *inode, struct file *filp);
|
|
|
|
extern int drm_stub_open(struct inode *inode, struct file *filp);
|
|
|
|
extern int drm_fasync(int fd, struct file *filp, int on);
|
|
|
|
extern int drm_release(struct inode *inode, struct file *filp);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Mapping support (drm_vm.h) */
|
2005-09-25 06:28:13 +02:00
|
|
|
extern int drm_mmap(struct file *filp, struct vm_area_struct *vma);
|
2007-11-05 04:07:28 +01:00
|
|
|
extern unsigned long drm_core_get_map_ofs(struct drm_map * map);
|
|
|
|
extern unsigned long drm_core_get_reg_ofs(struct drm_device *dev);
|
2005-09-25 06:28:13 +02:00
|
|
|
extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Memory management support (drm_memory.h) */
|
|
|
|
#include "drm_memory.h"
|
2005-09-25 06:28:13 +02:00
|
|
|
extern void drm_mem_init(void);
|
|
|
|
extern int drm_mem_info(char *buf, char **start, off_t offset,
|
|
|
|
int request, int *eof, void *data);
|
|
|
|
extern void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area);
|
|
|
|
|
2007-07-11 07:53:27 +02:00
|
|
|
extern DRM_AGP_MEM *drm_alloc_agp(struct drm_device *dev, int pages, u32 type);
|
2005-09-25 06:28:13 +02:00
|
|
|
extern int drm_free_agp(DRM_AGP_MEM * handle, int pages);
|
|
|
|
extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start);
|
2008-07-30 21:06:12 +02:00
|
|
|
extern DRM_AGP_MEM *drm_agp_bind_pages(struct drm_device *dev,
|
|
|
|
struct page **pages,
|
|
|
|
unsigned long num_pages,
|
|
|
|
uint32_t gtt_offset);
|
2005-09-25 06:28:13 +02:00
|
|
|
extern int drm_unbind_agp(DRM_AGP_MEM * handle);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Misc. IOCTL support (drm_ioctl.h) */
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_irq_by_busid(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_getunique(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_setunique(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_getmap(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_getclient(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_getstats(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_setversion(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_noop(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Context IOCTL support (drm_context.h) */
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_resctx(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_addctx(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_modctx(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_getctx(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_switchctx(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_newctx(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_rmctx(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2005-09-25 06:28:13 +02:00
|
|
|
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_ctxbitmap_init(struct drm_device *dev);
|
|
|
|
extern void drm_ctxbitmap_cleanup(struct drm_device *dev);
|
|
|
|
extern void drm_ctxbitmap_free(struct drm_device *dev, int ctx_handle);
|
2005-09-25 06:28:13 +02:00
|
|
|
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_setsareactx(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_getsareactx(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Drawable IOCTL support (drm_drawable.h) */
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_adddraw(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_rmdraw(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_update_drawable_info(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern struct drm_drawable_info *drm_get_drawable_info(struct drm_device *dev,
|
2006-10-24 15:04:19 +02:00
|
|
|
drm_drawable_t id);
|
2007-07-17 02:55:47 +02:00
|
|
|
extern void drm_drawable_free_all(struct drm_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Authentication IOCTL support (drm_auth.h) */
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_getmagic(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_authmagic(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-07-30 21:06:12 +02:00
|
|
|
/* Cache management (drm_cache.c) */
|
|
|
|
void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Locking IOCTL support (drm_lock.h) */
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_lock(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_unlock(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2007-07-11 08:53:40 +02:00
|
|
|
extern int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
|
|
|
|
extern int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context);
|
|
|
|
extern void drm_idlelock_take(struct drm_lock_data *lock_data);
|
|
|
|
extern void drm_idlelock_release(struct drm_lock_data *lock_data);
|
2007-03-23 03:28:33 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* These are exported to drivers so that they can implement fencing using
|
|
|
|
* DMA quiscent + idle. DMA quiescent usually requires the hardware lock.
|
|
|
|
*/
|
|
|
|
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Buffer management support (drm_bufs.h) */
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request);
|
|
|
|
extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request);
|
|
|
|
extern int drm_addmap(struct drm_device *dev, unsigned int offset,
|
2007-07-11 07:27:12 +02:00
|
|
|
unsigned int size, enum drm_map_type type,
|
|
|
|
enum drm_map_flags flags, drm_local_map_t ** map_ptr);
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_addmap_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_rmmap(struct drm_device *dev, drm_local_map_t *map);
|
|
|
|
extern int drm_rmmap_locked(struct drm_device *dev, drm_local_map_t *map);
|
|
|
|
extern int drm_rmmap_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_addbufs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_infobufs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_markbufs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_freebufs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_mapbufs(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2005-09-25 06:28:13 +02:00
|
|
|
extern int drm_order(unsigned long size);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern unsigned long drm_get_resource_start(struct drm_device *dev,
|
2005-07-10 11:27:04 +02:00
|
|
|
unsigned int resource);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern unsigned long drm_get_resource_len(struct drm_device *dev,
|
2005-07-10 11:27:04 +02:00
|
|
|
unsigned int resource);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* DMA support (drm_dma.h) */
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_dma_setup(struct drm_device *dev);
|
|
|
|
extern void drm_dma_takedown(struct drm_device *dev);
|
2007-07-11 08:17:42 +02:00
|
|
|
extern void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf);
|
2007-08-25 12:23:09 +02:00
|
|
|
extern void drm_core_reclaim_buffers(struct drm_device *dev,
|
|
|
|
struct drm_file *filp);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* IRQ support (drm_irq.h) */
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_control(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2005-09-25 06:28:13 +02:00
|
|
|
extern irqreturn_t drm_irq_handler(DRM_IRQ_ARGS);
|
2008-08-20 17:04:27 +02:00
|
|
|
extern int drm_irq_install(struct drm_device *dev);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_irq_uninstall(struct drm_device *dev);
|
|
|
|
extern void drm_driver_irq_preinstall(struct drm_device *dev);
|
|
|
|
extern void drm_driver_irq_postinstall(struct drm_device *dev);
|
|
|
|
extern void drm_driver_irq_uninstall(struct drm_device *dev);
|
2005-09-25 06:28:13 +02:00
|
|
|
|
2008-09-30 21:14:26 +02:00
|
|
|
extern int drm_vblank_init(struct drm_device *dev, int num_crtcs);
|
2008-05-07 04:15:39 +02:00
|
|
|
extern int drm_wait_vblank(struct drm_device *dev, void *data,
|
2008-09-30 21:14:26 +02:00
|
|
|
struct drm_file *filp);
|
2008-05-07 04:15:39 +02:00
|
|
|
extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq);
|
2008-09-30 21:14:26 +02:00
|
|
|
extern void drm_locked_tasklet(struct drm_device *dev,
|
|
|
|
void(*func)(struct drm_device *));
|
|
|
|
extern u32 drm_vblank_count(struct drm_device *dev, int crtc);
|
|
|
|
extern void drm_handle_vblank(struct drm_device *dev, int crtc);
|
|
|
|
extern int drm_vblank_get(struct drm_device *dev, int crtc);
|
|
|
|
extern void drm_vblank_put(struct drm_device *dev, int crtc);
|
|
|
|
/* Modesetting support */
|
|
|
|
extern int drm_modeset_ctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2008-05-07 04:15:39 +02:00
|
|
|
extern void drm_locked_tasklet(struct drm_device *dev, void(*func)(struct drm_device*));
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* AGP/GART support (drm_agpsupport.h) */
|
2007-07-11 08:53:40 +02:00
|
|
|
extern struct drm_agp_head *drm_agp_init(struct drm_device *dev);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_agp_acquire(struct drm_device *dev);
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_agp_release(struct drm_device *dev);
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_agp_release_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode);
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_agp_enable_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info);
|
|
|
|
extern int drm_agp_info_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request);
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_agp_alloc_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request);
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_agp_free_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request);
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_agp_unbind_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request);
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge, size_t pages, u32 type);
|
2005-09-25 06:28:13 +02:00
|
|
|
extern int drm_agp_free_memory(DRM_AGP_MEM * handle);
|
|
|
|
extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start);
|
|
|
|
extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
|
2008-07-30 21:06:12 +02:00
|
|
|
extern void drm_agp_chipset_flush(struct drm_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Stub support (drm_stub.h) */
|
|
|
|
extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
|
2005-09-25 06:28:13 +02:00
|
|
|
struct drm_driver *driver);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_put_dev(struct drm_device *dev);
|
2008-04-21 08:47:32 +02:00
|
|
|
extern int drm_put_minor(struct drm_minor **minor);
|
2005-09-25 06:28:13 +02:00
|
|
|
extern unsigned int drm_debug;
|
2008-04-21 08:47:32 +02:00
|
|
|
|
2006-01-20 23:08:59 +01:00
|
|
|
extern struct class *drm_class;
|
2005-04-17 00:20:36 +02:00
|
|
|
extern struct proc_dir_entry *drm_proc_root;
|
|
|
|
|
2008-04-21 08:47:32 +02:00
|
|
|
extern struct idr drm_minors_idr;
|
|
|
|
|
2007-05-25 21:04:51 +02:00
|
|
|
extern drm_local_map_t *drm_getsarea(struct drm_device *dev);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Proc support (drm_proc.h) */
|
2008-04-21 08:47:32 +02:00
|
|
|
extern int drm_proc_init(struct drm_minor *minor, int minor_id,
|
|
|
|
struct proc_dir_entry *root);
|
|
|
|
extern int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Scatter Gather Support (drm_scatter.h) */
|
2007-07-11 08:53:40 +02:00
|
|
|
extern void drm_sg_cleanup(struct drm_sg_mem * entry);
|
2007-09-03 04:06:45 +02:00
|
|
|
extern int drm_sg_alloc_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request);
|
|
|
|
extern int drm_sg_free(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
/* ATI PCIGART support (ati_pcigart.h) */
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_ati_pcigart_init(struct drm_device *dev,
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_ati_pcigart_info * gart_info);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern int drm_ati_pcigart_cleanup(struct drm_device *dev,
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_ati_pcigart_info * gart_info);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-11 07:53:27 +02:00
|
|
|
extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size,
|
2005-07-10 07:38:56 +02:00
|
|
|
size_t align, dma_addr_t maxaddr);
|
2007-07-11 07:53:27 +02:00
|
|
|
extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
|
|
|
|
extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* sysfs support (drm_sysfs.c) */
|
2007-11-22 05:02:38 +01:00
|
|
|
struct drm_sysfs_class;
|
2006-01-20 23:08:59 +01:00
|
|
|
extern struct class *drm_sysfs_create(struct module *owner, char *name);
|
2007-11-22 05:02:38 +01:00
|
|
|
extern void drm_sysfs_destroy(void);
|
2008-04-21 08:47:32 +02:00
|
|
|
extern int drm_sysfs_device_add(struct drm_minor *minor);
|
|
|
|
extern void drm_sysfs_device_remove(struct drm_minor *minor);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-08-07 13:30:28 +02:00
|
|
|
/*
|
|
|
|
* Basic memory manager support (drm_mm.c)
|
|
|
|
*/
|
2007-07-11 08:53:40 +02:00
|
|
|
extern struct drm_mm_node *drm_mm_get_block(struct drm_mm_node * parent,
|
2006-08-07 13:30:28 +02:00
|
|
|
unsigned long size,
|
|
|
|
unsigned alignment);
|
2007-11-05 03:37:41 +01:00
|
|
|
extern void drm_mm_put_block(struct drm_mm_node * cur);
|
2007-07-11 08:53:40 +02:00
|
|
|
extern struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm, unsigned long size,
|
2006-08-07 13:30:28 +02:00
|
|
|
unsigned alignment, int best_match);
|
2007-07-11 08:53:40 +02:00
|
|
|
extern int drm_mm_init(struct drm_mm *mm, unsigned long start, unsigned long size);
|
|
|
|
extern void drm_mm_takedown(struct drm_mm *mm);
|
|
|
|
extern int drm_mm_clean(struct drm_mm *mm);
|
|
|
|
extern unsigned long drm_mm_tail_space(struct drm_mm *mm);
|
|
|
|
extern int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size);
|
|
|
|
extern int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size);
|
2006-08-07 13:30:28 +02:00
|
|
|
|
2008-07-30 21:06:12 +02:00
|
|
|
/* Graphics Execution Manager library functions (drm_gem.c) */
|
|
|
|
int drm_gem_init(struct drm_device *dev);
|
|
|
|
void drm_gem_object_free(struct kref *kref);
|
|
|
|
struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev,
|
|
|
|
size_t size);
|
|
|
|
void drm_gem_object_handle_free(struct kref *kref);
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
drm_gem_object_reference(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
kref_get(&obj->refcount);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
drm_gem_object_unreference(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
if (obj == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
kref_put(&obj->refcount, drm_gem_object_free);
|
|
|
|
}
|
|
|
|
|
|
|
|
int drm_gem_handle_create(struct drm_file *file_priv,
|
|
|
|
struct drm_gem_object *obj,
|
|
|
|
int *handlep);
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
drm_gem_object_handle_reference(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
drm_gem_object_reference(obj);
|
|
|
|
kref_get(&obj->handlecount);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
drm_gem_object_handle_unreference(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
if (obj == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Must bump handle count first as this may be the last
|
|
|
|
* ref, in which case the object would disappear before we
|
|
|
|
* checked for a name
|
|
|
|
*/
|
|
|
|
kref_put(&obj->handlecount, drm_gem_object_handle_free);
|
|
|
|
drm_gem_object_unreference(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev,
|
|
|
|
struct drm_file *filp,
|
|
|
|
int handle);
|
|
|
|
int drm_gem_close_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
int drm_gem_flink_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
int drm_gem_open_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
void drm_gem_open(struct drm_device *dev, struct drm_file *file_private);
|
|
|
|
void drm_gem_release(struct drm_device *dev, struct drm_file *file_private);
|
|
|
|
|
2007-01-08 11:56:59 +01:00
|
|
|
extern void drm_core_ioremap(struct drm_map *map, struct drm_device *dev);
|
2008-07-15 07:48:05 +02:00
|
|
|
extern void drm_core_ioremap_wc(struct drm_map *map, struct drm_device *dev);
|
2007-01-08 11:56:59 +01:00
|
|
|
extern void drm_core_ioremapfree(struct drm_map *map, struct drm_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
static __inline__ struct drm_map *drm_core_findmap(struct drm_device *dev,
|
|
|
|
unsigned int token)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_map_list *_entry;
|
2007-05-25 21:01:51 +02:00
|
|
|
list_for_each_entry(_entry, &dev->maplist, head)
|
2005-09-25 06:28:13 +02:00
|
|
|
if (_entry->user_token == token)
|
|
|
|
return _entry->map;
|
2005-04-17 00:20:36 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-07-11 07:53:27 +02:00
|
|
|
static __inline__ int drm_device_is_agp(struct drm_device *dev)
|
2005-07-10 09:31:26 +02:00
|
|
|
{
|
2005-09-25 06:28:13 +02:00
|
|
|
if (dev->driver->device_is_agp != NULL) {
|
|
|
|
int err = (*dev->driver->device_is_agp) (dev);
|
|
|
|
|
2005-07-10 09:31:26 +02:00
|
|
|
if (err != 2) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP);
|
|
|
|
}
|
|
|
|
|
2007-07-11 07:53:27 +02:00
|
|
|
static __inline__ int drm_device_is_pcie(struct drm_device *dev)
|
2005-09-11 12:28:11 +02:00
|
|
|
{
|
|
|
|
return pci_find_capability(dev->pdev, PCI_CAP_ID_EXP);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static __inline__ void drm_core_dropmap(struct drm_map *map)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef DEBUG_MEMORY
|
|
|
|
/** Wrapper around kmalloc() */
|
|
|
|
static __inline__ void *drm_alloc(size_t size, int area)
|
|
|
|
{
|
|
|
|
return kmalloc(size, GFP_KERNEL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Wrapper around kfree() */
|
|
|
|
static __inline__ void drm_free(void *pt, size_t size, int area)
|
|
|
|
{
|
|
|
|
kfree(pt);
|
|
|
|
}
|
2005-07-07 12:33:26 +02:00
|
|
|
|
|
|
|
/** Wrapper around kcalloc() */
|
|
|
|
static __inline__ void *drm_calloc(size_t nmemb, size_t size, int area)
|
|
|
|
{
|
|
|
|
return kcalloc(nmemb, size, GFP_KERNEL);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
#else
|
|
|
|
extern void *drm_alloc(size_t size, int area);
|
|
|
|
extern void drm_free(void *pt, size_t size, int area);
|
2005-07-07 12:33:26 +02:00
|
|
|
extern void *drm_calloc(size_t nmemb, size_t size, int area);
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*@}*/
|
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
#endif /* __KERNEL__ */
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|