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.
|
2010-05-27 21:40:25 +02:00
|
|
|
* Copyright (c) 2009-2010, Code Aurora Forum.
|
2005-04-17 00:20:36 +02:00
|
|
|
* 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_
|
|
|
|
|
|
|
|
#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/kernel.h>
|
|
|
|
#include <linux/miscdevice.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/file.h>
|
2010-05-27 21:40:25 +02:00
|
|
|
#include <linux/platform_device.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/jiffies.h>
|
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>
|
2013-05-14 01:58:47 +02:00
|
|
|
#include <linux/io.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 09:04:11 +01:00
|
|
|
#include <linux/slab.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/mman.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/agp_backend.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <asm/pgalloc.h>
|
2012-10-02 19:01:03 +02:00
|
|
|
#include <drm/drm.h>
|
|
|
|
#include <drm/drm_sarea.h>
|
2013-07-24 21:07:52 +02:00
|
|
|
#include <drm/drm_vma_manager.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
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)))
|
|
|
|
|
2011-05-26 19:46:22 +02:00
|
|
|
struct module;
|
|
|
|
|
2007-09-03 04:06:45 +02:00
|
|
|
struct drm_file;
|
|
|
|
struct drm_device;
|
|
|
|
|
2012-10-28 18:28:06 +01:00
|
|
|
struct device_node;
|
2012-11-14 11:22:52 +01:00
|
|
|
struct videomode;
|
|
|
|
|
2012-10-02 19:01:25 +02:00
|
|
|
#include <drm/drm_os_linux.h>
|
|
|
|
#include <drm/drm_hashtab.h>
|
|
|
|
#include <drm/drm_mm.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
drm: add separate drm debugging levels
Now all the DRM debug info will be reported if the boot option of
"drm.debug=1" is added. Sometimes it is inconvenient to get the debug
info in KMS mode. We will get too much unrelated info.
This will separate several DRM debug levels and the debug level can be used
to print the different debug info. And the debug level is controlled by the
module parameter of drm.debug
In this patch it is divided into four debug levels;
drm_core, drm_driver, drm_kms, drm_mode.
At the same time we can get the different debug info by changing the debug
level. This can be done by adding the module parameter. Of course it can
be changed through the /sys/module/drm/parameters/debug after the system is
booted.
Four debug macro definitions are provided.
DRM_DEBUG(fmt, args...)
DRM_DEBUG_DRIVER(prefix, fmt, args...)
DRM_DEBUG_KMS(prefix, fmt, args...)
DRM_DEBUG_MODE(prefix, fmt, args...)
When the boot option of "drm.debug=4" is added, it will print the debug info
using DRM_DEBUG_KMS macro definition.
When the boot option of "drm.debug=6" is added, it will print the debug info
using DRM_DEBUG_KMS/DRM_DEBUG_DRIVER.
Sometimes we expect to print the value of an array.
For example: SDVO command,
In such case the following four DRM debug macro definitions are added:
DRM_LOG(fmt, args...)
DRM_LOG_DRIVER(fmt, args...)
DRM_LOG_KMS(fmt, args...)
DRM_LOG_MODE(fmt, args...)
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-06-02 08:09:47 +02:00
|
|
|
#define DRM_UT_CORE 0x01
|
|
|
|
#define DRM_UT_DRIVER 0x02
|
|
|
|
#define DRM_UT_KMS 0x04
|
2011-11-25 16:21:02 +01:00
|
|
|
#define DRM_UT_PRIME 0x08
|
2009-07-20 07:48:06 +02:00
|
|
|
/*
|
|
|
|
* Three debug levels are defined.
|
|
|
|
* drm_core, drm_driver, drm_kms
|
|
|
|
* drm_core level can be used in the generic drm code. For example:
|
|
|
|
* drm_ioctl, drm_mm, drm_memory
|
2011-03-31 03:57:33 +02:00
|
|
|
* The macro definition of DRM_DEBUG is used.
|
2009-07-20 07:48:06 +02:00
|
|
|
* DRM_DEBUG(fmt, args...)
|
|
|
|
* The debug info by using the DRM_DEBUG can be obtained by adding
|
|
|
|
* the boot option of "drm.debug=1".
|
|
|
|
*
|
|
|
|
* drm_driver level can be used in the specific drm driver. It is used
|
|
|
|
* to add the debug info related with the drm driver. For example:
|
|
|
|
* i915_drv, i915_dma, i915_gem, radeon_drv,
|
|
|
|
* The macro definition of DRM_DEBUG_DRIVER can be used.
|
|
|
|
* DRM_DEBUG_DRIVER(fmt, args...)
|
|
|
|
* The debug info by using the DRM_DEBUG_DRIVER can be obtained by
|
|
|
|
* adding the boot option of "drm.debug=0x02"
|
|
|
|
*
|
|
|
|
* drm_kms level can be used in the KMS code related with specific drm driver.
|
|
|
|
* It is used to add the debug info related with KMS mode. For example:
|
|
|
|
* the connector/crtc ,
|
|
|
|
* The macro definition of DRM_DEBUG_KMS can be used.
|
|
|
|
* DRM_DEBUG_KMS(fmt, args...)
|
|
|
|
* The debug info by using the DRM_DEBUG_KMS can be obtained by
|
|
|
|
* adding the boot option of "drm.debug=0x04"
|
|
|
|
*
|
|
|
|
* If we add the boot option of "drm.debug=0x06", we can get the debug info by
|
|
|
|
* using the DRM_DEBUG_KMS and DRM_DEBUG_DRIVER.
|
|
|
|
* If we add the boot option of "drm.debug=0x05", we can get the debug info by
|
|
|
|
* using the DRM_DEBUG_KMS and DRM_DEBUG.
|
|
|
|
*/
|
drm: add separate drm debugging levels
Now all the DRM debug info will be reported if the boot option of
"drm.debug=1" is added. Sometimes it is inconvenient to get the debug
info in KMS mode. We will get too much unrelated info.
This will separate several DRM debug levels and the debug level can be used
to print the different debug info. And the debug level is controlled by the
module parameter of drm.debug
In this patch it is divided into four debug levels;
drm_core, drm_driver, drm_kms, drm_mode.
At the same time we can get the different debug info by changing the debug
level. This can be done by adding the module parameter. Of course it can
be changed through the /sys/module/drm/parameters/debug after the system is
booted.
Four debug macro definitions are provided.
DRM_DEBUG(fmt, args...)
DRM_DEBUG_DRIVER(prefix, fmt, args...)
DRM_DEBUG_KMS(prefix, fmt, args...)
DRM_DEBUG_MODE(prefix, fmt, args...)
When the boot option of "drm.debug=4" is added, it will print the debug info
using DRM_DEBUG_KMS macro definition.
When the boot option of "drm.debug=6" is added, it will print the debug info
using DRM_DEBUG_KMS/DRM_DEBUG_DRIVER.
Sometimes we expect to print the value of an array.
For example: SDVO command,
In such case the following four DRM debug macro definitions are added:
DRM_LOG(fmt, args...)
DRM_LOG_DRIVER(fmt, args...)
DRM_LOG_KMS(fmt, args...)
DRM_LOG_MODE(fmt, args...)
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-06-02 08:09:47 +02:00
|
|
|
|
2011-11-01 01:11:33 +01:00
|
|
|
extern __printf(4, 5)
|
2011-04-18 05:35:52 +02:00
|
|
|
void drm_ut_debug_printk(unsigned int request_level,
|
2011-11-01 01:11:33 +01:00
|
|
|
const char *prefix,
|
|
|
|
const char *function_name,
|
|
|
|
const char *format, ...);
|
|
|
|
extern __printf(2, 3)
|
2011-04-18 05:35:51 +02:00
|
|
|
int drm_err(const char *func, const char *format, ...);
|
|
|
|
|
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_PCI_DMA 0x8
|
|
|
|
#define DRIVER_SG 0x10
|
|
|
|
#define DRIVER_HAVE_DMA 0x20
|
|
|
|
#define DRIVER_HAVE_IRQ 0x40
|
|
|
|
#define DRIVER_IRQ_SHARED 0x80
|
2008-07-30 21:06:12 +02:00
|
|
|
#define DRIVER_GEM 0x1000
|
2008-11-07 23:05:41 +01:00
|
|
|
#define DRIVER_MODESET 0x2000
|
2011-11-25 16:21:02 +01:00
|
|
|
#define DRIVER_PRIME 0x4000
|
drm: implement experimental render nodes
Render nodes provide an API for userspace to use non-privileged GPU
commands without any running DRM-Master. It is useful for offscreen
rendering, GPGPU clients, and normal render clients which do not perform
modesetting.
Compared to legacy clients, render clients no longer need any
authentication to perform client ioctls. Instead, user-space controls
render/client access to GPUs via filesystem access-modes on the
render-node. Once a render-node was opened, a client has full access to
the client/render operations on the GPU. However, no modesetting or ioctls
that affect global state are allowed on render nodes.
To prevent privilege-escalation, drivers must explicitly state that they
support render nodes. They must mark their render-only ioctls as
DRM_RENDER_ALLOW so render clients can use them. Furthermore, they must
support clients without any attached master.
If filesystem access-modes are not enough for fine-grained access control
to render nodes (very unlikely, considering the versaitlity of FS-ACLs),
you may still fall-back to fd-passing from server to client (which allows
arbitrary access-control). However, note that revoking access is
currently impossible and unlikely to get implemented.
Note: Render clients no longer have any associated DRM-Master as they are
supposed to be independent of any server state. DRM core highly depends on
file_priv->master to be non-NULL for modesetting/ctx/etc. commands.
Therefore, drivers must be very careful to not require DRM-Master if they
support DRIVER_RENDER.
So far render-nodes are protected by "drm_rnodes". As long as this
module-parameter is not set to 1, a driver will not create render nodes.
This allows us to experiment with the API a bit before we stabilize it.
v2: drop insecure GEM_FLINK to force use of dmabuf
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-08-25 18:29:00 +02:00
|
|
|
#define DRIVER_RENDER 0x8000
|
2010-12-14 18:16:38 +01:00
|
|
|
|
|
|
|
#define DRIVER_BUS_PCI 0x1
|
|
|
|
#define DRIVER_BUS_PLATFORM 0x2
|
|
|
|
#define DRIVER_BUS_USB 0x3
|
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 */
|
|
|
|
|
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
|
|
|
|
*/
|
2011-04-18 05:35:51 +02:00
|
|
|
#define DRM_ERROR(fmt, ...) \
|
|
|
|
drm_err(__func__, fmt, ##__VA_ARGS__)
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-04-18 05:35:51 +02:00
|
|
|
#define DRM_INFO(fmt, ...) \
|
|
|
|
printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__)
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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
|
drm: add separate drm debugging levels
Now all the DRM debug info will be reported if the boot option of
"drm.debug=1" is added. Sometimes it is inconvenient to get the debug
info in KMS mode. We will get too much unrelated info.
This will separate several DRM debug levels and the debug level can be used
to print the different debug info. And the debug level is controlled by the
module parameter of drm.debug
In this patch it is divided into four debug levels;
drm_core, drm_driver, drm_kms, drm_mode.
At the same time we can get the different debug info by changing the debug
level. This can be done by adding the module parameter. Of course it can
be changed through the /sys/module/drm/parameters/debug after the system is
booted.
Four debug macro definitions are provided.
DRM_DEBUG(fmt, args...)
DRM_DEBUG_DRIVER(prefix, fmt, args...)
DRM_DEBUG_KMS(prefix, fmt, args...)
DRM_DEBUG_MODE(prefix, fmt, args...)
When the boot option of "drm.debug=4" is added, it will print the debug info
using DRM_DEBUG_KMS macro definition.
When the boot option of "drm.debug=6" is added, it will print the debug info
using DRM_DEBUG_KMS/DRM_DEBUG_DRIVER.
Sometimes we expect to print the value of an array.
For example: SDVO command,
In such case the following four DRM debug macro definitions are added:
DRM_LOG(fmt, args...)
DRM_LOG_DRIVER(fmt, args...)
DRM_LOG_KMS(fmt, args...)
DRM_LOG_MODE(fmt, args...)
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-06-02 08:09:47 +02:00
|
|
|
#define DRM_DEBUG(fmt, args...) \
|
2005-04-17 00:20:36 +02:00
|
|
|
do { \
|
drm: add separate drm debugging levels
Now all the DRM debug info will be reported if the boot option of
"drm.debug=1" is added. Sometimes it is inconvenient to get the debug
info in KMS mode. We will get too much unrelated info.
This will separate several DRM debug levels and the debug level can be used
to print the different debug info. And the debug level is controlled by the
module parameter of drm.debug
In this patch it is divided into four debug levels;
drm_core, drm_driver, drm_kms, drm_mode.
At the same time we can get the different debug info by changing the debug
level. This can be done by adding the module parameter. Of course it can
be changed through the /sys/module/drm/parameters/debug after the system is
booted.
Four debug macro definitions are provided.
DRM_DEBUG(fmt, args...)
DRM_DEBUG_DRIVER(prefix, fmt, args...)
DRM_DEBUG_KMS(prefix, fmt, args...)
DRM_DEBUG_MODE(prefix, fmt, args...)
When the boot option of "drm.debug=4" is added, it will print the debug info
using DRM_DEBUG_KMS macro definition.
When the boot option of "drm.debug=6" is added, it will print the debug info
using DRM_DEBUG_KMS/DRM_DEBUG_DRIVER.
Sometimes we expect to print the value of an array.
For example: SDVO command,
In such case the following four DRM debug macro definitions are added:
DRM_LOG(fmt, args...)
DRM_LOG_DRIVER(fmt, args...)
DRM_LOG_KMS(fmt, args...)
DRM_LOG_MODE(fmt, args...)
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-06-02 08:09:47 +02:00
|
|
|
drm_ut_debug_printk(DRM_UT_CORE, DRM_NAME, \
|
|
|
|
__func__, fmt, ##args); \
|
|
|
|
} while (0)
|
|
|
|
|
2009-07-20 07:48:04 +02:00
|
|
|
#define DRM_DEBUG_DRIVER(fmt, args...) \
|
drm: add separate drm debugging levels
Now all the DRM debug info will be reported if the boot option of
"drm.debug=1" is added. Sometimes it is inconvenient to get the debug
info in KMS mode. We will get too much unrelated info.
This will separate several DRM debug levels and the debug level can be used
to print the different debug info. And the debug level is controlled by the
module parameter of drm.debug
In this patch it is divided into four debug levels;
drm_core, drm_driver, drm_kms, drm_mode.
At the same time we can get the different debug info by changing the debug
level. This can be done by adding the module parameter. Of course it can
be changed through the /sys/module/drm/parameters/debug after the system is
booted.
Four debug macro definitions are provided.
DRM_DEBUG(fmt, args...)
DRM_DEBUG_DRIVER(prefix, fmt, args...)
DRM_DEBUG_KMS(prefix, fmt, args...)
DRM_DEBUG_MODE(prefix, fmt, args...)
When the boot option of "drm.debug=4" is added, it will print the debug info
using DRM_DEBUG_KMS macro definition.
When the boot option of "drm.debug=6" is added, it will print the debug info
using DRM_DEBUG_KMS/DRM_DEBUG_DRIVER.
Sometimes we expect to print the value of an array.
For example: SDVO command,
In such case the following four DRM debug macro definitions are added:
DRM_LOG(fmt, args...)
DRM_LOG_DRIVER(fmt, args...)
DRM_LOG_KMS(fmt, args...)
DRM_LOG_MODE(fmt, args...)
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-06-02 08:09:47 +02:00
|
|
|
do { \
|
2009-07-20 07:48:04 +02:00
|
|
|
drm_ut_debug_printk(DRM_UT_DRIVER, DRM_NAME, \
|
drm: add separate drm debugging levels
Now all the DRM debug info will be reported if the boot option of
"drm.debug=1" is added. Sometimes it is inconvenient to get the debug
info in KMS mode. We will get too much unrelated info.
This will separate several DRM debug levels and the debug level can be used
to print the different debug info. And the debug level is controlled by the
module parameter of drm.debug
In this patch it is divided into four debug levels;
drm_core, drm_driver, drm_kms, drm_mode.
At the same time we can get the different debug info by changing the debug
level. This can be done by adding the module parameter. Of course it can
be changed through the /sys/module/drm/parameters/debug after the system is
booted.
Four debug macro definitions are provided.
DRM_DEBUG(fmt, args...)
DRM_DEBUG_DRIVER(prefix, fmt, args...)
DRM_DEBUG_KMS(prefix, fmt, args...)
DRM_DEBUG_MODE(prefix, fmt, args...)
When the boot option of "drm.debug=4" is added, it will print the debug info
using DRM_DEBUG_KMS macro definition.
When the boot option of "drm.debug=6" is added, it will print the debug info
using DRM_DEBUG_KMS/DRM_DEBUG_DRIVER.
Sometimes we expect to print the value of an array.
For example: SDVO command,
In such case the following four DRM debug macro definitions are added:
DRM_LOG(fmt, args...)
DRM_LOG_DRIVER(fmt, args...)
DRM_LOG_KMS(fmt, args...)
DRM_LOG_MODE(fmt, args...)
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-06-02 08:09:47 +02:00
|
|
|
__func__, fmt, ##args); \
|
|
|
|
} while (0)
|
2009-07-20 07:48:04 +02:00
|
|
|
#define DRM_DEBUG_KMS(fmt, args...) \
|
drm: add separate drm debugging levels
Now all the DRM debug info will be reported if the boot option of
"drm.debug=1" is added. Sometimes it is inconvenient to get the debug
info in KMS mode. We will get too much unrelated info.
This will separate several DRM debug levels and the debug level can be used
to print the different debug info. And the debug level is controlled by the
module parameter of drm.debug
In this patch it is divided into four debug levels;
drm_core, drm_driver, drm_kms, drm_mode.
At the same time we can get the different debug info by changing the debug
level. This can be done by adding the module parameter. Of course it can
be changed through the /sys/module/drm/parameters/debug after the system is
booted.
Four debug macro definitions are provided.
DRM_DEBUG(fmt, args...)
DRM_DEBUG_DRIVER(prefix, fmt, args...)
DRM_DEBUG_KMS(prefix, fmt, args...)
DRM_DEBUG_MODE(prefix, fmt, args...)
When the boot option of "drm.debug=4" is added, it will print the debug info
using DRM_DEBUG_KMS macro definition.
When the boot option of "drm.debug=6" is added, it will print the debug info
using DRM_DEBUG_KMS/DRM_DEBUG_DRIVER.
Sometimes we expect to print the value of an array.
For example: SDVO command,
In such case the following four DRM debug macro definitions are added:
DRM_LOG(fmt, args...)
DRM_LOG_DRIVER(fmt, args...)
DRM_LOG_KMS(fmt, args...)
DRM_LOG_MODE(fmt, args...)
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-06-02 08:09:47 +02:00
|
|
|
do { \
|
2009-07-20 07:48:04 +02:00
|
|
|
drm_ut_debug_printk(DRM_UT_KMS, DRM_NAME, \
|
drm: add separate drm debugging levels
Now all the DRM debug info will be reported if the boot option of
"drm.debug=1" is added. Sometimes it is inconvenient to get the debug
info in KMS mode. We will get too much unrelated info.
This will separate several DRM debug levels and the debug level can be used
to print the different debug info. And the debug level is controlled by the
module parameter of drm.debug
In this patch it is divided into four debug levels;
drm_core, drm_driver, drm_kms, drm_mode.
At the same time we can get the different debug info by changing the debug
level. This can be done by adding the module parameter. Of course it can
be changed through the /sys/module/drm/parameters/debug after the system is
booted.
Four debug macro definitions are provided.
DRM_DEBUG(fmt, args...)
DRM_DEBUG_DRIVER(prefix, fmt, args...)
DRM_DEBUG_KMS(prefix, fmt, args...)
DRM_DEBUG_MODE(prefix, fmt, args...)
When the boot option of "drm.debug=4" is added, it will print the debug info
using DRM_DEBUG_KMS macro definition.
When the boot option of "drm.debug=6" is added, it will print the debug info
using DRM_DEBUG_KMS/DRM_DEBUG_DRIVER.
Sometimes we expect to print the value of an array.
For example: SDVO command,
In such case the following four DRM debug macro definitions are added:
DRM_LOG(fmt, args...)
DRM_LOG_DRIVER(fmt, args...)
DRM_LOG_KMS(fmt, args...)
DRM_LOG_MODE(fmt, args...)
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-06-02 08:09:47 +02:00
|
|
|
__func__, fmt, ##args); \
|
|
|
|
} while (0)
|
2011-11-25 16:21:02 +01:00
|
|
|
#define DRM_DEBUG_PRIME(fmt, args...) \
|
|
|
|
do { \
|
|
|
|
drm_ut_debug_printk(DRM_UT_PRIME, DRM_NAME, \
|
|
|
|
__func__, fmt, ##args); \
|
|
|
|
} while (0)
|
drm: add separate drm debugging levels
Now all the DRM debug info will be reported if the boot option of
"drm.debug=1" is added. Sometimes it is inconvenient to get the debug
info in KMS mode. We will get too much unrelated info.
This will separate several DRM debug levels and the debug level can be used
to print the different debug info. And the debug level is controlled by the
module parameter of drm.debug
In this patch it is divided into four debug levels;
drm_core, drm_driver, drm_kms, drm_mode.
At the same time we can get the different debug info by changing the debug
level. This can be done by adding the module parameter. Of course it can
be changed through the /sys/module/drm/parameters/debug after the system is
booted.
Four debug macro definitions are provided.
DRM_DEBUG(fmt, args...)
DRM_DEBUG_DRIVER(prefix, fmt, args...)
DRM_DEBUG_KMS(prefix, fmt, args...)
DRM_DEBUG_MODE(prefix, fmt, args...)
When the boot option of "drm.debug=4" is added, it will print the debug info
using DRM_DEBUG_KMS macro definition.
When the boot option of "drm.debug=6" is added, it will print the debug info
using DRM_DEBUG_KMS/DRM_DEBUG_DRIVER.
Sometimes we expect to print the value of an array.
For example: SDVO command,
In such case the following four DRM debug macro definitions are added:
DRM_LOG(fmt, args...)
DRM_LOG_DRIVER(fmt, args...)
DRM_LOG_KMS(fmt, args...)
DRM_LOG_MODE(fmt, args...)
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-06-02 08:09:47 +02:00
|
|
|
#define DRM_LOG(fmt, args...) \
|
|
|
|
do { \
|
|
|
|
drm_ut_debug_printk(DRM_UT_CORE, NULL, \
|
|
|
|
NULL, fmt, ##args); \
|
|
|
|
} while (0)
|
|
|
|
#define DRM_LOG_KMS(fmt, args...) \
|
|
|
|
do { \
|
|
|
|
drm_ut_debug_printk(DRM_UT_KMS, NULL, \
|
|
|
|
NULL, fmt, ##args); \
|
|
|
|
} while (0)
|
|
|
|
#define DRM_LOG_MODE(fmt, args...) \
|
|
|
|
do { \
|
|
|
|
drm_ut_debug_printk(DRM_UT_MODE, NULL, \
|
|
|
|
NULL, fmt, ##args); \
|
|
|
|
} while (0)
|
|
|
|
#define DRM_LOG_DRIVER(fmt, args...) \
|
|
|
|
do { \
|
|
|
|
drm_ut_debug_printk(DRM_UT_DRIVER, NULL, \
|
|
|
|
NULL, fmt, ##args); \
|
2005-04-17 00:20:36 +02:00
|
|
|
} while (0)
|
|
|
|
#else
|
2009-07-20 07:48:04 +02:00
|
|
|
#define DRM_DEBUG_DRIVER(fmt, args...) do { } while (0)
|
|
|
|
#define DRM_DEBUG_KMS(fmt, args...) do { } while (0)
|
2011-11-25 16:21:02 +01:00
|
|
|
#define DRM_DEBUG_PRIME(fmt, args...) do { } while (0)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define DRM_DEBUG(fmt, arg...) do { } while (0)
|
drm: add separate drm debugging levels
Now all the DRM debug info will be reported if the boot option of
"drm.debug=1" is added. Sometimes it is inconvenient to get the debug
info in KMS mode. We will get too much unrelated info.
This will separate several DRM debug levels and the debug level can be used
to print the different debug info. And the debug level is controlled by the
module parameter of drm.debug
In this patch it is divided into four debug levels;
drm_core, drm_driver, drm_kms, drm_mode.
At the same time we can get the different debug info by changing the debug
level. This can be done by adding the module parameter. Of course it can
be changed through the /sys/module/drm/parameters/debug after the system is
booted.
Four debug macro definitions are provided.
DRM_DEBUG(fmt, args...)
DRM_DEBUG_DRIVER(prefix, fmt, args...)
DRM_DEBUG_KMS(prefix, fmt, args...)
DRM_DEBUG_MODE(prefix, fmt, args...)
When the boot option of "drm.debug=4" is added, it will print the debug info
using DRM_DEBUG_KMS macro definition.
When the boot option of "drm.debug=6" is added, it will print the debug info
using DRM_DEBUG_KMS/DRM_DEBUG_DRIVER.
Sometimes we expect to print the value of an array.
For example: SDVO command,
In such case the following four DRM debug macro definitions are added:
DRM_LOG(fmt, args...)
DRM_LOG_DRIVER(fmt, args...)
DRM_LOG_KMS(fmt, args...)
DRM_LOG_MODE(fmt, args...)
Signed-off-by: Zhao Yakui <yakui.zhao@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2009-06-02 08:09:47 +02:00
|
|
|
#define DRM_LOG(fmt, arg...) do { } while (0)
|
|
|
|
#define DRM_LOG_KMS(fmt, args...) do { } while (0)
|
|
|
|
#define DRM_LOG_MODE(fmt, arg...) do { } while (0)
|
|
|
|
#define DRM_LOG_DRIVER(fmt, arg...) do { } while (0)
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*@}*/
|
|
|
|
|
|
|
|
/***********************************************************************/
|
|
|
|
/** \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_IF_VERSION(maj, min) (maj << 16 | min)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Test that the hardware lock is held by the caller, returning otherwise.
|
|
|
|
*
|
|
|
|
* \param dev DRM device.
|
|
|
|
* \param filp file pointer of the caller.
|
|
|
|
*/
|
2009-06-10 21:43:48 +02:00
|
|
|
#define LOCK_TEST_WITH_RETURN( dev, _file_priv ) \
|
|
|
|
do { \
|
|
|
|
if (!_DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock) || \
|
|
|
|
_file_priv->master->lock.file_priv != _file_priv) { \
|
2007-09-03 04:06:45 +02:00
|
|
|
DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\
|
2009-06-10 21:43:48 +02:00
|
|
|
__func__, _DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock),\
|
|
|
|
_file_priv->master->lock.file_priv, _file_priv); \
|
|
|
|
return -EINVAL; \
|
|
|
|
} \
|
2005-04-17 00:20:36 +02:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2009-12-02 18:13:48 +01:00
|
|
|
#define DRM_IOCTL_NR(n) _IOC_NR(n)
|
|
|
|
#define DRM_MAJOR 226
|
|
|
|
|
2006-01-02 03:54:04 +01:00
|
|
|
#define DRM_AUTH 0x1
|
|
|
|
#define DRM_MASTER 0x2
|
|
|
|
#define DRM_ROOT_ONLY 0x4
|
2008-11-07 23:05:41 +01:00
|
|
|
#define DRM_CONTROL_ALLOW 0x8
|
2009-12-16 23:17:09 +01:00
|
|
|
#define DRM_UNLOCKED 0x10
|
drm: implement experimental render nodes
Render nodes provide an API for userspace to use non-privileged GPU
commands without any running DRM-Master. It is useful for offscreen
rendering, GPGPU clients, and normal render clients which do not perform
modesetting.
Compared to legacy clients, render clients no longer need any
authentication to perform client ioctls. Instead, user-space controls
render/client access to GPUs via filesystem access-modes on the
render-node. Once a render-node was opened, a client has full access to
the client/render operations on the GPU. However, no modesetting or ioctls
that affect global state are allowed on render nodes.
To prevent privilege-escalation, drivers must explicitly state that they
support render nodes. They must mark their render-only ioctls as
DRM_RENDER_ALLOW so render clients can use them. Furthermore, they must
support clients without any attached master.
If filesystem access-modes are not enough for fine-grained access control
to render nodes (very unlikely, considering the versaitlity of FS-ACLs),
you may still fall-back to fd-passing from server to client (which allows
arbitrary access-control). However, note that revoking access is
currently impossible and unlikely to get implemented.
Note: Render clients no longer have any associated DRM-Master as they are
supposed to be independent of any server state. DRM core highly depends on
file_priv->master to be non-NULL for modesetting/ctx/etc. commands.
Therefore, drivers must be very careful to not require DRM-Master if they
support DRIVER_RENDER.
So far render-nodes are protected by "drm_rnodes". As long as this
module-parameter is not set to 1, a driver will not create render nodes.
This allows us to experiment with the API a bit before we stabilize it.
v2: drop insecure GEM_FLINK to force use of dmabuf
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-08-25 18:29:00 +02:00
|
|
|
#define DRM_RENDER_ALLOW 0x20
|
2006-01-02 03:54:04 +01:00
|
|
|
|
2007-09-03 04:06:45 +02:00
|
|
|
struct drm_ioctl_desc {
|
|
|
|
unsigned int cmd;
|
2006-01-02 03:54:04 +01:00
|
|
|
int flags;
|
2009-03-18 18:26:44 +01:00
|
|
|
drm_ioctl_t *func;
|
2010-08-14 12:20:34 +02:00
|
|
|
unsigned int cmd_drv;
|
drm: Use names of ioctls in debug traces
The intention here is to make the output of dmesg with full verbosity a
bit easier for a human to parse. This commit transforms:
[drm:drm_ioctl], pid=699, cmd=0x6458, nr=0x58, dev 0xe200, auth=1
[drm:drm_ioctl], pid=699, cmd=0xc010645b, nr=0x5b, dev 0xe200, auth=1
[drm:drm_ioctl], pid=699, cmd=0xc0106461, nr=0x61, dev 0xe200, auth=1
[drm:drm_ioctl], pid=699, cmd=0xc01c64ae, nr=0xae, dev 0xe200, auth=1
[drm:drm_mode_addfb], [FB:32]
[drm:drm_ioctl], pid=699, cmd=0xc0106464, nr=0x64, dev 0xe200, auth=1
[drm:drm_vm_open_locked], 0x7fd9302fe000,0x00a00000
[drm:drm_ioctl], pid=699, cmd=0x400c645f, nr=0x5f, dev 0xe200, auth=1
[drm:drm_ioctl], pid=699, cmd=0xc00464af, nr=0xaf, dev 0xe200, auth=1
[drm:intel_crtc_set_config], [CRTC:3] [NOFB]
into:
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, I915_GEM_THROTTLE
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, I915_GEM_CREATE
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, I915_GEM_SET_TILING
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, IOCTL_MODE_ADDFB
[drm:drm_mode_addfb], [FB:32]
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, I915_GEM_MMAP_GTT
[drm:drm_vm_open_locked], 0x7fd9302fe000,0x00a00000
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, I915_GEM_SET_DOMAIN
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, DRM_IOCTL_MODE_RMFB
[drm:intel_crtc_set_config], [CRTC:3] [NOFB]
v2: drm_ioctls is now a constant (Ville Syrjälä)
Signed-off-by: Chris Cummins <christopher.e.cummins@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-05-09 15:20:40 +02:00
|
|
|
const char *name;
|
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().
|
|
|
|
*/
|
2010-08-14 12:20:34 +02:00
|
|
|
|
|
|
|
#define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags) \
|
drm: Use names of ioctls in debug traces
The intention here is to make the output of dmesg with full verbosity a
bit easier for a human to parse. This commit transforms:
[drm:drm_ioctl], pid=699, cmd=0x6458, nr=0x58, dev 0xe200, auth=1
[drm:drm_ioctl], pid=699, cmd=0xc010645b, nr=0x5b, dev 0xe200, auth=1
[drm:drm_ioctl], pid=699, cmd=0xc0106461, nr=0x61, dev 0xe200, auth=1
[drm:drm_ioctl], pid=699, cmd=0xc01c64ae, nr=0xae, dev 0xe200, auth=1
[drm:drm_mode_addfb], [FB:32]
[drm:drm_ioctl], pid=699, cmd=0xc0106464, nr=0x64, dev 0xe200, auth=1
[drm:drm_vm_open_locked], 0x7fd9302fe000,0x00a00000
[drm:drm_ioctl], pid=699, cmd=0x400c645f, nr=0x5f, dev 0xe200, auth=1
[drm:drm_ioctl], pid=699, cmd=0xc00464af, nr=0xaf, dev 0xe200, auth=1
[drm:intel_crtc_set_config], [CRTC:3] [NOFB]
into:
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, I915_GEM_THROTTLE
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, I915_GEM_CREATE
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, I915_GEM_SET_TILING
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, IOCTL_MODE_ADDFB
[drm:drm_mode_addfb], [FB:32]
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, I915_GEM_MMAP_GTT
[drm:drm_vm_open_locked], 0x7fd9302fe000,0x00a00000
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, I915_GEM_SET_DOMAIN
[drm:drm_ioctl], pid=699, dev=0xe200, auth=1, DRM_IOCTL_MODE_RMFB
[drm:intel_crtc_set_config], [CRTC:3] [NOFB]
v2: drm_ioctls is now a constant (Ville Syrjälä)
Signed-off-by: Chris Cummins <christopher.e.cummins@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-05-09 15:20:40 +02:00
|
|
|
[DRM_IOCTL_NR(DRM_##ioctl)] = {.cmd = DRM_##ioctl, .func = _func, .flags = _flags, .cmd_drv = DRM_IOCTL_##ioctl, .name = #ioctl}
|
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 */
|
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
|
|
|
|
2009-09-11 20:33:34 +02:00
|
|
|
/* Event queued up for userspace to read */
|
|
|
|
struct drm_pending_event {
|
|
|
|
struct drm_event *event;
|
|
|
|
struct list_head link;
|
|
|
|
struct drm_file *file_priv;
|
2010-07-02 01:48:09 +02:00
|
|
|
pid_t pid; /* pid of requester, no guarantee it's valid by the time
|
|
|
|
we deliver the event, for tracing only */
|
2009-09-11 20:33:34 +02:00
|
|
|
void (*destroy)(struct drm_pending_event *event);
|
|
|
|
};
|
|
|
|
|
2011-11-25 16:21:02 +01:00
|
|
|
/* initial implementaton using a linked list - todo hashtab */
|
|
|
|
struct drm_prime_file_private {
|
|
|
|
struct list_head head;
|
|
|
|
struct mutex lock;
|
|
|
|
};
|
|
|
|
|
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;
|
2012-02-08 01:47:26 +01:00
|
|
|
struct pid *pid;
|
|
|
|
kuid_t uid;
|
2005-09-25 06:28:13 +02:00
|
|
|
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
|
|
|
unsigned long lock_count;
|
2008-11-28 05:22:24 +01:00
|
|
|
|
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;
|
2008-11-28 05:22:24 +01:00
|
|
|
|
2007-08-25 12:23:09 +02:00
|
|
|
struct file *filp;
|
2007-11-05 03:37:41 +01:00
|
|
|
void *driver_priv;
|
2008-11-28 05:22:24 +01:00
|
|
|
|
|
|
|
int is_master; /* this file private is a master for a minor */
|
|
|
|
struct drm_master *master; /* master this node is currently associated with
|
|
|
|
N.B. not always minor->master */
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 21:19:18 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* fbs - List of framebuffers associated with this file.
|
|
|
|
*
|
|
|
|
* Protected by fbs_lock. Note that the fbs list holds a reference on
|
|
|
|
* the fb object to prevent it from untimely disappearing.
|
|
|
|
*/
|
2008-11-07 23:05:41 +01:00
|
|
|
struct list_head fbs;
|
drm: revamp locking around fb creation/destruction
Well, at least step 1. The goal here is that framebuffer objects can
survive outside of the mode_config lock, with just a reference held
as protection. The first step to get there is to introduce a special
fb_lock which protects fb lookup, creation and destruction, to make
them appear atomic.
This new fb_lock can nest within the mode_config lock. But the idea is
(once the reference counting part is completed) that we only quickly
take that fb_lock to lookup a framebuffer and grab a reference,
without any other locks involved.
vmwgfx is the only driver which does framebuffer lookups itself, also
wrap those calls to drm_mode_object_find with the new lock.
Also protect the fb_list walking in i915 and omapdrm with the new lock.
As a slight complication there's also the list of user-created fbs
attached to the file private. The problem now is that at fclose() time
we need to walk that list, eventually do a modeset call to remove the
fb from active usage (and are required to be able to take the
mode_config lock), but in the end we need to grab the new fb_lock to
remove the fb from the list. The easiest solution is to add another
mutex to protect this per-file list.
Currently that new fbs_lock nests within the modeset locks and so
appears redudant. But later patches will switch around this sequence
so that taking the modeset locks in the fb destruction path is
optional in the fastpath. Ultimately the goal is that addfb and rmfb
do not require the mode_config lock, since otherwise they have the
potential to introduce stalls in the pageflip sequence of a compositor
(if the compositor e.g. switches to a fullscreen client or if it
enables a plane). But that requires a few more steps and hoops to jump
through.
Note that framebuffer creation/destruction is now double-protected -
once by the fb_lock and in parts by the idr_lock. The later would be
unnecessariy if framebuffers would have their own idr allocator. But
that's material for another patch (series).
v2: Properly initialize the fb->filp_head list in _init, otherwise the
newly added WARN to check whether the fb isn't on a fpriv list any
more will fail for driver-private objects.
v3: Fixup two error-case unlock bugs spotted by Richard Wilbur.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-10 21:19:18 +01:00
|
|
|
struct mutex fbs_lock;
|
2009-09-11 20:33:34 +02:00
|
|
|
|
|
|
|
wait_queue_head_t event_wait;
|
|
|
|
struct list_head event_list;
|
|
|
|
int event_space;
|
2011-11-25 16:21:02 +01:00
|
|
|
|
|
|
|
struct drm_prime_file_private prime;
|
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
|
|
|
|
2009-02-02 06:55:46 +01:00
|
|
|
/**
|
|
|
|
* Kernel side of a mapping
|
|
|
|
*/
|
|
|
|
struct drm_local_map {
|
2009-02-02 06:55:47 +01:00
|
|
|
resource_size_t offset; /**< Requested physical address (0 for SAREA)*/
|
2009-02-02 06:55:46 +01:00
|
|
|
unsigned long size; /**< Requested physical size (bytes) */
|
|
|
|
enum drm_map_type type; /**< Type of memory to map */
|
|
|
|
enum drm_map_flags flags; /**< Flags */
|
|
|
|
void *handle; /**< User-space: "Handle" to pass to mmap() */
|
|
|
|
/**< Kernel-space: kernel-virtual address */
|
|
|
|
int mtrr; /**< MTRR slot used */
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct drm_local_map drm_local_map_t;
|
|
|
|
|
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;
|
2009-02-02 06:55:46 +01:00
|
|
|
struct drm_local_map *map; /**< mapping */
|
2007-11-05 03:37:41 +01:00
|
|
|
uint64_t user_token;
|
2008-11-28 05:22:24 +01:00
|
|
|
struct drm_master *master;
|
2007-07-11 08:53:40 +02:00
|
|
|
};
|
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
|
|
|
|
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;
|
2009-02-02 06:55:46 +01:00
|
|
|
struct drm_local_map 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-11-05 19:31:53 +01:00
|
|
|
/**
|
|
|
|
* GEM specific mm private for tracking GEM objects
|
|
|
|
*/
|
|
|
|
struct drm_gem_mm {
|
2013-07-24 21:07:52 +02:00
|
|
|
struct drm_vma_offset_manager vma_manager;
|
2008-11-05 19:31:53 +01: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;
|
|
|
|
|
2013-08-15 00:02:37 +02:00
|
|
|
/**
|
|
|
|
* handle_count - gem file_priv handle count of this object
|
|
|
|
*
|
|
|
|
* Each handle also holds a reference. Note that when the handle_count
|
|
|
|
* drops to 0 any global names (e.g. the id in the flink namespace) will
|
|
|
|
* be cleared.
|
|
|
|
*
|
|
|
|
* Protected by dev->object_name_lock.
|
|
|
|
* */
|
|
|
|
unsigned handle_count;
|
2008-07-30 21:06:12 +02:00
|
|
|
|
|
|
|
/** Related drm device */
|
|
|
|
struct drm_device *dev;
|
|
|
|
|
|
|
|
/** File representing the shmem storage */
|
|
|
|
struct file *filp;
|
|
|
|
|
2008-11-05 19:31:53 +01:00
|
|
|
/* Mapping info for this object */
|
2013-07-24 21:07:52 +02:00
|
|
|
struct drm_vma_offset_node vma_node;
|
2008-11-05 19:31:53 +01:00
|
|
|
|
2008-07-30 21:06:12 +02:00
|
|
|
/**
|
|
|
|
* 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;
|
2011-11-25 16:21:02 +01:00
|
|
|
|
2013-08-15 00:02:46 +02:00
|
|
|
/**
|
|
|
|
* dma_buf - dma buf associated with this GEM object
|
|
|
|
*
|
|
|
|
* Pointer to the dma-buf associated with this gem object (either
|
|
|
|
* through importing or exporting). We break the resulting reference
|
|
|
|
* loop when the last gem handle for this object is released.
|
|
|
|
*
|
|
|
|
* Protected by obj->object_name_lock
|
|
|
|
*/
|
|
|
|
struct dma_buf *dma_buf;
|
2011-11-25 16:21:02 +01:00
|
|
|
|
2013-08-15 00:02:33 +02:00
|
|
|
/**
|
|
|
|
* import_attach - dma buf attachment backing this object
|
|
|
|
*
|
|
|
|
* Any foreign dma_buf imported as a gem object has this set to the
|
|
|
|
* attachment point for the device. This is invariant over the lifetime
|
|
|
|
* of a gem object.
|
|
|
|
*
|
|
|
|
* The driver's ->gem_free_object callback is responsible for cleaning
|
|
|
|
* up the dma_buf attachment and references acquired at import time.
|
2013-08-15 00:02:47 +02:00
|
|
|
*
|
|
|
|
* Note that the drm gem/prime core does not depend upon drivers setting
|
|
|
|
* this field any more. So for drivers where this doesn't make sense
|
|
|
|
* (e.g. virtual devices or a displaylink behind an usb bus) they can
|
|
|
|
* simply leave it as NULL.
|
2013-08-15 00:02:33 +02:00
|
|
|
*/
|
2011-11-25 16:21:02 +01:00
|
|
|
struct dma_buf_attachment *import_attach;
|
2008-07-30 21:06:12 +02:00
|
|
|
};
|
|
|
|
|
2012-10-02 19:01:25 +02:00
|
|
|
#include <drm/drm_crtc.h>
|
2008-11-07 23:05:41 +01:00
|
|
|
|
2008-11-28 05:22:24 +01:00
|
|
|
/* per-master structure */
|
|
|
|
struct drm_master {
|
|
|
|
|
|
|
|
struct kref refcount; /* refcount for this master */
|
|
|
|
|
|
|
|
struct list_head head; /**< each minor contains a list of masters */
|
|
|
|
struct drm_minor *minor; /**< link back to minor we are a master for */
|
|
|
|
|
|
|
|
char *unique; /**< Unique identifier: e.g., busid */
|
|
|
|
int unique_len; /**< Length of unique field */
|
2008-12-02 04:38:47 +01:00
|
|
|
int unique_size; /**< amount allocated */
|
2008-11-28 05:22:24 +01:00
|
|
|
|
|
|
|
int blocked; /**< Blocked due to VC switch? */
|
|
|
|
|
|
|
|
/** \name Authentication */
|
|
|
|
/*@{ */
|
|
|
|
struct drm_open_hash magiclist;
|
|
|
|
struct list_head magicfree;
|
|
|
|
/*@} */
|
|
|
|
|
|
|
|
struct drm_lock_data lock; /**< Information on hardware lock */
|
|
|
|
|
|
|
|
void *driver_priv; /**< Private structure for driver to use */
|
|
|
|
};
|
|
|
|
|
drm/vblank: Add support for precise vblank timestamping.
The DRI2 swap & sync implementation needs precise
vblank counts and precise timestamps corresponding
to those vblank counts. For conformance to the OpenML
OML_sync_control extension specification the DRM
timestamp associated with a vblank count should
correspond to the start of video scanout of the first
scanline of the video frame following the vblank
interval for that vblank count.
Therefore we need to carry around precise timestamps
for vblanks. Currently the DRM and KMS drivers generate
timestamps ad-hoc via do_gettimeofday() in some
places. The resulting timestamps are sometimes not
very precise due to interrupt handling delays, they
don't conform to OML_sync_control and some are wrong,
as they aren't taken synchronized to the vblank.
This patch implements support inside the drm core
for precise and robust timestamping. It consists
of the following interrelated pieces.
1. Vblank timestamp caching:
A per-crtc ringbuffer stores the most recent vblank
timestamps corresponding to vblank counts.
The ringbuffer can be read out lock-free via the
accessor function:
struct timeval timestamp;
vblankcount = drm_vblank_count_and_time(dev, crtcid, ×tamp).
The function returns the current vblank count and
the corresponding timestamp for start of video
scanout following the vblank interval. It can be
used anywhere between enclosing drm_vblank_get(dev, crtcid)
and drm_vblank_put(dev,crtcid) statements. It is used
inside the drmWaitVblank ioctl and in the vblank event
queueing and handling. It should be used by kms drivers for
timestamping of bufferswap completion.
The timestamp ringbuffer is reinitialized each time
vblank irq's get reenabled in drm_vblank_get()/
drm_update_vblank_count(). It is invalidated when
vblank irq's get disabled.
The ringbuffer is updated inside drm_handle_vblank()
at each vblank irq.
2. Calculation of precise vblank timestamps:
drm_get_last_vbltimestamp() is used to compute the
timestamp for the end of the most recent vblank (if
inside active scanout), or the expected end of the
current vblank interval (if called inside a vblank
interval). The function calls into a new optional kms
driver entry point dev->driver->get_vblank_timestamp()
which is supposed to provide the precise timestamp.
If a kms driver doesn't implement the entry point or
if the call fails, a simple do_gettimeofday() timestamp
is returned as crude approximation of the true vblank time.
A new drm module parameter drm.timestamp_precision_usec
allows to disable high precision timestamps (if set to
zero) or to specify the maximum acceptable error in
the timestamps in microseconds.
Kms drivers could implement their get_vblank_timestamp()
function in a gpu specific way, as long as returned
timestamps conform to OML_sync_control, e.g., by use
of gpu specific hardware timestamps.
Optionally, kms drivers can simply wrap and use the new
utility function drm_calc_vbltimestamp_from_scanoutpos().
This function calls a new optional kms driver function
dev->driver->get_scanout_position() which returns the
current horizontal and vertical video scanout position
of the crtc. The scanout position together with the
drm_display_timing of the current video mode is used
to calculate elapsed time relative to start of active scanout
for the current video frame. This elapsed time is subtracted
from the current do_gettimeofday() time to get the timestamp
corresponding to start of video scanout. Currently
non-interlaced, non-doublescan video modes, with or
without panel scaling are handled correctly. Interlaced/
doublescan modes are tbd in a future patch.
3. Filtering of redundant vblank irq's and removal of
some race-conditions in the vblank irq enable/disable path:
Some gpu's (e.g., Radeon R500/R600) send spurious vblank
irq's outside the vblank if vblank irq's get reenabled.
These get detected by use of the vblank timestamps and
filtered out to avoid miscounting of vblanks.
Some race-conditions between the vblank irq enable/disable
functions, the vblank irq handler and the gpu itself (updating
its hardware vblank counter in the "wrong" moment) are
fixed inside vblank_disable_and_save() and
drm_update_vblank_count() by use of the vblank timestamps and
a new spinlock dev->vblank_time_lock.
The time until vblank irq disable is now configurable via
a new drm module parameter drm.vblankoffdelay to allow
experimentation with timeouts that are much shorter than
the current 5 seconds and should allow longer vblank off
periods for better power savings.
Followup patches will use these new functions to
implement precise timestamping for the intel and radeon
kms drivers.
Signed-off-by: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2010-10-23 04:20:23 +02:00
|
|
|
/* Size of ringbuffer for vblank timestamps. Just double-buffer
|
|
|
|
* in initial implementation.
|
|
|
|
*/
|
|
|
|
#define DRM_VBLANKTIME_RBSIZE 2
|
|
|
|
|
|
|
|
/* Flags and return codes for get_vblank_timestamp() driver function. */
|
|
|
|
#define DRM_CALLED_FROM_VBLIRQ 1
|
|
|
|
#define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0)
|
|
|
|
#define DRM_VBLANKTIME_INVBL (1 << 1)
|
|
|
|
|
|
|
|
/* get_scanout_position() return flags */
|
|
|
|
#define DRM_SCANOUTPOS_VALID (1 << 0)
|
|
|
|
#define DRM_SCANOUTPOS_INVBL (1 << 1)
|
|
|
|
#define DRM_SCANOUTPOS_ACCURATE (1 << 2)
|
|
|
|
|
2010-12-14 18:16:38 +01:00
|
|
|
struct drm_bus {
|
|
|
|
int bus_type;
|
|
|
|
int (*get_irq)(struct drm_device *dev);
|
|
|
|
const char *(*get_name)(struct drm_device *dev);
|
|
|
|
int (*set_busid)(struct drm_device *dev, struct drm_master *master);
|
|
|
|
int (*set_unique)(struct drm_device *dev, struct drm_master *master,
|
|
|
|
struct drm_unique *unique);
|
|
|
|
int (*irq_by_busid)(struct drm_device *dev, struct drm_irq_busid *p);
|
|
|
|
/* hooks that are for PCI */
|
|
|
|
int (*agp_init)(struct drm_device *dev);
|
2013-07-27 16:37:00 +02:00
|
|
|
void (*agp_destroy)(struct drm_device *dev);
|
2010-12-14 18:16:38 +01:00
|
|
|
|
|
|
|
};
|
|
|
|
|
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
|
|
|
int (*dma_quiescent) (struct drm_device *);
|
2007-07-11 07:53:27 +02:00
|
|
|
int (*context_dtor) (struct drm_device *dev, int context);
|
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
|
|
|
|
*
|
2012-05-17 13:27:20 +02:00
|
|
|
* 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. The DRM core will account for
|
|
|
|
* missed vblank events while interrupts where disabled based on system
|
|
|
|
* timestamps.
|
2008-09-30 21:14:26 +02:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
drm/vblank: Add support for precise vblank timestamping.
The DRI2 swap & sync implementation needs precise
vblank counts and precise timestamps corresponding
to those vblank counts. For conformance to the OpenML
OML_sync_control extension specification the DRM
timestamp associated with a vblank count should
correspond to the start of video scanout of the first
scanline of the video frame following the vblank
interval for that vblank count.
Therefore we need to carry around precise timestamps
for vblanks. Currently the DRM and KMS drivers generate
timestamps ad-hoc via do_gettimeofday() in some
places. The resulting timestamps are sometimes not
very precise due to interrupt handling delays, they
don't conform to OML_sync_control and some are wrong,
as they aren't taken synchronized to the vblank.
This patch implements support inside the drm core
for precise and robust timestamping. It consists
of the following interrelated pieces.
1. Vblank timestamp caching:
A per-crtc ringbuffer stores the most recent vblank
timestamps corresponding to vblank counts.
The ringbuffer can be read out lock-free via the
accessor function:
struct timeval timestamp;
vblankcount = drm_vblank_count_and_time(dev, crtcid, ×tamp).
The function returns the current vblank count and
the corresponding timestamp for start of video
scanout following the vblank interval. It can be
used anywhere between enclosing drm_vblank_get(dev, crtcid)
and drm_vblank_put(dev,crtcid) statements. It is used
inside the drmWaitVblank ioctl and in the vblank event
queueing and handling. It should be used by kms drivers for
timestamping of bufferswap completion.
The timestamp ringbuffer is reinitialized each time
vblank irq's get reenabled in drm_vblank_get()/
drm_update_vblank_count(). It is invalidated when
vblank irq's get disabled.
The ringbuffer is updated inside drm_handle_vblank()
at each vblank irq.
2. Calculation of precise vblank timestamps:
drm_get_last_vbltimestamp() is used to compute the
timestamp for the end of the most recent vblank (if
inside active scanout), or the expected end of the
current vblank interval (if called inside a vblank
interval). The function calls into a new optional kms
driver entry point dev->driver->get_vblank_timestamp()
which is supposed to provide the precise timestamp.
If a kms driver doesn't implement the entry point or
if the call fails, a simple do_gettimeofday() timestamp
is returned as crude approximation of the true vblank time.
A new drm module parameter drm.timestamp_precision_usec
allows to disable high precision timestamps (if set to
zero) or to specify the maximum acceptable error in
the timestamps in microseconds.
Kms drivers could implement their get_vblank_timestamp()
function in a gpu specific way, as long as returned
timestamps conform to OML_sync_control, e.g., by use
of gpu specific hardware timestamps.
Optionally, kms drivers can simply wrap and use the new
utility function drm_calc_vbltimestamp_from_scanoutpos().
This function calls a new optional kms driver function
dev->driver->get_scanout_position() which returns the
current horizontal and vertical video scanout position
of the crtc. The scanout position together with the
drm_display_timing of the current video mode is used
to calculate elapsed time relative to start of active scanout
for the current video frame. This elapsed time is subtracted
from the current do_gettimeofday() time to get the timestamp
corresponding to start of video scanout. Currently
non-interlaced, non-doublescan video modes, with or
without panel scaling are handled correctly. Interlaced/
doublescan modes are tbd in a future patch.
3. Filtering of redundant vblank irq's and removal of
some race-conditions in the vblank irq enable/disable path:
Some gpu's (e.g., Radeon R500/R600) send spurious vblank
irq's outside the vblank if vblank irq's get reenabled.
These get detected by use of the vblank timestamps and
filtered out to avoid miscounting of vblanks.
Some race-conditions between the vblank irq enable/disable
functions, the vblank irq handler and the gpu itself (updating
its hardware vblank counter in the "wrong" moment) are
fixed inside vblank_disable_and_save() and
drm_update_vblank_count() by use of the vblank timestamps and
a new spinlock dev->vblank_time_lock.
The time until vblank irq disable is now configurable via
a new drm module parameter drm.vblankoffdelay to allow
experimentation with timeouts that are much shorter than
the current 5 seconds and should allow longer vblank off
periods for better power savings.
Followup patches will use these new functions to
implement precise timestamping for the intel and radeon
kms drivers.
Signed-off-by: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2010-10-23 04:20:23 +02:00
|
|
|
/**
|
|
|
|
* Called by vblank timestamping code.
|
|
|
|
*
|
|
|
|
* Return the current display scanout position from a crtc.
|
|
|
|
*
|
|
|
|
* \param dev DRM device.
|
|
|
|
* \param crtc Id of the crtc to query.
|
|
|
|
* \param *vpos Target location for current vertical scanout position.
|
|
|
|
* \param *hpos Target location for current horizontal scanout position.
|
|
|
|
*
|
|
|
|
* Returns vpos as a positive number while in active scanout area.
|
|
|
|
* Returns vpos as a negative number inside vblank, counting the number
|
|
|
|
* of scanlines to go until end of vblank, e.g., -1 means "one scanline
|
|
|
|
* until start of active scanout / end of vblank."
|
|
|
|
*
|
|
|
|
* \return Flags, or'ed together as follows:
|
|
|
|
*
|
2011-03-31 03:57:33 +02:00
|
|
|
* DRM_SCANOUTPOS_VALID = Query successful.
|
drm/vblank: Add support for precise vblank timestamping.
The DRI2 swap & sync implementation needs precise
vblank counts and precise timestamps corresponding
to those vblank counts. For conformance to the OpenML
OML_sync_control extension specification the DRM
timestamp associated with a vblank count should
correspond to the start of video scanout of the first
scanline of the video frame following the vblank
interval for that vblank count.
Therefore we need to carry around precise timestamps
for vblanks. Currently the DRM and KMS drivers generate
timestamps ad-hoc via do_gettimeofday() in some
places. The resulting timestamps are sometimes not
very precise due to interrupt handling delays, they
don't conform to OML_sync_control and some are wrong,
as they aren't taken synchronized to the vblank.
This patch implements support inside the drm core
for precise and robust timestamping. It consists
of the following interrelated pieces.
1. Vblank timestamp caching:
A per-crtc ringbuffer stores the most recent vblank
timestamps corresponding to vblank counts.
The ringbuffer can be read out lock-free via the
accessor function:
struct timeval timestamp;
vblankcount = drm_vblank_count_and_time(dev, crtcid, ×tamp).
The function returns the current vblank count and
the corresponding timestamp for start of video
scanout following the vblank interval. It can be
used anywhere between enclosing drm_vblank_get(dev, crtcid)
and drm_vblank_put(dev,crtcid) statements. It is used
inside the drmWaitVblank ioctl and in the vblank event
queueing and handling. It should be used by kms drivers for
timestamping of bufferswap completion.
The timestamp ringbuffer is reinitialized each time
vblank irq's get reenabled in drm_vblank_get()/
drm_update_vblank_count(). It is invalidated when
vblank irq's get disabled.
The ringbuffer is updated inside drm_handle_vblank()
at each vblank irq.
2. Calculation of precise vblank timestamps:
drm_get_last_vbltimestamp() is used to compute the
timestamp for the end of the most recent vblank (if
inside active scanout), or the expected end of the
current vblank interval (if called inside a vblank
interval). The function calls into a new optional kms
driver entry point dev->driver->get_vblank_timestamp()
which is supposed to provide the precise timestamp.
If a kms driver doesn't implement the entry point or
if the call fails, a simple do_gettimeofday() timestamp
is returned as crude approximation of the true vblank time.
A new drm module parameter drm.timestamp_precision_usec
allows to disable high precision timestamps (if set to
zero) or to specify the maximum acceptable error in
the timestamps in microseconds.
Kms drivers could implement their get_vblank_timestamp()
function in a gpu specific way, as long as returned
timestamps conform to OML_sync_control, e.g., by use
of gpu specific hardware timestamps.
Optionally, kms drivers can simply wrap and use the new
utility function drm_calc_vbltimestamp_from_scanoutpos().
This function calls a new optional kms driver function
dev->driver->get_scanout_position() which returns the
current horizontal and vertical video scanout position
of the crtc. The scanout position together with the
drm_display_timing of the current video mode is used
to calculate elapsed time relative to start of active scanout
for the current video frame. This elapsed time is subtracted
from the current do_gettimeofday() time to get the timestamp
corresponding to start of video scanout. Currently
non-interlaced, non-doublescan video modes, with or
without panel scaling are handled correctly. Interlaced/
doublescan modes are tbd in a future patch.
3. Filtering of redundant vblank irq's and removal of
some race-conditions in the vblank irq enable/disable path:
Some gpu's (e.g., Radeon R500/R600) send spurious vblank
irq's outside the vblank if vblank irq's get reenabled.
These get detected by use of the vblank timestamps and
filtered out to avoid miscounting of vblanks.
Some race-conditions between the vblank irq enable/disable
functions, the vblank irq handler and the gpu itself (updating
its hardware vblank counter in the "wrong" moment) are
fixed inside vblank_disable_and_save() and
drm_update_vblank_count() by use of the vblank timestamps and
a new spinlock dev->vblank_time_lock.
The time until vblank irq disable is now configurable via
a new drm module parameter drm.vblankoffdelay to allow
experimentation with timeouts that are much shorter than
the current 5 seconds and should allow longer vblank off
periods for better power savings.
Followup patches will use these new functions to
implement precise timestamping for the intel and radeon
kms drivers.
Signed-off-by: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2010-10-23 04:20:23 +02:00
|
|
|
* DRM_SCANOUTPOS_INVBL = Inside vblank.
|
|
|
|
* DRM_SCANOUTPOS_ACCURATE = Returned position is accurate. A lack of
|
|
|
|
* this flag means that returned position may be offset by a constant
|
|
|
|
* but unknown small number of scanlines wrt. real scanout position.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
int (*get_scanout_position) (struct drm_device *dev, int crtc,
|
|
|
|
int *vpos, int *hpos);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Called by \c drm_get_last_vbltimestamp. Should return a precise
|
|
|
|
* timestamp when the most recent VBLANK interval ended or will end.
|
|
|
|
*
|
|
|
|
* Specifically, the timestamp in @vblank_time should correspond as
|
|
|
|
* closely as possible to the time when the first video scanline of
|
|
|
|
* the video frame after the end of VBLANK will start scanning out,
|
2011-11-29 05:31:00 +01:00
|
|
|
* the time immediately after end of the VBLANK interval. If the
|
drm/vblank: Add support for precise vblank timestamping.
The DRI2 swap & sync implementation needs precise
vblank counts and precise timestamps corresponding
to those vblank counts. For conformance to the OpenML
OML_sync_control extension specification the DRM
timestamp associated with a vblank count should
correspond to the start of video scanout of the first
scanline of the video frame following the vblank
interval for that vblank count.
Therefore we need to carry around precise timestamps
for vblanks. Currently the DRM and KMS drivers generate
timestamps ad-hoc via do_gettimeofday() in some
places. The resulting timestamps are sometimes not
very precise due to interrupt handling delays, they
don't conform to OML_sync_control and some are wrong,
as they aren't taken synchronized to the vblank.
This patch implements support inside the drm core
for precise and robust timestamping. It consists
of the following interrelated pieces.
1. Vblank timestamp caching:
A per-crtc ringbuffer stores the most recent vblank
timestamps corresponding to vblank counts.
The ringbuffer can be read out lock-free via the
accessor function:
struct timeval timestamp;
vblankcount = drm_vblank_count_and_time(dev, crtcid, ×tamp).
The function returns the current vblank count and
the corresponding timestamp for start of video
scanout following the vblank interval. It can be
used anywhere between enclosing drm_vblank_get(dev, crtcid)
and drm_vblank_put(dev,crtcid) statements. It is used
inside the drmWaitVblank ioctl and in the vblank event
queueing and handling. It should be used by kms drivers for
timestamping of bufferswap completion.
The timestamp ringbuffer is reinitialized each time
vblank irq's get reenabled in drm_vblank_get()/
drm_update_vblank_count(). It is invalidated when
vblank irq's get disabled.
The ringbuffer is updated inside drm_handle_vblank()
at each vblank irq.
2. Calculation of precise vblank timestamps:
drm_get_last_vbltimestamp() is used to compute the
timestamp for the end of the most recent vblank (if
inside active scanout), or the expected end of the
current vblank interval (if called inside a vblank
interval). The function calls into a new optional kms
driver entry point dev->driver->get_vblank_timestamp()
which is supposed to provide the precise timestamp.
If a kms driver doesn't implement the entry point or
if the call fails, a simple do_gettimeofday() timestamp
is returned as crude approximation of the true vblank time.
A new drm module parameter drm.timestamp_precision_usec
allows to disable high precision timestamps (if set to
zero) or to specify the maximum acceptable error in
the timestamps in microseconds.
Kms drivers could implement their get_vblank_timestamp()
function in a gpu specific way, as long as returned
timestamps conform to OML_sync_control, e.g., by use
of gpu specific hardware timestamps.
Optionally, kms drivers can simply wrap and use the new
utility function drm_calc_vbltimestamp_from_scanoutpos().
This function calls a new optional kms driver function
dev->driver->get_scanout_position() which returns the
current horizontal and vertical video scanout position
of the crtc. The scanout position together with the
drm_display_timing of the current video mode is used
to calculate elapsed time relative to start of active scanout
for the current video frame. This elapsed time is subtracted
from the current do_gettimeofday() time to get the timestamp
corresponding to start of video scanout. Currently
non-interlaced, non-doublescan video modes, with or
without panel scaling are handled correctly. Interlaced/
doublescan modes are tbd in a future patch.
3. Filtering of redundant vblank irq's and removal of
some race-conditions in the vblank irq enable/disable path:
Some gpu's (e.g., Radeon R500/R600) send spurious vblank
irq's outside the vblank if vblank irq's get reenabled.
These get detected by use of the vblank timestamps and
filtered out to avoid miscounting of vblanks.
Some race-conditions between the vblank irq enable/disable
functions, the vblank irq handler and the gpu itself (updating
its hardware vblank counter in the "wrong" moment) are
fixed inside vblank_disable_and_save() and
drm_update_vblank_count() by use of the vblank timestamps and
a new spinlock dev->vblank_time_lock.
The time until vblank irq disable is now configurable via
a new drm module parameter drm.vblankoffdelay to allow
experimentation with timeouts that are much shorter than
the current 5 seconds and should allow longer vblank off
periods for better power savings.
Followup patches will use these new functions to
implement precise timestamping for the intel and radeon
kms drivers.
Signed-off-by: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2010-10-23 04:20:23 +02:00
|
|
|
* @crtc is currently inside VBLANK, this will be a time in the future.
|
|
|
|
* If the @crtc is currently scanning out a frame, this will be the
|
|
|
|
* past start time of the current scanout. This is meant to adhere
|
|
|
|
* to the OpenML OML_sync_control extension specification.
|
|
|
|
*
|
|
|
|
* \param dev dev DRM device handle.
|
|
|
|
* \param crtc crtc for which timestamp should be returned.
|
|
|
|
* \param *max_error Maximum allowable timestamp error in nanoseconds.
|
|
|
|
* Implementation should strive to provide timestamp
|
|
|
|
* with an error of at most *max_error nanoseconds.
|
|
|
|
* Returns true upper bound on error for timestamp.
|
|
|
|
* \param *vblank_time Target location for returned vblank timestamp.
|
|
|
|
* \param flags 0 = Defaults, no special treatment needed.
|
|
|
|
* \param DRM_CALLED_FROM_VBLIRQ = Function is called from vblank
|
|
|
|
* irq handler. Some drivers need to apply some workarounds
|
|
|
|
* for gpu-specific vblank irq quirks if flag is set.
|
|
|
|
*
|
|
|
|
* \returns
|
|
|
|
* Zero if timestamping isn't supported in current display mode or a
|
|
|
|
* negative number on failure. A positive status code on success,
|
|
|
|
* which describes how the vblank_time timestamp was computed.
|
|
|
|
*/
|
|
|
|
int (*get_vblank_timestamp) (struct drm_device *dev, int crtc,
|
|
|
|
int *max_error,
|
|
|
|
struct timeval *vblank_time,
|
|
|
|
unsigned flags);
|
|
|
|
|
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);
|
2005-11-10 12:16:34 +01:00
|
|
|
|
2008-11-28 05:22:24 +01:00
|
|
|
/* Master routines */
|
|
|
|
int (*master_create)(struct drm_device *dev, struct drm_master *master);
|
|
|
|
void (*master_destroy)(struct drm_device *dev, struct drm_master *master);
|
2009-12-02 19:15:25 +01:00
|
|
|
/**
|
|
|
|
* master_set is called whenever the minor master is set.
|
|
|
|
* master_drop is called whenever the minor master is dropped.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
|
|
|
|
bool from_open);
|
|
|
|
void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv,
|
|
|
|
bool from_release);
|
2008-11-28 05:22:24 +01:00
|
|
|
|
2009-02-18 02:08:49 +01:00
|
|
|
int (*debugfs_init)(struct drm_minor *minor);
|
|
|
|
void (*debugfs_cleanup)(struct drm_minor *minor);
|
2008-07-30 21:06:12 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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);
|
2011-06-09 02:24:59 +02:00
|
|
|
int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
|
|
|
|
void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
|
2008-07-30 21:06:12 +02:00
|
|
|
|
2011-11-25 16:21:02 +01:00
|
|
|
/* prime: */
|
|
|
|
/* export handle -> fd (see drm_gem_prime_handle_to_fd() helper) */
|
|
|
|
int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
|
|
|
|
uint32_t handle, uint32_t flags, int *prime_fd);
|
|
|
|
/* import fd -> handle (see drm_gem_prime_fd_to_handle() helper) */
|
|
|
|
int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
|
|
|
|
int prime_fd, uint32_t *handle);
|
|
|
|
/* export GEM -> dmabuf */
|
|
|
|
struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
|
|
|
|
struct drm_gem_object *obj, int flags);
|
|
|
|
/* import dmabuf -> GEM */
|
|
|
|
struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
|
|
|
|
struct dma_buf *dma_buf);
|
2013-01-15 21:47:42 +01:00
|
|
|
/* low-level interface used by drm_gem_prime_{import,export} */
|
|
|
|
int (*gem_prime_pin)(struct drm_gem_object *obj);
|
2013-04-09 09:18:44 +02:00
|
|
|
void (*gem_prime_unpin)(struct drm_gem_object *obj);
|
2013-01-15 21:47:42 +01:00
|
|
|
struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj);
|
|
|
|
struct drm_gem_object *(*gem_prime_import_sg_table)(
|
|
|
|
struct drm_device *dev, size_t size,
|
|
|
|
struct sg_table *sgt);
|
|
|
|
void *(*gem_prime_vmap)(struct drm_gem_object *obj);
|
|
|
|
void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr);
|
2013-06-28 07:24:53 +02:00
|
|
|
int (*gem_prime_mmap)(struct drm_gem_object *obj,
|
|
|
|
struct vm_area_struct *vma);
|
2011-11-25 16:21:02 +01:00
|
|
|
|
2009-09-21 06:33:58 +02:00
|
|
|
/* vga arb irq handler */
|
|
|
|
void (*vgaarb_irq)(struct drm_device *dev, bool state);
|
|
|
|
|
2011-02-07 03:16:14 +01:00
|
|
|
/* dumb alloc support */
|
|
|
|
int (*dumb_create)(struct drm_file *file_priv,
|
|
|
|
struct drm_device *dev,
|
|
|
|
struct drm_mode_create_dumb *args);
|
|
|
|
int (*dumb_map_offset)(struct drm_file *file_priv,
|
|
|
|
struct drm_device *dev, uint32_t handle,
|
|
|
|
uint64_t *offset);
|
|
|
|
int (*dumb_destroy)(struct drm_file *file_priv,
|
|
|
|
struct drm_device *dev,
|
|
|
|
uint32_t handle);
|
|
|
|
|
2008-11-05 19:31:53 +01:00
|
|
|
/* Driver private ops for this object */
|
2012-05-17 13:27:22 +02:00
|
|
|
const struct vm_operations_struct *gem_vm_ops;
|
2008-11-05 19:31:53 +01:00
|
|
|
|
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;
|
2013-08-02 19:27:49 +02:00
|
|
|
const struct drm_ioctl_desc *ioctls;
|
2005-04-17 00:20:36 +02:00
|
|
|
int num_ioctls;
|
2011-10-31 15:28:57 +01:00
|
|
|
const struct file_operations *fops;
|
2010-12-14 18:16:38 +01:00
|
|
|
union {
|
|
|
|
struct pci_driver *pci;
|
|
|
|
struct platform_device *platform_device;
|
2010-12-14 22:13:55 +01:00
|
|
|
struct usb_driver *usb;
|
2010-12-14 18:16:38 +01:00
|
|
|
} kdriver;
|
|
|
|
struct drm_bus *bus;
|
|
|
|
|
2008-11-28 04:43:47 +01:00
|
|
|
/* List of devices hanging off this driver */
|
|
|
|
struct list_head device_list;
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2008-04-21 08:47:32 +02:00
|
|
|
#define DRM_MINOR_UNASSIGNED 0
|
|
|
|
#define DRM_MINOR_LEGACY 1
|
2008-11-07 23:05:41 +01:00
|
|
|
#define DRM_MINOR_CONTROL 2
|
|
|
|
#define DRM_MINOR_RENDER 3
|
2008-04-21 08:47:32 +02:00
|
|
|
|
2009-02-18 02:08:49 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* debugfs node list. This structure represents a debugfs file to
|
|
|
|
* be created by the drm core
|
|
|
|
*/
|
|
|
|
struct drm_debugfs_list {
|
|
|
|
const char *name; /** file name */
|
|
|
|
int (*show)(struct seq_file*, void*); /** show callback */
|
|
|
|
u32 driver_features; /**< Required driver features for this entry */
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* debugfs node structure. This structure represents a debugfs file.
|
|
|
|
*/
|
|
|
|
struct drm_debugfs_node {
|
|
|
|
struct list_head list;
|
|
|
|
struct drm_minor *minor;
|
|
|
|
struct drm_debugfs_list *debugfs_ent;
|
|
|
|
struct dentry *dent;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Info file list entry. This structure represents a debugfs or proc file to
|
|
|
|
* be created by the drm core
|
|
|
|
*/
|
|
|
|
struct drm_info_list {
|
|
|
|
const char *name; /** file name */
|
|
|
|
int (*show)(struct seq_file*, void*); /** show callback */
|
|
|
|
u32 driver_features; /**< Required driver features for this entry */
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* debugfs node structure. This structure represents a debugfs file.
|
|
|
|
*/
|
|
|
|
struct drm_info_node {
|
|
|
|
struct list_head list;
|
|
|
|
struct drm_minor *minor;
|
2013-04-12 16:23:25 +02:00
|
|
|
const struct drm_info_list *info_ent;
|
2009-02-18 02:08:49 +01:00
|
|
|
struct dentry *dent;
|
|
|
|
};
|
|
|
|
|
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;
|
2009-02-18 02:08:49 +01:00
|
|
|
|
|
|
|
struct dentry *debugfs_root;
|
2011-11-09 22:20:35 +01:00
|
|
|
|
|
|
|
struct list_head debugfs_list;
|
|
|
|
struct mutex debugfs_lock; /* Protects debugfs_list. */
|
2009-02-18 02:08:49 +01:00
|
|
|
|
2008-11-28 05:22:24 +01:00
|
|
|
struct drm_master *master; /* currently active master for this node */
|
|
|
|
struct list_head master_list;
|
2008-11-07 23:05:41 +01:00
|
|
|
struct drm_mode_group mode_group;
|
2007-07-11 07:53:27 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-04-17 08:43:32 +02:00
|
|
|
/* mode specified on the command line */
|
|
|
|
struct drm_cmdline_mode {
|
|
|
|
bool specified;
|
|
|
|
bool refresh_specified;
|
|
|
|
bool bpp_specified;
|
|
|
|
int xres, yres;
|
|
|
|
int bpp;
|
|
|
|
int refresh;
|
|
|
|
bool rb;
|
|
|
|
bool interlace;
|
|
|
|
bool cvt;
|
|
|
|
bool margins;
|
|
|
|
enum drm_connector_force force;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-09-11 20:33:34 +02:00
|
|
|
struct drm_pending_vblank_event {
|
|
|
|
struct drm_pending_event base;
|
|
|
|
int pipe;
|
|
|
|
struct drm_event_vblank event;
|
|
|
|
};
|
|
|
|
|
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 {
|
2008-11-28 04:43:47 +01:00
|
|
|
struct list_head driver_item; /**< list of devices per driver */
|
2005-09-25 06:28:13 +02:00
|
|
|
char *devname; /**< For /proc/interrupts */
|
|
|
|
int if_version; /**< Highest interface version set */
|
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
|
|
|
|
2007-05-25 21:01:51 +02:00
|
|
|
struct list_head filelist;
|
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) */
|
2008-11-07 23:05:41 +01:00
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@} */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-10-26 00:54:41 +02:00
|
|
|
/** \name DMA support */
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@{ */
|
2007-07-11 08:32:08 +02:00
|
|
|
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_enabled; /**< True if irq handler is enabled */
|
2005-04-17 00:20:36 +02:00
|
|
|
__volatile__ long context_flag; /**< Context swapping flag */
|
2005-09-25 06:28:13 +02:00
|
|
|
int last_context; /**< Last current context */
|
|
|
|
/*@} */
|
|
|
|
|
|
|
|
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) */
|
drm/vblank: Add support for precise vblank timestamping.
The DRI2 swap & sync implementation needs precise
vblank counts and precise timestamps corresponding
to those vblank counts. For conformance to the OpenML
OML_sync_control extension specification the DRM
timestamp associated with a vblank count should
correspond to the start of video scanout of the first
scanline of the video frame following the vblank
interval for that vblank count.
Therefore we need to carry around precise timestamps
for vblanks. Currently the DRM and KMS drivers generate
timestamps ad-hoc via do_gettimeofday() in some
places. The resulting timestamps are sometimes not
very precise due to interrupt handling delays, they
don't conform to OML_sync_control and some are wrong,
as they aren't taken synchronized to the vblank.
This patch implements support inside the drm core
for precise and robust timestamping. It consists
of the following interrelated pieces.
1. Vblank timestamp caching:
A per-crtc ringbuffer stores the most recent vblank
timestamps corresponding to vblank counts.
The ringbuffer can be read out lock-free via the
accessor function:
struct timeval timestamp;
vblankcount = drm_vblank_count_and_time(dev, crtcid, ×tamp).
The function returns the current vblank count and
the corresponding timestamp for start of video
scanout following the vblank interval. It can be
used anywhere between enclosing drm_vblank_get(dev, crtcid)
and drm_vblank_put(dev,crtcid) statements. It is used
inside the drmWaitVblank ioctl and in the vblank event
queueing and handling. It should be used by kms drivers for
timestamping of bufferswap completion.
The timestamp ringbuffer is reinitialized each time
vblank irq's get reenabled in drm_vblank_get()/
drm_update_vblank_count(). It is invalidated when
vblank irq's get disabled.
The ringbuffer is updated inside drm_handle_vblank()
at each vblank irq.
2. Calculation of precise vblank timestamps:
drm_get_last_vbltimestamp() is used to compute the
timestamp for the end of the most recent vblank (if
inside active scanout), or the expected end of the
current vblank interval (if called inside a vblank
interval). The function calls into a new optional kms
driver entry point dev->driver->get_vblank_timestamp()
which is supposed to provide the precise timestamp.
If a kms driver doesn't implement the entry point or
if the call fails, a simple do_gettimeofday() timestamp
is returned as crude approximation of the true vblank time.
A new drm module parameter drm.timestamp_precision_usec
allows to disable high precision timestamps (if set to
zero) or to specify the maximum acceptable error in
the timestamps in microseconds.
Kms drivers could implement their get_vblank_timestamp()
function in a gpu specific way, as long as returned
timestamps conform to OML_sync_control, e.g., by use
of gpu specific hardware timestamps.
Optionally, kms drivers can simply wrap and use the new
utility function drm_calc_vbltimestamp_from_scanoutpos().
This function calls a new optional kms driver function
dev->driver->get_scanout_position() which returns the
current horizontal and vertical video scanout position
of the crtc. The scanout position together with the
drm_display_timing of the current video mode is used
to calculate elapsed time relative to start of active scanout
for the current video frame. This elapsed time is subtracted
from the current do_gettimeofday() time to get the timestamp
corresponding to start of video scanout. Currently
non-interlaced, non-doublescan video modes, with or
without panel scaling are handled correctly. Interlaced/
doublescan modes are tbd in a future patch.
3. Filtering of redundant vblank irq's and removal of
some race-conditions in the vblank irq enable/disable path:
Some gpu's (e.g., Radeon R500/R600) send spurious vblank
irq's outside the vblank if vblank irq's get reenabled.
These get detected by use of the vblank timestamps and
filtered out to avoid miscounting of vblanks.
Some race-conditions between the vblank irq enable/disable
functions, the vblank irq handler and the gpu itself (updating
its hardware vblank counter in the "wrong" moment) are
fixed inside vblank_disable_and_save() and
drm_update_vblank_count() by use of the vblank timestamps and
a new spinlock dev->vblank_time_lock.
The time until vblank irq disable is now configurable via
a new drm module parameter drm.vblankoffdelay to allow
experimentation with timeouts that are much shorter than
the current 5 seconds and should allow longer vblank off
periods for better power savings.
Followup patches will use these new functions to
implement precise timestamping for the intel and radeon
kms drivers.
Signed-off-by: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2010-10-23 04:20:23 +02:00
|
|
|
struct timeval *_vblank_time; /**< timestamp of current vblank_count (drivers must alloc right number of fields) */
|
|
|
|
spinlock_t vblank_time_lock; /**< Protects vblank count and time updates during vblank enable/disable */
|
2005-09-25 06:28:13 +02:00
|
|
|
spinlock_t vbl_lock;
|
2008-09-30 21:14:26 +02:00
|
|
|
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 */
|
2008-12-20 02:23:38 +01:00
|
|
|
u32 *last_vblank_wait; /* Last vblank seqno waited per CRTC */
|
2008-09-30 21:14:26 +02:00
|
|
|
struct timer_list vblank_disable_timer;
|
|
|
|
|
|
|
|
u32 max_vblank_count; /**< size of vblank counter register */
|
2005-09-25 06:28:13 +02:00
|
|
|
|
2009-09-11 20:33:34 +02:00
|
|
|
/**
|
|
|
|
* List of events
|
|
|
|
*/
|
|
|
|
struct list_head vblank_event_list;
|
|
|
|
spinlock_t event_lock;
|
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
/*@} */
|
|
|
|
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_agp_head *agp; /**< AGP data */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-05-27 21:40:25 +02:00
|
|
|
struct device *dev; /**< Device structure */
|
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
|
2010-05-27 21:40:25 +02:00
|
|
|
|
|
|
|
struct platform_device *platformdev; /**< Platform device struture */
|
2010-12-14 22:13:55 +01:00
|
|
|
struct usb_device *usbdev;
|
2010-05-27 21:40:25 +02:00
|
|
|
|
2007-07-11 08:53:40 +02:00
|
|
|
struct drm_sg_mem *sg; /**< Scatter gather memory */
|
2011-02-23 23:35:06 +01:00
|
|
|
unsigned int num_crtcs; /**< Number of CRTCs on this device */
|
2005-09-25 06:28:13 +02:00
|
|
|
void *dev_private; /**< device private data */
|
2008-11-05 19:31:53 +01:00
|
|
|
void *mm_private;
|
|
|
|
struct address_space *dev_mapping;
|
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;
|
2009-02-02 06:55:46 +01:00
|
|
|
struct drm_local_map *agp_buffer_map;
|
2005-08-05 14:11:22 +02:00
|
|
|
unsigned int agp_buffer_token;
|
2008-11-07 23:05:41 +01:00
|
|
|
struct drm_minor *control; /**< Control node for card */
|
2008-04-21 08:47:32 +02:00
|
|
|
struct drm_minor *primary; /**< render type primary screen head */
|
drm: implement experimental render nodes
Render nodes provide an API for userspace to use non-privileged GPU
commands without any running DRM-Master. It is useful for offscreen
rendering, GPGPU clients, and normal render clients which do not perform
modesetting.
Compared to legacy clients, render clients no longer need any
authentication to perform client ioctls. Instead, user-space controls
render/client access to GPUs via filesystem access-modes on the
render-node. Once a render-node was opened, a client has full access to
the client/render operations on the GPU. However, no modesetting or ioctls
that affect global state are allowed on render nodes.
To prevent privilege-escalation, drivers must explicitly state that they
support render nodes. They must mark their render-only ioctls as
DRM_RENDER_ALLOW so render clients can use them. Furthermore, they must
support clients without any attached master.
If filesystem access-modes are not enough for fine-grained access control
to render nodes (very unlikely, considering the versaitlity of FS-ACLs),
you may still fall-back to fd-passing from server to client (which allows
arbitrary access-control). However, note that revoking access is
currently impossible and unlikely to get implemented.
Note: Render clients no longer have any associated DRM-Master as they are
supposed to be independent of any server state. DRM core highly depends on
file_priv->master to be non-NULL for modesetting/ctx/etc. commands.
Therefore, drivers must be very careful to not require DRM-Master if they
support DRIVER_RENDER.
So far render-nodes are protected by "drm_rnodes". As long as this
module-parameter is not set to 1, a driver will not create render nodes.
This allows us to experiment with the API a bit before we stabilize it.
v2: drop insecure GEM_FLINK to force use of dmabuf
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-08-25 18:29:00 +02:00
|
|
|
struct drm_minor *render; /**< render node for card */
|
2006-10-24 15:04:19 +02:00
|
|
|
|
2008-11-07 23:05:41 +01:00
|
|
|
struct drm_mode_config mode_config; /**< Current mode config */
|
|
|
|
|
2008-07-30 21:06:12 +02:00
|
|
|
/** \name GEM information */
|
|
|
|
/*@{ */
|
2013-08-15 00:02:44 +02:00
|
|
|
struct mutex object_name_lock;
|
2008-07-30 21:06:12 +02:00
|
|
|
struct idr object_name_idr;
|
|
|
|
/*@} */
|
2010-12-07 00:20:40 +01:00
|
|
|
int switch_power_state;
|
2012-02-20 15:18:07 +01:00
|
|
|
|
|
|
|
atomic_t unplugged; /* device has been unplugged or gone away */
|
2007-07-11 07:53:27 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-12-07 00:20:40 +01:00
|
|
|
#define DRM_SWITCH_POWER_ON 0
|
|
|
|
#define DRM_SWITCH_POWER_OFF 1
|
|
|
|
#define DRM_SWITCH_POWER_CHANGING 2
|
2012-09-12 07:55:05 +02:00
|
|
|
#define DRM_SWITCH_POWER_DYNAMIC_OFF 3
|
2010-12-07 00:20:40 +01: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);
|
|
|
|
}
|
|
|
|
|
2010-05-27 21:40:25 +02:00
|
|
|
static inline int drm_dev_to_irq(struct drm_device *dev)
|
|
|
|
{
|
2010-12-14 18:16:38 +01:00
|
|
|
return dev->driver->bus->get_irq(dev);
|
2010-05-27 21:40:25 +02:00
|
|
|
}
|
|
|
|
|
2012-02-20 15:18:07 +01:00
|
|
|
static inline void drm_device_set_unplugged(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
smp_wmb();
|
|
|
|
atomic_set(&dev->unplugged, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int drm_device_is_unplugged(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
int ret = atomic_read(&dev->unplugged);
|
|
|
|
smp_rmb();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
drm: review locking rules in drm_crtc.c
- config_cleanup was confused: It claimed that callers need to hold
the modeset lock, but the connector|encoder_cleanup helpers grabbed
that themselves (note that crtc_cleanup did _not_ grab the modeset
lock). Which resulted in all drivers _not_ hodling the lock. Since
this is for single-threaded cleanup code, drop the requirement from
docs and also drop the lock_grabbing from all _cleanup functions.
- Kill the LOCKING section in the doctype, since clearly we're not
good enough to keep them up-to-date. And misleading locking
documentation is worse than useless (see e.g. the comment in the
vmgfx driver about the cleanup mess). And since for most functions
the very first line either grabs the lock or has a WARN_ON(!locked)
the documentation doesn't really add anything.
- Instead put in some effort into explaining the only two special
cases a bit better: config_init and config_cleanup are both called
from single-threaded setup/teardown code, so don't do any locking.
It's the driver's job though to enforce this.
- Where lacking, add a WARN_ON(!is_locked). Not many places though,
since locking around fbdev setup/teardown is through-roughly screwed
up, and so will break almost every single WARN annotation I've tried
to add.
- Add a drm_modeset_is_locked helper - the Grate Modset Locking Rework
will use the compiler to assist in the big reorg by renaming the
mode lock, so start encapsulating things. Unfortunately this ended
up in the "wrong" header file since it needs the definition of
struct drm_device.
v2: Drop most WARNS again - we hit them all over the place, mostly in
the setup and teardown sequences. And trying to fix it up leads to
nice deadlocks, since the locking in the setup code is really
inconsistent.
Reviewed-by: Rob Clark <rob@ti.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-12-01 23:43:11 +01:00
|
|
|
static inline bool drm_modeset_is_locked(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
return mutex_is_locked(&dev->mode_config.mutex);
|
|
|
|
}
|
|
|
|
|
drm: implement experimental render nodes
Render nodes provide an API for userspace to use non-privileged GPU
commands without any running DRM-Master. It is useful for offscreen
rendering, GPGPU clients, and normal render clients which do not perform
modesetting.
Compared to legacy clients, render clients no longer need any
authentication to perform client ioctls. Instead, user-space controls
render/client access to GPUs via filesystem access-modes on the
render-node. Once a render-node was opened, a client has full access to
the client/render operations on the GPU. However, no modesetting or ioctls
that affect global state are allowed on render nodes.
To prevent privilege-escalation, drivers must explicitly state that they
support render nodes. They must mark their render-only ioctls as
DRM_RENDER_ALLOW so render clients can use them. Furthermore, they must
support clients without any attached master.
If filesystem access-modes are not enough for fine-grained access control
to render nodes (very unlikely, considering the versaitlity of FS-ACLs),
you may still fall-back to fd-passing from server to client (which allows
arbitrary access-control). However, note that revoking access is
currently impossible and unlikely to get implemented.
Note: Render clients no longer have any associated DRM-Master as they are
supposed to be independent of any server state. DRM core highly depends on
file_priv->master to be non-NULL for modesetting/ctx/etc. commands.
Therefore, drivers must be very careful to not require DRM-Master if they
support DRIVER_RENDER.
So far render-nodes are protected by "drm_rnodes". As long as this
module-parameter is not set to 1, a driver will not create render nodes.
This allows us to experiment with the API a bit before we stabilize it.
v2: drop insecure GEM_FLINK to force use of dmabuf
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-08-25 18:29:00 +02:00
|
|
|
static inline bool drm_is_render_client(struct drm_file *file_priv)
|
|
|
|
{
|
|
|
|
return file_priv->minor->type == DRM_MINOR_RENDER;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/******************************************************************/
|
|
|
|
/** \name Internal function definitions */
|
|
|
|
/*@{*/
|
|
|
|
|
|
|
|
/* Driver support (drm_drv.h) */
|
2009-12-16 23:17:09 +01:00
|
|
|
extern long drm_ioctl(struct file *filp,
|
|
|
|
unsigned int cmd, unsigned long arg);
|
2005-09-25 06:28:13 +02:00
|
|
|
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) */
|
2010-07-10 23:51:39 +02:00
|
|
|
extern struct mutex drm_global_mutex;
|
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);
|
2009-09-11 20:33:34 +02:00
|
|
|
extern ssize_t drm_read(struct file *filp, char __user *buffer,
|
|
|
|
size_t count, loff_t *offset);
|
2005-09-25 06:28:13 +02:00
|
|
|
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);
|
2008-11-05 19:31:53 +01:00
|
|
|
extern int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma);
|
2012-05-01 18:04:51 +02:00
|
|
|
extern void drm_vm_open_locked(struct drm_device *dev, struct vm_area_struct *vma);
|
|
|
|
extern void drm_vm_close_locked(struct drm_device *dev, struct vm_area_struct *vma);
|
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) */
|
2012-10-02 19:01:25 +02:00
|
|
|
#include <drm/drm_memory.h>
|
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);
|
2011-02-21 02:17:35 +01:00
|
|
|
extern int drm_getcap(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2013-09-25 17:45:20 +02:00
|
|
|
extern int drm_setclientcap(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2007-09-03 04:06:45 +02:00
|
|
|
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_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
|
|
|
|
2013-09-20 00:32:59 +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
|
|
|
|
|
|
|
/* 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);
|
2012-01-24 18:54:21 +01:00
|
|
|
extern int drm_remove_magic(struct drm_master *master, drm_magic_t magic);
|
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);
|
2012-06-01 16:20:22 +02:00
|
|
|
void drm_clflush_sg(struct sg_table *st);
|
2012-03-25 19:47:30 +02:00
|
|
|
void drm_clflush_virt_range(char *addr, unsigned long length);
|
2008-07-30 21:06:12 +02:00
|
|
|
|
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_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);
|
2009-02-02 06:55:47 +01:00
|
|
|
extern int drm_addmap(struct drm_device *dev, resource_size_t offset,
|
2007-07-11 07:27:12 +02:00
|
|
|
unsigned int size, enum drm_map_type type,
|
2009-02-02 06:55:46 +01:00
|
|
|
enum drm_map_flags flags, struct drm_local_map **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);
|
2009-02-02 06:55:46 +01:00
|
|
|
extern int drm_rmmap(struct drm_device *dev, struct drm_local_map *map);
|
|
|
|
extern int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map);
|
2007-09-03 04:06:45 +02:00
|
|
|
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);
|
2013-08-08 15:41:29 +02:00
|
|
|
extern int drm_dma_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* DMA support (drm_dma.h) */
|
2013-08-08 15:41:19 +02:00
|
|
|
extern int drm_legacy_dma_setup(struct drm_device *dev);
|
|
|
|
extern void drm_legacy_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);
|
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);
|
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);
|
|
|
|
extern u32 drm_vblank_count(struct drm_device *dev, int crtc);
|
drm/vblank: Add support for precise vblank timestamping.
The DRI2 swap & sync implementation needs precise
vblank counts and precise timestamps corresponding
to those vblank counts. For conformance to the OpenML
OML_sync_control extension specification the DRM
timestamp associated with a vblank count should
correspond to the start of video scanout of the first
scanline of the video frame following the vblank
interval for that vblank count.
Therefore we need to carry around precise timestamps
for vblanks. Currently the DRM and KMS drivers generate
timestamps ad-hoc via do_gettimeofday() in some
places. The resulting timestamps are sometimes not
very precise due to interrupt handling delays, they
don't conform to OML_sync_control and some are wrong,
as they aren't taken synchronized to the vblank.
This patch implements support inside the drm core
for precise and robust timestamping. It consists
of the following interrelated pieces.
1. Vblank timestamp caching:
A per-crtc ringbuffer stores the most recent vblank
timestamps corresponding to vblank counts.
The ringbuffer can be read out lock-free via the
accessor function:
struct timeval timestamp;
vblankcount = drm_vblank_count_and_time(dev, crtcid, ×tamp).
The function returns the current vblank count and
the corresponding timestamp for start of video
scanout following the vblank interval. It can be
used anywhere between enclosing drm_vblank_get(dev, crtcid)
and drm_vblank_put(dev,crtcid) statements. It is used
inside the drmWaitVblank ioctl and in the vblank event
queueing and handling. It should be used by kms drivers for
timestamping of bufferswap completion.
The timestamp ringbuffer is reinitialized each time
vblank irq's get reenabled in drm_vblank_get()/
drm_update_vblank_count(). It is invalidated when
vblank irq's get disabled.
The ringbuffer is updated inside drm_handle_vblank()
at each vblank irq.
2. Calculation of precise vblank timestamps:
drm_get_last_vbltimestamp() is used to compute the
timestamp for the end of the most recent vblank (if
inside active scanout), or the expected end of the
current vblank interval (if called inside a vblank
interval). The function calls into a new optional kms
driver entry point dev->driver->get_vblank_timestamp()
which is supposed to provide the precise timestamp.
If a kms driver doesn't implement the entry point or
if the call fails, a simple do_gettimeofday() timestamp
is returned as crude approximation of the true vblank time.
A new drm module parameter drm.timestamp_precision_usec
allows to disable high precision timestamps (if set to
zero) or to specify the maximum acceptable error in
the timestamps in microseconds.
Kms drivers could implement their get_vblank_timestamp()
function in a gpu specific way, as long as returned
timestamps conform to OML_sync_control, e.g., by use
of gpu specific hardware timestamps.
Optionally, kms drivers can simply wrap and use the new
utility function drm_calc_vbltimestamp_from_scanoutpos().
This function calls a new optional kms driver function
dev->driver->get_scanout_position() which returns the
current horizontal and vertical video scanout position
of the crtc. The scanout position together with the
drm_display_timing of the current video mode is used
to calculate elapsed time relative to start of active scanout
for the current video frame. This elapsed time is subtracted
from the current do_gettimeofday() time to get the timestamp
corresponding to start of video scanout. Currently
non-interlaced, non-doublescan video modes, with or
without panel scaling are handled correctly. Interlaced/
doublescan modes are tbd in a future patch.
3. Filtering of redundant vblank irq's and removal of
some race-conditions in the vblank irq enable/disable path:
Some gpu's (e.g., Radeon R500/R600) send spurious vblank
irq's outside the vblank if vblank irq's get reenabled.
These get detected by use of the vblank timestamps and
filtered out to avoid miscounting of vblanks.
Some race-conditions between the vblank irq enable/disable
functions, the vblank irq handler and the gpu itself (updating
its hardware vblank counter in the "wrong" moment) are
fixed inside vblank_disable_and_save() and
drm_update_vblank_count() by use of the vblank timestamps and
a new spinlock dev->vblank_time_lock.
The time until vblank irq disable is now configurable via
a new drm module parameter drm.vblankoffdelay to allow
experimentation with timeouts that are much shorter than
the current 5 seconds and should allow longer vblank off
periods for better power savings.
Followup patches will use these new functions to
implement precise timestamping for the intel and radeon
kms drivers.
Signed-off-by: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2010-10-23 04:20:23 +02:00
|
|
|
extern u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc,
|
|
|
|
struct timeval *vblanktime);
|
2012-10-17 00:48:40 +02:00
|
|
|
extern void drm_send_vblank_event(struct drm_device *dev, int crtc,
|
|
|
|
struct drm_pending_vblank_event *e);
|
drm/i915: Suppress spurious vblank interrupts
Hugh Dickins found that characters in xterm were going missing and oft
delayed. Being the curious type, he managed to associate this with the
new high-precision vblank patches; disabling these he found, restored
the orderliness of his characters.
The oddness begins when one realised that Hugh was not using vblanks at
all on his system (fvwm and some xterms). Instead, all he had to go on
were warning of a pipe underrun, curiously enough at around 60Hz. He
poked and found that in addition to the underrun warning, the hardware
was flagging the start of a new frame, a vblank, which in turn was
kicking off the pending vblank processing code.
There is little we can do for the underruns on Hugh's machine, a
Crestline [965GM], which must have its FIFO watermarks set to 8.
However, we do not need to process the vblank if we know that they are
disabled...
Reported-by: Hugh Dickins <hughd@google.com>
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
2011-01-31 11:48:04 +01:00
|
|
|
extern bool drm_handle_vblank(struct drm_device *dev, int crtc);
|
2008-09-30 21:14:26 +02:00
|
|
|
extern int drm_vblank_get(struct drm_device *dev, int crtc);
|
|
|
|
extern void drm_vblank_put(struct drm_device *dev, int crtc);
|
2009-11-09 05:51:22 +01:00
|
|
|
extern void drm_vblank_off(struct drm_device *dev, int crtc);
|
2008-11-18 18:30:25 +01:00
|
|
|
extern void drm_vblank_cleanup(struct drm_device *dev);
|
drm/vblank: Add support for precise vblank timestamping.
The DRI2 swap & sync implementation needs precise
vblank counts and precise timestamps corresponding
to those vblank counts. For conformance to the OpenML
OML_sync_control extension specification the DRM
timestamp associated with a vblank count should
correspond to the start of video scanout of the first
scanline of the video frame following the vblank
interval for that vblank count.
Therefore we need to carry around precise timestamps
for vblanks. Currently the DRM and KMS drivers generate
timestamps ad-hoc via do_gettimeofday() in some
places. The resulting timestamps are sometimes not
very precise due to interrupt handling delays, they
don't conform to OML_sync_control and some are wrong,
as they aren't taken synchronized to the vblank.
This patch implements support inside the drm core
for precise and robust timestamping. It consists
of the following interrelated pieces.
1. Vblank timestamp caching:
A per-crtc ringbuffer stores the most recent vblank
timestamps corresponding to vblank counts.
The ringbuffer can be read out lock-free via the
accessor function:
struct timeval timestamp;
vblankcount = drm_vblank_count_and_time(dev, crtcid, ×tamp).
The function returns the current vblank count and
the corresponding timestamp for start of video
scanout following the vblank interval. It can be
used anywhere between enclosing drm_vblank_get(dev, crtcid)
and drm_vblank_put(dev,crtcid) statements. It is used
inside the drmWaitVblank ioctl and in the vblank event
queueing and handling. It should be used by kms drivers for
timestamping of bufferswap completion.
The timestamp ringbuffer is reinitialized each time
vblank irq's get reenabled in drm_vblank_get()/
drm_update_vblank_count(). It is invalidated when
vblank irq's get disabled.
The ringbuffer is updated inside drm_handle_vblank()
at each vblank irq.
2. Calculation of precise vblank timestamps:
drm_get_last_vbltimestamp() is used to compute the
timestamp for the end of the most recent vblank (if
inside active scanout), or the expected end of the
current vblank interval (if called inside a vblank
interval). The function calls into a new optional kms
driver entry point dev->driver->get_vblank_timestamp()
which is supposed to provide the precise timestamp.
If a kms driver doesn't implement the entry point or
if the call fails, a simple do_gettimeofday() timestamp
is returned as crude approximation of the true vblank time.
A new drm module parameter drm.timestamp_precision_usec
allows to disable high precision timestamps (if set to
zero) or to specify the maximum acceptable error in
the timestamps in microseconds.
Kms drivers could implement their get_vblank_timestamp()
function in a gpu specific way, as long as returned
timestamps conform to OML_sync_control, e.g., by use
of gpu specific hardware timestamps.
Optionally, kms drivers can simply wrap and use the new
utility function drm_calc_vbltimestamp_from_scanoutpos().
This function calls a new optional kms driver function
dev->driver->get_scanout_position() which returns the
current horizontal and vertical video scanout position
of the crtc. The scanout position together with the
drm_display_timing of the current video mode is used
to calculate elapsed time relative to start of active scanout
for the current video frame. This elapsed time is subtracted
from the current do_gettimeofday() time to get the timestamp
corresponding to start of video scanout. Currently
non-interlaced, non-doublescan video modes, with or
without panel scaling are handled correctly. Interlaced/
doublescan modes are tbd in a future patch.
3. Filtering of redundant vblank irq's and removal of
some race-conditions in the vblank irq enable/disable path:
Some gpu's (e.g., Radeon R500/R600) send spurious vblank
irq's outside the vblank if vblank irq's get reenabled.
These get detected by use of the vblank timestamps and
filtered out to avoid miscounting of vblanks.
Some race-conditions between the vblank irq enable/disable
functions, the vblank irq handler and the gpu itself (updating
its hardware vblank counter in the "wrong" moment) are
fixed inside vblank_disable_and_save() and
drm_update_vblank_count() by use of the vblank timestamps and
a new spinlock dev->vblank_time_lock.
The time until vblank irq disable is now configurable via
a new drm module parameter drm.vblankoffdelay to allow
experimentation with timeouts that are much shorter than
the current 5 seconds and should allow longer vblank off
periods for better power savings.
Followup patches will use these new functions to
implement precise timestamping for the intel and radeon
kms drivers.
Signed-off-by: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2010-10-23 04:20:23 +02:00
|
|
|
extern u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
|
|
|
|
struct timeval *tvblank, unsigned flags);
|
|
|
|
extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev,
|
|
|
|
int crtc, int *max_error,
|
|
|
|
struct timeval *vblank_time,
|
|
|
|
unsigned flags,
|
|
|
|
struct drm_crtc *refcrtc);
|
|
|
|
extern void drm_calc_timestamping_constants(struct drm_crtc *crtc);
|
|
|
|
|
2011-04-17 08:43:32 +02:00
|
|
|
extern bool
|
|
|
|
drm_mode_parse_command_line_for_connector(const char *mode_option,
|
|
|
|
struct drm_connector *connector,
|
|
|
|
struct drm_cmdline_mode *mode);
|
|
|
|
|
|
|
|
extern struct drm_display_mode *
|
|
|
|
drm_mode_create_from_cmdline_mode(struct drm_device *dev,
|
|
|
|
struct drm_cmdline_mode *cmd);
|
|
|
|
|
2012-11-14 11:22:52 +01:00
|
|
|
extern int drm_display_mode_from_videomode(const struct videomode *vm,
|
|
|
|
struct drm_display_mode *dmode);
|
2012-10-28 18:28:06 +01:00
|
|
|
extern int of_get_drm_display_mode(struct device_node *np,
|
|
|
|
struct drm_display_mode *dmode,
|
|
|
|
int index);
|
2012-11-14 11:22:52 +01:00
|
|
|
|
2008-09-30 21:14:26 +02:00
|
|
|
/* Modesetting support */
|
2008-11-07 23:05:41 +01:00
|
|
|
extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc);
|
|
|
|
extern void drm_vblank_post_modeset(struct drm_device *dev, int crtc);
|
2008-09-30 21:14:26 +02:00
|
|
|
extern int drm_modeset_ctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* AGP/GART support (drm_agpsupport.h) */
|
2013-08-08 22:19:12 +02:00
|
|
|
|
|
|
|
#include <drm/drm_agpsupport.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Stub support (drm_stub.h) */
|
2008-11-28 05:22:24 +01:00
|
|
|
extern int drm_setmaster_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
struct drm_master *drm_master_create(struct drm_minor *minor);
|
|
|
|
extern struct drm_master *drm_master_get(struct drm_master *master);
|
|
|
|
extern void drm_master_put(struct drm_master **master);
|
2010-12-14 18:16:38 +01:00
|
|
|
|
2009-01-04 22:55:33 +01:00
|
|
|
extern void drm_put_dev(struct drm_device *dev);
|
2008-04-21 08:47:32 +02:00
|
|
|
extern int drm_put_minor(struct drm_minor **minor);
|
2012-02-20 15:18:07 +01:00
|
|
|
extern void drm_unplug_dev(struct drm_device *dev);
|
2005-09-25 06:28:13 +02:00
|
|
|
extern unsigned int drm_debug;
|
drm: implement experimental render nodes
Render nodes provide an API for userspace to use non-privileged GPU
commands without any running DRM-Master. It is useful for offscreen
rendering, GPGPU clients, and normal render clients which do not perform
modesetting.
Compared to legacy clients, render clients no longer need any
authentication to perform client ioctls. Instead, user-space controls
render/client access to GPUs via filesystem access-modes on the
render-node. Once a render-node was opened, a client has full access to
the client/render operations on the GPU. However, no modesetting or ioctls
that affect global state are allowed on render nodes.
To prevent privilege-escalation, drivers must explicitly state that they
support render nodes. They must mark their render-only ioctls as
DRM_RENDER_ALLOW so render clients can use them. Furthermore, they must
support clients without any attached master.
If filesystem access-modes are not enough for fine-grained access control
to render nodes (very unlikely, considering the versaitlity of FS-ACLs),
you may still fall-back to fd-passing from server to client (which allows
arbitrary access-control). However, note that revoking access is
currently impossible and unlikely to get implemented.
Note: Render clients no longer have any associated DRM-Master as they are
supposed to be independent of any server state. DRM core highly depends on
file_priv->master to be non-NULL for modesetting/ctx/etc. commands.
Therefore, drivers must be very careful to not require DRM-Master if they
support DRIVER_RENDER.
So far render-nodes are protected by "drm_rnodes". As long as this
module-parameter is not set to 1, a driver will not create render nodes.
This allows us to experiment with the API a bit before we stabilize it.
v2: drop insecure GEM_FLINK to force use of dmabuf
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2013-08-25 18:29:00 +02:00
|
|
|
extern unsigned int drm_rnodes;
|
2008-04-21 08:47:32 +02:00
|
|
|
|
drm/vblank: Add support for precise vblank timestamping.
The DRI2 swap & sync implementation needs precise
vblank counts and precise timestamps corresponding
to those vblank counts. For conformance to the OpenML
OML_sync_control extension specification the DRM
timestamp associated with a vblank count should
correspond to the start of video scanout of the first
scanline of the video frame following the vblank
interval for that vblank count.
Therefore we need to carry around precise timestamps
for vblanks. Currently the DRM and KMS drivers generate
timestamps ad-hoc via do_gettimeofday() in some
places. The resulting timestamps are sometimes not
very precise due to interrupt handling delays, they
don't conform to OML_sync_control and some are wrong,
as they aren't taken synchronized to the vblank.
This patch implements support inside the drm core
for precise and robust timestamping. It consists
of the following interrelated pieces.
1. Vblank timestamp caching:
A per-crtc ringbuffer stores the most recent vblank
timestamps corresponding to vblank counts.
The ringbuffer can be read out lock-free via the
accessor function:
struct timeval timestamp;
vblankcount = drm_vblank_count_and_time(dev, crtcid, ×tamp).
The function returns the current vblank count and
the corresponding timestamp for start of video
scanout following the vblank interval. It can be
used anywhere between enclosing drm_vblank_get(dev, crtcid)
and drm_vblank_put(dev,crtcid) statements. It is used
inside the drmWaitVblank ioctl and in the vblank event
queueing and handling. It should be used by kms drivers for
timestamping of bufferswap completion.
The timestamp ringbuffer is reinitialized each time
vblank irq's get reenabled in drm_vblank_get()/
drm_update_vblank_count(). It is invalidated when
vblank irq's get disabled.
The ringbuffer is updated inside drm_handle_vblank()
at each vblank irq.
2. Calculation of precise vblank timestamps:
drm_get_last_vbltimestamp() is used to compute the
timestamp for the end of the most recent vblank (if
inside active scanout), or the expected end of the
current vblank interval (if called inside a vblank
interval). The function calls into a new optional kms
driver entry point dev->driver->get_vblank_timestamp()
which is supposed to provide the precise timestamp.
If a kms driver doesn't implement the entry point or
if the call fails, a simple do_gettimeofday() timestamp
is returned as crude approximation of the true vblank time.
A new drm module parameter drm.timestamp_precision_usec
allows to disable high precision timestamps (if set to
zero) or to specify the maximum acceptable error in
the timestamps in microseconds.
Kms drivers could implement their get_vblank_timestamp()
function in a gpu specific way, as long as returned
timestamps conform to OML_sync_control, e.g., by use
of gpu specific hardware timestamps.
Optionally, kms drivers can simply wrap and use the new
utility function drm_calc_vbltimestamp_from_scanoutpos().
This function calls a new optional kms driver function
dev->driver->get_scanout_position() which returns the
current horizontal and vertical video scanout position
of the crtc. The scanout position together with the
drm_display_timing of the current video mode is used
to calculate elapsed time relative to start of active scanout
for the current video frame. This elapsed time is subtracted
from the current do_gettimeofday() time to get the timestamp
corresponding to start of video scanout. Currently
non-interlaced, non-doublescan video modes, with or
without panel scaling are handled correctly. Interlaced/
doublescan modes are tbd in a future patch.
3. Filtering of redundant vblank irq's and removal of
some race-conditions in the vblank irq enable/disable path:
Some gpu's (e.g., Radeon R500/R600) send spurious vblank
irq's outside the vblank if vblank irq's get reenabled.
These get detected by use of the vblank timestamps and
filtered out to avoid miscounting of vblanks.
Some race-conditions between the vblank irq enable/disable
functions, the vblank irq handler and the gpu itself (updating
its hardware vblank counter in the "wrong" moment) are
fixed inside vblank_disable_and_save() and
drm_update_vblank_count() by use of the vblank timestamps and
a new spinlock dev->vblank_time_lock.
The time until vblank irq disable is now configurable via
a new drm module parameter drm.vblankoffdelay to allow
experimentation with timeouts that are much shorter than
the current 5 seconds and should allow longer vblank off
periods for better power savings.
Followup patches will use these new functions to
implement precise timestamping for the intel and radeon
kms drivers.
Signed-off-by: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2010-10-23 04:20:23 +02:00
|
|
|
extern unsigned int drm_vblank_offdelay;
|
|
|
|
extern unsigned int drm_timestamp_precision;
|
2012-10-23 20:53:26 +02:00
|
|
|
extern unsigned int drm_timestamp_monotonic;
|
drm/vblank: Add support for precise vblank timestamping.
The DRI2 swap & sync implementation needs precise
vblank counts and precise timestamps corresponding
to those vblank counts. For conformance to the OpenML
OML_sync_control extension specification the DRM
timestamp associated with a vblank count should
correspond to the start of video scanout of the first
scanline of the video frame following the vblank
interval for that vblank count.
Therefore we need to carry around precise timestamps
for vblanks. Currently the DRM and KMS drivers generate
timestamps ad-hoc via do_gettimeofday() in some
places. The resulting timestamps are sometimes not
very precise due to interrupt handling delays, they
don't conform to OML_sync_control and some are wrong,
as they aren't taken synchronized to the vblank.
This patch implements support inside the drm core
for precise and robust timestamping. It consists
of the following interrelated pieces.
1. Vblank timestamp caching:
A per-crtc ringbuffer stores the most recent vblank
timestamps corresponding to vblank counts.
The ringbuffer can be read out lock-free via the
accessor function:
struct timeval timestamp;
vblankcount = drm_vblank_count_and_time(dev, crtcid, ×tamp).
The function returns the current vblank count and
the corresponding timestamp for start of video
scanout following the vblank interval. It can be
used anywhere between enclosing drm_vblank_get(dev, crtcid)
and drm_vblank_put(dev,crtcid) statements. It is used
inside the drmWaitVblank ioctl and in the vblank event
queueing and handling. It should be used by kms drivers for
timestamping of bufferswap completion.
The timestamp ringbuffer is reinitialized each time
vblank irq's get reenabled in drm_vblank_get()/
drm_update_vblank_count(). It is invalidated when
vblank irq's get disabled.
The ringbuffer is updated inside drm_handle_vblank()
at each vblank irq.
2. Calculation of precise vblank timestamps:
drm_get_last_vbltimestamp() is used to compute the
timestamp for the end of the most recent vblank (if
inside active scanout), or the expected end of the
current vblank interval (if called inside a vblank
interval). The function calls into a new optional kms
driver entry point dev->driver->get_vblank_timestamp()
which is supposed to provide the precise timestamp.
If a kms driver doesn't implement the entry point or
if the call fails, a simple do_gettimeofday() timestamp
is returned as crude approximation of the true vblank time.
A new drm module parameter drm.timestamp_precision_usec
allows to disable high precision timestamps (if set to
zero) or to specify the maximum acceptable error in
the timestamps in microseconds.
Kms drivers could implement their get_vblank_timestamp()
function in a gpu specific way, as long as returned
timestamps conform to OML_sync_control, e.g., by use
of gpu specific hardware timestamps.
Optionally, kms drivers can simply wrap and use the new
utility function drm_calc_vbltimestamp_from_scanoutpos().
This function calls a new optional kms driver function
dev->driver->get_scanout_position() which returns the
current horizontal and vertical video scanout position
of the crtc. The scanout position together with the
drm_display_timing of the current video mode is used
to calculate elapsed time relative to start of active scanout
for the current video frame. This elapsed time is subtracted
from the current do_gettimeofday() time to get the timestamp
corresponding to start of video scanout. Currently
non-interlaced, non-doublescan video modes, with or
without panel scaling are handled correctly. Interlaced/
doublescan modes are tbd in a future patch.
3. Filtering of redundant vblank irq's and removal of
some race-conditions in the vblank irq enable/disable path:
Some gpu's (e.g., Radeon R500/R600) send spurious vblank
irq's outside the vblank if vblank irq's get reenabled.
These get detected by use of the vblank timestamps and
filtered out to avoid miscounting of vblanks.
Some race-conditions between the vblank irq enable/disable
functions, the vblank irq handler and the gpu itself (updating
its hardware vblank counter in the "wrong" moment) are
fixed inside vblank_disable_and_save() and
drm_update_vblank_count() by use of the vblank timestamps and
a new spinlock dev->vblank_time_lock.
The time until vblank irq disable is now configurable via
a new drm module parameter drm.vblankoffdelay to allow
experimentation with timeouts that are much shorter than
the current 5 seconds and should allow longer vblank off
periods for better power savings.
Followup patches will use these new functions to
implement precise timestamping for the intel and radeon
kms drivers.
Signed-off-by: Mario Kleiner <mario.kleiner@tuebingen.mpg.de>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2010-10-23 04:20:23 +02:00
|
|
|
|
2006-01-20 23:08:59 +01:00
|
|
|
extern struct class *drm_class;
|
2009-02-18 02:08:49 +01:00
|
|
|
extern struct dentry *drm_debugfs_root;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-04-21 08:47:32 +02:00
|
|
|
extern struct idr drm_minors_idr;
|
|
|
|
|
2009-02-02 06:55:46 +01:00
|
|
|
extern struct drm_local_map *drm_getsarea(struct drm_device *dev);
|
2007-05-25 21:04:51 +02:00
|
|
|
|
2009-02-18 02:08:49 +01:00
|
|
|
/* Debugfs support */
|
|
|
|
#if defined(CONFIG_DEBUG_FS)
|
|
|
|
extern int drm_debugfs_init(struct drm_minor *minor, int minor_id,
|
|
|
|
struct dentry *root);
|
|
|
|
extern int drm_debugfs_create_files(struct drm_info_list *files, int count,
|
|
|
|
struct dentry *root, struct drm_minor *minor);
|
|
|
|
extern int drm_debugfs_remove_files(struct drm_info_list *files, int count,
|
|
|
|
struct drm_minor *minor);
|
|
|
|
extern int drm_debugfs_cleanup(struct drm_minor *minor);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Info file support */
|
|
|
|
extern int drm_name_info(struct seq_file *m, void *data);
|
|
|
|
extern int drm_vm_info(struct seq_file *m, void *data);
|
|
|
|
extern int drm_bufs_info(struct seq_file *m, void *data);
|
|
|
|
extern int drm_vblank_info(struct seq_file *m, void *data);
|
|
|
|
extern int drm_clients_info(struct seq_file *m, void* data);
|
|
|
|
extern int drm_gem_name_info(struct seq_file *m, void *data);
|
|
|
|
|
2011-11-25 16:21:02 +01:00
|
|
|
|
2013-01-15 21:47:42 +01:00
|
|
|
extern struct dma_buf *drm_gem_prime_export(struct drm_device *dev,
|
|
|
|
struct drm_gem_object *obj, int flags);
|
2011-11-25 16:21:02 +01:00
|
|
|
extern int drm_gem_prime_handle_to_fd(struct drm_device *dev,
|
|
|
|
struct drm_file *file_priv, uint32_t handle, uint32_t flags,
|
|
|
|
int *prime_fd);
|
2013-01-15 21:47:42 +01:00
|
|
|
extern struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
|
|
|
|
struct dma_buf *dma_buf);
|
2011-11-25 16:21:02 +01:00
|
|
|
extern int drm_gem_prime_fd_to_handle(struct drm_device *dev,
|
|
|
|
struct drm_file *file_priv, int prime_fd, uint32_t *handle);
|
2013-08-15 00:02:30 +02:00
|
|
|
extern void drm_gem_dmabuf_release(struct dma_buf *dma_buf);
|
2011-11-25 16:21:02 +01:00
|
|
|
|
|
|
|
extern int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
extern int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv);
|
|
|
|
|
2012-05-18 16:40:33 +02:00
|
|
|
extern int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, struct page **pages,
|
|
|
|
dma_addr_t *addrs, int max_pages);
|
2011-11-25 16:21:02 +01:00
|
|
|
extern struct sg_table *drm_prime_pages_to_sg(struct page **pages, int nr_pages);
|
|
|
|
extern void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg);
|
|
|
|
|
2013-07-16 09:12:04 +02:00
|
|
|
int drm_gem_dumb_destroy(struct drm_file *file,
|
|
|
|
struct drm_device *dev,
|
|
|
|
uint32_t handle);
|
2011-11-25 16:21:02 +01:00
|
|
|
|
|
|
|
void drm_prime_init_file_private(struct drm_prime_file_private *prime_fpriv);
|
|
|
|
void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv);
|
2013-08-15 00:02:49 +02:00
|
|
|
void drm_prime_remove_buf_handle_locked(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf);
|
2011-11-25 16:21:02 +01:00
|
|
|
|
2009-02-18 02:08:49 +01:00
|
|
|
#if DRM_DEBUG_CODE
|
|
|
|
extern int drm_vma_info(struct seq_file *m, void *data);
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Scatter Gather Support (drm_scatter.h) */
|
2013-08-08 15:41:17 +02:00
|
|
|
extern void drm_legacy_sg_cleanup(struct drm_device *dev);
|
2013-07-10 14:11:50 +02:00
|
|
|
extern int drm_sg_alloc(struct drm_device *dev, void *data,
|
2007-09-03 04:06:45 +02:00
|
|
|
struct drm_file *file_priv);
|
|
|
|
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,
|
2010-01-05 04:25:05 +01:00
|
|
|
size_t align);
|
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);
|
2008-11-07 23:05:41 +01:00
|
|
|
extern void drm_sysfs_hotplug_event(struct drm_device *dev);
|
2008-04-21 08:47:32 +02:00
|
|
|
extern void drm_sysfs_device_remove(struct drm_minor *minor);
|
2008-11-07 23:05:41 +01:00
|
|
|
extern int drm_sysfs_connector_add(struct drm_connector *connector);
|
|
|
|
extern void drm_sysfs_connector_remove(struct drm_connector *connector);
|
2005-04-17 00:20:36 +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);
|
2008-11-05 19:31:53 +01:00
|
|
|
void drm_gem_destroy(struct drm_device *dev);
|
2010-04-09 21:05:05 +02:00
|
|
|
void drm_gem_object_release(struct drm_gem_object *obj);
|
2008-07-30 21:06:12 +02:00
|
|
|
void drm_gem_object_free(struct kref *kref);
|
|
|
|
struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev,
|
|
|
|
size_t size);
|
2010-04-09 21:05:04 +02:00
|
|
|
int drm_gem_object_init(struct drm_device *dev,
|
|
|
|
struct drm_gem_object *obj, size_t size);
|
2013-07-11 11:56:32 +02:00
|
|
|
void drm_gem_private_object_init(struct drm_device *dev,
|
|
|
|
struct drm_gem_object *obj, size_t size);
|
2009-02-11 23:01:46 +01:00
|
|
|
void drm_gem_vm_open(struct vm_area_struct *vma);
|
|
|
|
void drm_gem_vm_close(struct vm_area_struct *vma);
|
2013-04-16 14:14:52 +02:00
|
|
|
int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size,
|
|
|
|
struct vm_area_struct *vma);
|
2008-11-05 19:31:53 +01:00
|
|
|
int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma);
|
2008-07-30 21:06:12 +02:00
|
|
|
|
2012-10-02 19:01:25 +02:00
|
|
|
#include <drm/drm_global.h>
|
2010-03-09 01:56:52 +01:00
|
|
|
|
2008-07-30 21:06:12 +02:00
|
|
|
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)
|
|
|
|
{
|
2010-02-09 06:49:11 +01:00
|
|
|
if (obj != NULL)
|
|
|
|
kref_put(&obj->refcount, drm_gem_object_free);
|
|
|
|
}
|
2008-07-30 21:06:12 +02:00
|
|
|
|
2010-02-09 06:49:11 +01:00
|
|
|
static inline void
|
|
|
|
drm_gem_object_unreference_unlocked(struct drm_gem_object *obj)
|
|
|
|
{
|
2013-08-06 10:59:46 +02:00
|
|
|
if (obj && !atomic_add_unless(&obj->refcount.refcount, -1, 1)) {
|
2010-09-30 10:10:26 +02:00
|
|
|
struct drm_device *dev = obj->dev;
|
2013-08-06 10:59:46 +02:00
|
|
|
|
2010-09-30 10:10:26 +02:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2013-08-06 10:59:46 +02:00
|
|
|
if (likely(atomic_dec_and_test(&obj->refcount.refcount)))
|
|
|
|
drm_gem_object_free(&obj->refcount);
|
2010-09-30 10:10:26 +02:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
}
|
2008-07-30 21:06:12 +02:00
|
|
|
}
|
|
|
|
|
2013-08-15 00:02:45 +02:00
|
|
|
int drm_gem_handle_create_tail(struct drm_file *file_priv,
|
|
|
|
struct drm_gem_object *obj,
|
|
|
|
u32 *handlep);
|
2008-07-30 21:06:12 +02:00
|
|
|
int drm_gem_handle_create(struct drm_file *file_priv,
|
|
|
|
struct drm_gem_object *obj,
|
2009-08-23 11:40:55 +02:00
|
|
|
u32 *handlep);
|
2011-02-07 03:16:14 +01:00
|
|
|
int drm_gem_handle_delete(struct drm_file *filp, u32 handle);
|
2008-07-30 21:06:12 +02:00
|
|
|
|
2010-02-09 06:49:11 +01:00
|
|
|
|
2011-08-10 15:09:07 +02:00
|
|
|
void drm_gem_free_mmap_offset(struct drm_gem_object *obj);
|
|
|
|
int drm_gem_create_mmap_offset(struct drm_gem_object *obj);
|
2013-08-07 19:41:23 +02:00
|
|
|
int drm_gem_create_mmap_offset_size(struct drm_gem_object *obj, size_t size);
|
2011-08-10 15:09:07 +02:00
|
|
|
|
2013-08-07 19:41:24 +02:00
|
|
|
struct page **drm_gem_get_pages(struct drm_gem_object *obj, gfp_t gfpmask);
|
|
|
|
void drm_gem_put_pages(struct drm_gem_object *obj, struct page **pages,
|
|
|
|
bool dirty, bool accessed);
|
|
|
|
|
2008-07-30 21:06:12 +02:00
|
|
|
struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev,
|
|
|
|
struct drm_file *filp,
|
2009-08-23 11:40:55 +02:00
|
|
|
u32 handle);
|
2008-07-30 21:06:12 +02:00
|
|
|
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);
|
|
|
|
|
2009-02-02 06:55:46 +01:00
|
|
|
extern void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev);
|
|
|
|
extern void drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev);
|
|
|
|
extern void drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-02-02 06:55:46 +01:00
|
|
|
static __inline__ struct drm_local_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;
|
|
|
|
}
|
|
|
|
|
2010-12-14 18:16:38 +01:00
|
|
|
static __inline__ void drm_core_dropmap(struct drm_local_map *map)
|
2005-07-10 09:31:26 +02:00
|
|
|
{
|
2010-12-14 18:16:38 +01:00
|
|
|
}
|
|
|
|
|
2012-10-02 19:01:25 +02:00
|
|
|
#include <drm/drm_mem_util.h>
|
2010-05-27 21:40:25 +02:00
|
|
|
|
2010-12-14 18:16:38 +01:00
|
|
|
extern int drm_fill_in_dev(struct drm_device *dev,
|
|
|
|
const struct pci_device_id *ent,
|
|
|
|
struct drm_driver *driver);
|
|
|
|
int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type);
|
|
|
|
/*@}*/
|
|
|
|
|
|
|
|
/* PCI section */
|
|
|
|
static __inline__ int drm_pci_device_is_agp(struct drm_device *dev)
|
|
|
|
{
|
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);
|
|
|
|
}
|
|
|
|
|
2010-12-14 18:16:38 +01:00
|
|
|
extern int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver);
|
|
|
|
extern void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver);
|
|
|
|
extern int drm_get_pci_dev(struct pci_dev *pdev,
|
2010-05-27 21:40:25 +02:00
|
|
|
const struct pci_device_id *ent,
|
|
|
|
struct drm_driver *driver);
|
2010-12-14 18:16:38 +01:00
|
|
|
|
2012-06-27 09:35:53 +02:00
|
|
|
#define DRM_PCIE_SPEED_25 1
|
|
|
|
#define DRM_PCIE_SPEED_50 2
|
|
|
|
#define DRM_PCIE_SPEED_80 4
|
|
|
|
|
|
|
|
extern int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *speed_mask);
|
2010-12-14 18:16:38 +01:00
|
|
|
|
|
|
|
/* platform section */
|
|
|
|
extern int drm_platform_init(struct drm_driver *driver, struct platform_device *platform_device);
|
|
|
|
extern void drm_platform_exit(struct drm_driver *driver, struct platform_device *platform_device);
|
|
|
|
|
2012-01-05 10:55:22 +01:00
|
|
|
/* returns true if currently okay to sleep */
|
|
|
|
static __inline__ bool drm_can_sleep(void)
|
|
|
|
{
|
|
|
|
if (in_atomic() || in_dbg_master() || irqs_disabled())
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2005-09-25 06:28:13 +02:00
|
|
|
#endif /* __KERNEL__ */
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|