2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Created: Fri Jan 19 10:48:35 2001 by faith@acm.org
|
|
|
|
*
|
|
|
|
* Copyright 2001 VA Linux Systems, Inc., Sunnyvale, California.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
2014-05-19 11:39:07 +00:00
|
|
|
* Author Rickard E. (Rik) Faith <faith@valinux.com>
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* 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
|
|
|
|
* PRECISION INSIGHT 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.
|
|
|
|
*/
|
|
|
|
|
2014-07-23 10:29:56 +00:00
|
|
|
#include <linux/debugfs.h>
|
2014-01-03 13:09:47 +00:00
|
|
|
#include <linux/fs.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
2014-01-03 13:09:47 +00:00
|
|
|
#include <linux/mount.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 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2012-10-02 17:01:07 +00:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/drm_core.h>
|
2014-07-24 10:10:04 +00:00
|
|
|
#include "drm_legacy.h"
|
2014-09-10 10:43:53 +00:00
|
|
|
#include "drm_internal.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-25 04:28:13 +00:00
|
|
|
unsigned int drm_debug = 0; /* 1 to enable debug output */
|
2005-04-16 22:20:36 +00:00
|
|
|
EXPORT_SYMBOL(drm_debug);
|
|
|
|
|
2005-09-25 04:28:13 +00:00
|
|
|
MODULE_AUTHOR(CORE_AUTHOR);
|
|
|
|
MODULE_DESCRIPTION(CORE_DESC);
|
2005-04-16 22:20:36 +00:00
|
|
|
MODULE_LICENSE("GPL and additional rights");
|
|
|
|
MODULE_PARM_DESC(debug, "Enable debug output");
|
2014-08-06 11:49:53 +00:00
|
|
|
MODULE_PARM_DESC(vblankoffdelay, "Delay until vblank irq auto-disable [msecs] (0: never disable, <0: disable immediately)");
|
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 02:20:23 +00:00
|
|
|
MODULE_PARM_DESC(timestamp_precision_usec, "Max. error on timestamps [usecs]");
|
2012-10-23 18:53:26 +00:00
|
|
|
MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-03 19:02:20 +00:00
|
|
|
module_param_named(debug, drm_debug, int, 0600);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-02-24 14:53:25 +00:00
|
|
|
static DEFINE_SPINLOCK(drm_minor_lock);
|
2014-07-23 10:29:56 +00:00
|
|
|
static struct idr drm_minors_idr;
|
2008-04-21 06:47:32 +00:00
|
|
|
|
2006-01-20 22:08:59 +00:00
|
|
|
struct class *drm_class;
|
2014-07-23 10:29:56 +00:00
|
|
|
static struct dentry *drm_debugfs_root;
|
2011-04-18 03:35:51 +00:00
|
|
|
|
2014-10-12 05:08:57 +00:00
|
|
|
void drm_err(const char *format, ...)
|
2011-04-18 03:35:51 +00:00
|
|
|
{
|
|
|
|
struct va_format vaf;
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, format);
|
|
|
|
|
|
|
|
vaf.fmt = format;
|
|
|
|
vaf.va = &args;
|
|
|
|
|
2014-10-12 05:08:57 +00:00
|
|
|
printk(KERN_ERR "[" DRM_NAME ":%pf] *ERROR* %pV",
|
|
|
|
__builtin_return_address(0), &vaf);
|
2011-04-18 03:35:51 +00:00
|
|
|
|
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_err);
|
|
|
|
|
2014-03-24 15:53:17 +00:00
|
|
|
void drm_ut_debug_printk(const char *function_name, const char *format, ...)
|
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 06:09:47 +00:00
|
|
|
{
|
2013-11-17 21:25:02 +00:00
|
|
|
struct va_format vaf;
|
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 06:09:47 +00:00
|
|
|
va_list args;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
drm: Pull the test on drm_debug in the logging macros
In the logging code, we are currently checking is we need to output in
drm_ut_debug_printk(). This is too late. The problem is that when we write
something like:
DRM_DEBUG_DRIVER("ELD on [CONNECTOR:%d:%s], [ENCODER:%d:%s]\n",
connector->base.id,
drm_get_connector_name(connector),
connector->encoder->base.id,
drm_get_encoder_name(connector->encoder));
We start by evaluating the arguments (so call drm_get_connector_name() and
drm_get_connector_name()) before ending up in drm_ut_debug_printk() which will
then does nothing.
This means we execute a lot of instructions (drm_get_connector_name(), in turn,
calls snprintf() for example) to happily discard them in the normal case,
drm.debug=0.
So, let's put the test on drm_debug earlier, in the macros themselves.
Sprinkle an unlikely() as well for good measure.
Signed-off-by: Damien Lespiau <damien.lespiau@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2014-03-24 15:53:15 +00:00
|
|
|
va_start(args, format);
|
|
|
|
vaf.fmt = format;
|
|
|
|
vaf.va = &args;
|
|
|
|
|
2014-03-24 15:53:18 +00:00
|
|
|
printk(KERN_DEBUG "[" DRM_NAME ":%s] %pV", function_name, &vaf);
|
drm: Pull the test on drm_debug in the logging macros
In the logging code, we are currently checking is we need to output in
drm_ut_debug_printk(). This is too late. The problem is that when we write
something like:
DRM_DEBUG_DRIVER("ELD on [CONNECTOR:%d:%s], [ENCODER:%d:%s]\n",
connector->base.id,
drm_get_connector_name(connector),
connector->encoder->base.id,
drm_get_encoder_name(connector->encoder));
We start by evaluating the arguments (so call drm_get_connector_name() and
drm_get_connector_name()) before ending up in drm_ut_debug_printk() which will
then does nothing.
This means we execute a lot of instructions (drm_get_connector_name(), in turn,
calls snprintf() for example) to happily discard them in the normal case,
drm.debug=0.
So, let's put the test on drm_debug earlier, in the macros themselves.
Sprinkle an unlikely() as well for good measure.
Signed-off-by: Damien Lespiau <damien.lespiau@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>
2014-03-24 15:53:15 +00:00
|
|
|
|
|
|
|
va_end(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 06:09:47 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_ut_debug_printk);
|
2011-04-18 03:35:51 +00:00
|
|
|
|
2014-09-10 10:44:00 +00:00
|
|
|
#define DRM_MAGIC_HASH_ORDER 4 /**< Size of key hash table. Must be power of 2. */
|
|
|
|
|
2008-11-28 04:22:24 +00:00
|
|
|
struct drm_master *drm_master_create(struct drm_minor *minor)
|
|
|
|
{
|
|
|
|
struct drm_master *master;
|
|
|
|
|
2009-03-24 19:23:04 +00:00
|
|
|
master = kzalloc(sizeof(*master), GFP_KERNEL);
|
2008-11-28 04:22:24 +00:00
|
|
|
if (!master)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
kref_init(&master->refcount);
|
|
|
|
spin_lock_init(&master->lock.spinlock);
|
|
|
|
init_waitqueue_head(&master->lock.lock_queue);
|
2014-04-05 09:12:04 +00:00
|
|
|
if (drm_ht_create(&master->magiclist, DRM_MAGIC_HASH_ORDER)) {
|
|
|
|
kfree(master);
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-11-28 04:22:24 +00:00
|
|
|
INIT_LIST_HEAD(&master->magicfree);
|
|
|
|
master->minor = minor;
|
|
|
|
|
|
|
|
return master;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct drm_master *drm_master_get(struct drm_master *master)
|
|
|
|
{
|
|
|
|
kref_get(&master->refcount);
|
|
|
|
return master;
|
|
|
|
}
|
2009-12-06 20:46:28 +00:00
|
|
|
EXPORT_SYMBOL(drm_master_get);
|
2008-11-28 04:22:24 +00:00
|
|
|
|
|
|
|
static void drm_master_destroy(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct drm_master *master = container_of(kref, struct drm_master, refcount);
|
|
|
|
struct drm_device *dev = master->minor->dev;
|
2009-01-19 07:17:58 +00:00
|
|
|
struct drm_map_list *r_list, *list_temp;
|
2008-11-28 04:22:24 +00:00
|
|
|
|
2014-02-25 18:57:44 +00:00
|
|
|
mutex_lock(&dev->struct_mutex);
|
2008-11-28 04:22:24 +00:00
|
|
|
if (dev->driver->master_destroy)
|
|
|
|
dev->driver->master_destroy(dev, master);
|
|
|
|
|
2009-01-19 07:17:58 +00:00
|
|
|
list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) {
|
|
|
|
if (r_list->master == master) {
|
2014-08-29 10:12:28 +00:00
|
|
|
drm_legacy_rmmap_locked(dev, r_list->map);
|
2009-01-19 07:17:58 +00:00
|
|
|
r_list = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-28 04:22:24 +00:00
|
|
|
if (master->unique) {
|
2009-03-24 19:23:04 +00:00
|
|
|
kfree(master->unique);
|
2008-11-28 04:22:24 +00:00
|
|
|
master->unique = NULL;
|
|
|
|
master->unique_len = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
drm_ht_remove(&master->magiclist);
|
|
|
|
|
2014-02-25 18:57:44 +00:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2009-03-24 19:23:04 +00:00
|
|
|
kfree(master);
|
2008-11-28 04:22:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void drm_master_put(struct drm_master **master)
|
|
|
|
{
|
|
|
|
kref_put(&(*master)->refcount, drm_master_destroy);
|
|
|
|
*master = NULL;
|
|
|
|
}
|
2009-12-06 20:46:28 +00:00
|
|
|
EXPORT_SYMBOL(drm_master_put);
|
2008-11-28 04:22:24 +00:00
|
|
|
|
|
|
|
int drm_setmaster_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
2013-06-26 15:58:59 +00:00
|
|
|
int ret = 0;
|
2009-12-02 18:15:25 +00:00
|
|
|
|
2014-02-25 18:57:44 +00:00
|
|
|
mutex_lock(&dev->master_mutex);
|
2014-08-07 21:30:53 +00:00
|
|
|
if (file_priv->is_master)
|
2014-02-25 18:57:44 +00:00
|
|
|
goto out_unlock;
|
2008-11-28 04:22:24 +00:00
|
|
|
|
2014-02-25 18:57:44 +00:00
|
|
|
if (file_priv->minor->master) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2008-11-28 04:22:24 +00:00
|
|
|
|
2014-02-25 18:57:44 +00:00
|
|
|
if (!file_priv->master) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2012-11-15 13:04:37 +00:00
|
|
|
|
|
|
|
file_priv->minor->master = drm_master_get(file_priv->master);
|
2014-08-07 21:30:53 +00:00
|
|
|
file_priv->is_master = 1;
|
2012-11-15 13:04:37 +00:00
|
|
|
if (dev->driver->master_set) {
|
|
|
|
ret = dev->driver->master_set(dev, file_priv, false);
|
2014-08-07 21:30:53 +00:00
|
|
|
if (unlikely(ret != 0)) {
|
|
|
|
file_priv->is_master = 0;
|
2012-11-15 13:04:37 +00:00
|
|
|
drm_master_put(&file_priv->minor->master);
|
2014-08-07 21:30:53 +00:00
|
|
|
}
|
2008-11-28 04:22:24 +00:00
|
|
|
}
|
|
|
|
|
2014-02-25 18:57:44 +00:00
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&dev->master_mutex);
|
2013-06-26 15:58:59 +00:00
|
|
|
return ret;
|
2008-11-28 04:22:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{
|
2014-02-25 18:57:44 +00:00
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&dev->master_mutex);
|
2014-08-07 21:30:53 +00:00
|
|
|
if (!file_priv->is_master)
|
2014-02-25 18:57:44 +00:00
|
|
|
goto out_unlock;
|
2009-04-16 07:00:02 +00:00
|
|
|
|
2009-04-19 23:32:50 +00:00
|
|
|
if (!file_priv->minor->master)
|
2014-02-25 18:57:44 +00:00
|
|
|
goto out_unlock;
|
2009-04-19 23:32:50 +00:00
|
|
|
|
2014-02-25 18:57:44 +00:00
|
|
|
ret = 0;
|
2009-12-02 18:15:25 +00:00
|
|
|
if (dev->driver->master_drop)
|
|
|
|
dev->driver->master_drop(dev, file_priv, false);
|
2008-11-28 04:22:24 +00:00
|
|
|
drm_master_put(&file_priv->minor->master);
|
2014-08-07 21:30:53 +00:00
|
|
|
file_priv->is_master = 0;
|
2014-02-25 18:57:44 +00:00
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&dev->master_mutex);
|
|
|
|
return ret;
|
2008-11-28 04:22:24 +00:00
|
|
|
}
|
|
|
|
|
2014-02-24 14:53:25 +00:00
|
|
|
/*
|
|
|
|
* DRM Minors
|
|
|
|
* A DRM device can provide several char-dev interfaces on the DRM-Major. Each
|
|
|
|
* of them is represented by a drm_minor object. Depending on the capabilities
|
|
|
|
* of the device-driver, different interfaces are registered.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2014-02-24 14:53:25 +00:00
|
|
|
* Minors can be accessed via dev->$minor_name. This pointer is either
|
|
|
|
* NULL or a valid drm_minor pointer and stays valid as long as the device is
|
|
|
|
* valid. This means, DRM minors have the same life-time as the underlying
|
|
|
|
* device. However, this doesn't mean that the minor is active. Minors are
|
|
|
|
* registered and unregistered dynamically according to device-state.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2014-02-24 14:53:25 +00:00
|
|
|
|
2014-01-29 11:43:56 +00:00
|
|
|
static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
|
|
|
|
unsigned int type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case DRM_MINOR_LEGACY:
|
|
|
|
return &dev->primary;
|
|
|
|
case DRM_MINOR_RENDER:
|
|
|
|
return &dev->render;
|
|
|
|
case DRM_MINOR_CONTROL:
|
|
|
|
return &dev->control;
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
|
|
|
|
{
|
|
|
|
struct drm_minor *minor;
|
2014-07-23 08:34:52 +00:00
|
|
|
unsigned long flags;
|
|
|
|
int r;
|
2014-01-29 11:43:56 +00:00
|
|
|
|
|
|
|
minor = kzalloc(sizeof(*minor), GFP_KERNEL);
|
|
|
|
if (!minor)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
minor->type = type;
|
|
|
|
minor->dev = dev;
|
|
|
|
|
2014-07-23 08:34:52 +00:00
|
|
|
idr_preload(GFP_KERNEL);
|
|
|
|
spin_lock_irqsave(&drm_minor_lock, flags);
|
|
|
|
r = idr_alloc(&drm_minors_idr,
|
|
|
|
NULL,
|
|
|
|
64 * type,
|
|
|
|
64 * (type + 1),
|
|
|
|
GFP_NOWAIT);
|
|
|
|
spin_unlock_irqrestore(&drm_minor_lock, flags);
|
|
|
|
idr_preload_end();
|
|
|
|
|
|
|
|
if (r < 0)
|
|
|
|
goto err_free;
|
|
|
|
|
|
|
|
minor->index = r;
|
|
|
|
|
2014-07-23 09:38:38 +00:00
|
|
|
minor->kdev = drm_sysfs_minor_alloc(minor);
|
|
|
|
if (IS_ERR(minor->kdev)) {
|
|
|
|
r = PTR_ERR(minor->kdev);
|
|
|
|
goto err_index;
|
|
|
|
}
|
|
|
|
|
2014-01-29 11:43:56 +00:00
|
|
|
*drm_minor_get_slot(dev, type) = minor;
|
|
|
|
return 0;
|
2014-07-23 08:34:52 +00:00
|
|
|
|
2014-07-23 09:38:38 +00:00
|
|
|
err_index:
|
|
|
|
spin_lock_irqsave(&drm_minor_lock, flags);
|
|
|
|
idr_remove(&drm_minors_idr, minor->index);
|
|
|
|
spin_unlock_irqrestore(&drm_minor_lock, flags);
|
2014-07-23 08:34:52 +00:00
|
|
|
err_free:
|
|
|
|
kfree(minor);
|
|
|
|
return r;
|
2014-01-29 11:43:56 +00:00
|
|
|
}
|
|
|
|
|
2014-01-29 11:55:48 +00:00
|
|
|
static void drm_minor_free(struct drm_device *dev, unsigned int type)
|
|
|
|
{
|
2014-07-23 08:34:52 +00:00
|
|
|
struct drm_minor **slot, *minor;
|
|
|
|
unsigned long flags;
|
2014-01-29 11:55:48 +00:00
|
|
|
|
|
|
|
slot = drm_minor_get_slot(dev, type);
|
2014-07-23 08:34:52 +00:00
|
|
|
minor = *slot;
|
|
|
|
if (!minor)
|
|
|
|
return;
|
|
|
|
|
|
|
|
drm_mode_group_destroy(&minor->mode_group);
|
2014-07-23 09:38:38 +00:00
|
|
|
put_device(minor->kdev);
|
2014-07-23 08:34:52 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&drm_minor_lock, flags);
|
|
|
|
idr_remove(&drm_minors_idr, minor->index);
|
|
|
|
spin_unlock_irqrestore(&drm_minor_lock, flags);
|
|
|
|
|
|
|
|
kfree(minor);
|
|
|
|
*slot = NULL;
|
2014-01-29 11:55:48 +00:00
|
|
|
}
|
|
|
|
|
2014-01-29 11:57:05 +00:00
|
|
|
static int drm_minor_register(struct drm_device *dev, unsigned int type)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-07-23 08:34:52 +00:00
|
|
|
struct drm_minor *minor;
|
2014-02-24 14:53:25 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
DRM_DEBUG("\n");
|
|
|
|
|
2014-07-23 08:34:52 +00:00
|
|
|
minor = *drm_minor_get_slot(dev, type);
|
|
|
|
if (!minor)
|
2014-01-29 11:43:56 +00:00
|
|
|
return 0;
|
|
|
|
|
2014-07-23 08:34:52 +00:00
|
|
|
ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
|
2009-02-18 01:08:49 +00:00
|
|
|
if (ret) {
|
2009-06-02 06:01:37 +00:00
|
|
|
DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
|
2014-07-23 08:34:52 +00:00
|
|
|
return ret;
|
2009-02-18 01:08:49 +00:00
|
|
|
}
|
2008-04-21 06:47:32 +00:00
|
|
|
|
2014-07-23 09:38:38 +00:00
|
|
|
ret = device_add(minor->kdev);
|
|
|
|
if (ret)
|
2013-08-08 13:41:34 +00:00
|
|
|
goto err_debugfs;
|
2008-04-21 06:47:32 +00:00
|
|
|
|
2014-02-24 14:53:25 +00:00
|
|
|
/* replace NULL with @minor so lookups will succeed from now on */
|
|
|
|
spin_lock_irqsave(&drm_minor_lock, flags);
|
2014-07-23 08:34:52 +00:00
|
|
|
idr_replace(&drm_minors_idr, minor, minor->index);
|
2014-02-24 14:53:25 +00:00
|
|
|
spin_unlock_irqrestore(&drm_minor_lock, flags);
|
2008-04-21 06:47:32 +00:00
|
|
|
|
2014-07-23 08:34:52 +00:00
|
|
|
DRM_DEBUG("new minor registered %d\n", minor->index);
|
2008-04-21 06:47:32 +00:00
|
|
|
return 0;
|
|
|
|
|
2013-08-08 13:41:34 +00:00
|
|
|
err_debugfs:
|
2014-07-23 08:34:52 +00:00
|
|
|
drm_debugfs_cleanup(minor);
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2005-09-25 04:28:13 +00:00
|
|
|
|
2014-01-29 11:57:05 +00:00
|
|
|
static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
|
2013-10-20 16:55:40 +00:00
|
|
|
{
|
2014-01-29 11:57:05 +00:00
|
|
|
struct drm_minor *minor;
|
2014-02-24 14:53:25 +00:00
|
|
|
unsigned long flags;
|
2014-01-29 11:57:05 +00:00
|
|
|
|
|
|
|
minor = *drm_minor_get_slot(dev, type);
|
2014-07-23 09:38:38 +00:00
|
|
|
if (!minor || !device_is_registered(minor->kdev))
|
2013-10-20 16:55:40 +00:00
|
|
|
return;
|
|
|
|
|
2014-07-23 08:34:52 +00:00
|
|
|
/* replace @minor with NULL so lookups will fail from now on */
|
2014-02-24 14:53:25 +00:00
|
|
|
spin_lock_irqsave(&drm_minor_lock, flags);
|
2014-07-23 08:34:52 +00:00
|
|
|
idr_replace(&drm_minors_idr, NULL, minor->index);
|
2014-02-24 14:53:25 +00:00
|
|
|
spin_unlock_irqrestore(&drm_minor_lock, flags);
|
2013-10-20 16:55:43 +00:00
|
|
|
|
2014-07-23 09:38:38 +00:00
|
|
|
device_del(minor->kdev);
|
|
|
|
dev_set_drvdata(minor->kdev, NULL); /* safety belt */
|
2013-10-20 16:55:43 +00:00
|
|
|
drm_debugfs_cleanup(minor);
|
2013-10-20 16:55:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-01-29 09:49:19 +00:00
|
|
|
* drm_minor_acquire - Acquire a DRM minor
|
|
|
|
* @minor_id: Minor ID of the DRM-minor
|
|
|
|
*
|
|
|
|
* Looks up the given minor-ID and returns the respective DRM-minor object. The
|
|
|
|
* refence-count of the underlying device is increased so you must release this
|
|
|
|
* object with drm_minor_release().
|
|
|
|
*
|
|
|
|
* As long as you hold this minor, it is guaranteed that the object and the
|
|
|
|
* minor->dev pointer will stay valid! However, the device may get unplugged and
|
|
|
|
* unregistered while you hold the minor.
|
2013-10-20 16:55:40 +00:00
|
|
|
*
|
2014-01-29 09:49:19 +00:00
|
|
|
* Returns:
|
|
|
|
* Pointer to minor-object with increased device-refcount, or PTR_ERR on
|
|
|
|
* failure.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2014-01-29 09:49:19 +00:00
|
|
|
struct drm_minor *drm_minor_acquire(unsigned int minor_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2014-01-29 09:49:19 +00:00
|
|
|
struct drm_minor *minor;
|
2014-02-24 14:53:25 +00:00
|
|
|
unsigned long flags;
|
2014-01-29 09:49:19 +00:00
|
|
|
|
2014-02-24 14:53:25 +00:00
|
|
|
spin_lock_irqsave(&drm_minor_lock, flags);
|
2014-01-29 09:49:19 +00:00
|
|
|
minor = idr_find(&drm_minors_idr, minor_id);
|
2014-02-24 14:53:25 +00:00
|
|
|
if (minor)
|
|
|
|
drm_dev_ref(minor->dev);
|
|
|
|
spin_unlock_irqrestore(&drm_minor_lock, flags);
|
|
|
|
|
|
|
|
if (!minor) {
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
} else if (drm_device_is_unplugged(minor->dev)) {
|
|
|
|
drm_dev_unref(minor->dev);
|
2014-01-29 09:49:19 +00:00
|
|
|
return ERR_PTR(-ENODEV);
|
2014-02-24 14:53:25 +00:00
|
|
|
}
|
2008-07-30 19:06:12 +00:00
|
|
|
|
2014-01-29 09:49:19 +00:00
|
|
|
return minor;
|
|
|
|
}
|
2005-09-25 04:28:13 +00:00
|
|
|
|
2014-01-29 09:49:19 +00:00
|
|
|
/**
|
|
|
|
* drm_minor_release - Release DRM minor
|
|
|
|
* @minor: Pointer to DRM minor object
|
|
|
|
*
|
|
|
|
* Release a minor that was previously acquired via drm_minor_acquire().
|
|
|
|
*/
|
|
|
|
void drm_minor_release(struct drm_minor *minor)
|
|
|
|
{
|
|
|
|
drm_dev_unref(minor->dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-01-04 21:55:33 +00:00
|
|
|
|
|
|
|
/**
|
2014-05-19 11:39:07 +00:00
|
|
|
* drm_put_dev - Unregister and release a DRM device
|
|
|
|
* @dev: DRM device
|
2009-01-04 21:55:33 +00:00
|
|
|
*
|
2014-05-19 11:39:07 +00:00
|
|
|
* Called at module unload time or when a PCI device is unplugged.
|
2009-01-04 21:55:33 +00:00
|
|
|
*
|
2014-05-19 11:39:07 +00:00
|
|
|
* Use of this function is discouraged. It will eventually go away completely.
|
|
|
|
* Please use drm_dev_unregister() and drm_dev_unref() explicitly instead.
|
|
|
|
*
|
|
|
|
* Cleans up all DRM device, calling drm_lastclose().
|
2009-01-04 21:55:33 +00:00
|
|
|
*/
|
|
|
|
void drm_put_dev(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
DRM_DEBUG("\n");
|
|
|
|
|
|
|
|
if (!dev) {
|
|
|
|
DRM_ERROR("cleanup called no dev\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-02 09:23:38 +00:00
|
|
|
drm_dev_unregister(dev);
|
drm: provide device-refcount
Lets not trick ourselves into thinking "drm_device" objects are not
ref-counted. That's just utterly stupid. We manage "drm_minor" objects on
each drm-device and each minor can have an unlimited number of open
handles. Each of these handles has the drm_minor (and thus the drm_device)
as private-data in the file-handle. Therefore, we may not destroy
"drm_device" until all these handles are closed.
It is *not* possible to reset all these pointers atomically and restrict
access to them, and this is *not* how this is done! Instead, we use
ref-counts to make sure the object is valid and not freed.
Note that we currently use "dev->open_count" for that, which is *exactly*
the same as a reference-count, just open coded. So this patch doesn't
change any semantics on DRM devices (well, this patch just introduces the
ref-count, anyway. Follow-up patches will replace open_count by it).
Also note that generic VFS revoke support could allow us to drop this
ref-count again. We could then just synchronously disable any fops->xy()
calls. However, this is not the case, yet, and no such patches are
in sight (and I seriously question the idea of dropping the ref-cnt
again).
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
2014-01-29 09:21:36 +00:00
|
|
|
drm_dev_unref(dev);
|
2009-01-04 21:55:33 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_put_dev);
|
2012-02-20 14:18:07 +00:00
|
|
|
|
|
|
|
void drm_unplug_dev(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
/* for a USB device */
|
2014-01-29 11:57:05 +00:00
|
|
|
drm_minor_unregister(dev, DRM_MINOR_LEGACY);
|
|
|
|
drm_minor_unregister(dev, DRM_MINOR_RENDER);
|
|
|
|
drm_minor_unregister(dev, DRM_MINOR_CONTROL);
|
2012-02-20 14:18:07 +00:00
|
|
|
|
|
|
|
mutex_lock(&drm_global_mutex);
|
|
|
|
|
|
|
|
drm_device_set_unplugged(dev);
|
|
|
|
|
|
|
|
if (dev->open_count == 0) {
|
|
|
|
drm_put_dev(dev);
|
|
|
|
}
|
|
|
|
mutex_unlock(&drm_global_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_unplug_dev);
|
2013-10-02 09:23:34 +00:00
|
|
|
|
2014-01-03 13:09:47 +00:00
|
|
|
/*
|
|
|
|
* DRM internal mount
|
|
|
|
* We want to be able to allocate our own "struct address_space" to control
|
|
|
|
* memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow
|
|
|
|
* stand-alone address_space objects, so we need an underlying inode. As there
|
|
|
|
* is no way to allocate an independent inode easily, we need a fake internal
|
|
|
|
* VFS mount-point.
|
|
|
|
*
|
|
|
|
* The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free()
|
|
|
|
* frees it again. You are allowed to use iget() and iput() to get references to
|
|
|
|
* the inode. But each drm_fs_inode_new() call must be paired with exactly one
|
|
|
|
* drm_fs_inode_free() call (which does not have to be the last iput()).
|
|
|
|
* We use drm_fs_inode_*() to manage our internal VFS mount-point and share it
|
|
|
|
* between multiple inode-users. You could, technically, call
|
|
|
|
* iget() + drm_fs_inode_free() directly after alloc and sometime later do an
|
|
|
|
* iput(), but this way you'd end up with a new vfsmount for each inode.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int drm_fs_cnt;
|
|
|
|
static struct vfsmount *drm_fs_mnt;
|
|
|
|
|
|
|
|
static const struct dentry_operations drm_fs_dops = {
|
|
|
|
.d_dname = simple_dname,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct super_operations drm_fs_sops = {
|
|
|
|
.statfs = simple_statfs,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct dentry *drm_fs_mount(struct file_system_type *fs_type, int flags,
|
|
|
|
const char *dev_name, void *data)
|
|
|
|
{
|
|
|
|
return mount_pseudo(fs_type,
|
|
|
|
"drm:",
|
|
|
|
&drm_fs_sops,
|
|
|
|
&drm_fs_dops,
|
|
|
|
0x010203ff);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_system_type drm_fs_type = {
|
|
|
|
.name = "drm",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.mount = drm_fs_mount,
|
|
|
|
.kill_sb = kill_anon_super,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct inode *drm_fs_inode_new(void)
|
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt);
|
|
|
|
if (r < 0) {
|
|
|
|
DRM_ERROR("Cannot mount pseudo fs: %d\n", r);
|
|
|
|
return ERR_PTR(r);
|
|
|
|
}
|
|
|
|
|
|
|
|
inode = alloc_anon_inode(drm_fs_mnt->mnt_sb);
|
|
|
|
if (IS_ERR(inode))
|
|
|
|
simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
|
|
|
|
|
|
|
|
return inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void drm_fs_inode_free(struct inode *inode)
|
|
|
|
{
|
|
|
|
if (inode) {
|
|
|
|
iput(inode);
|
|
|
|
simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-02 09:23:34 +00:00
|
|
|
/**
|
2014-05-19 11:39:07 +00:00
|
|
|
* drm_dev_alloc - Allocate new DRM device
|
2013-10-02 09:23:34 +00:00
|
|
|
* @driver: DRM driver to allocate device for
|
|
|
|
* @parent: Parent device object
|
|
|
|
*
|
|
|
|
* Allocate and initialize a new DRM device. No device registration is done.
|
2013-10-02 09:23:35 +00:00
|
|
|
* Call drm_dev_register() to advertice the device to user space and register it
|
|
|
|
* with other core subsystems.
|
2013-10-02 09:23:34 +00:00
|
|
|
*
|
drm: provide device-refcount
Lets not trick ourselves into thinking "drm_device" objects are not
ref-counted. That's just utterly stupid. We manage "drm_minor" objects on
each drm-device and each minor can have an unlimited number of open
handles. Each of these handles has the drm_minor (and thus the drm_device)
as private-data in the file-handle. Therefore, we may not destroy
"drm_device" until all these handles are closed.
It is *not* possible to reset all these pointers atomically and restrict
access to them, and this is *not* how this is done! Instead, we use
ref-counts to make sure the object is valid and not freed.
Note that we currently use "dev->open_count" for that, which is *exactly*
the same as a reference-count, just open coded. So this patch doesn't
change any semantics on DRM devices (well, this patch just introduces the
ref-count, anyway. Follow-up patches will replace open_count by it).
Also note that generic VFS revoke support could allow us to drop this
ref-count again. We could then just synchronously disable any fops->xy()
calls. However, this is not the case, yet, and no such patches are
in sight (and I seriously question the idea of dropping the ref-cnt
again).
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
2014-01-29 09:21:36 +00:00
|
|
|
* The initial ref-count of the object is 1. Use drm_dev_ref() and
|
|
|
|
* drm_dev_unref() to take and drop further ref-counts.
|
|
|
|
*
|
2013-10-02 09:23:34 +00:00
|
|
|
* RETURNS:
|
|
|
|
* Pointer to new DRM device, or NULL if out of memory.
|
|
|
|
*/
|
|
|
|
struct drm_device *drm_dev_alloc(struct drm_driver *driver,
|
|
|
|
struct device *parent)
|
|
|
|
{
|
|
|
|
struct drm_device *dev;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
|
drm: provide device-refcount
Lets not trick ourselves into thinking "drm_device" objects are not
ref-counted. That's just utterly stupid. We manage "drm_minor" objects on
each drm-device and each minor can have an unlimited number of open
handles. Each of these handles has the drm_minor (and thus the drm_device)
as private-data in the file-handle. Therefore, we may not destroy
"drm_device" until all these handles are closed.
It is *not* possible to reset all these pointers atomically and restrict
access to them, and this is *not* how this is done! Instead, we use
ref-counts to make sure the object is valid and not freed.
Note that we currently use "dev->open_count" for that, which is *exactly*
the same as a reference-count, just open coded. So this patch doesn't
change any semantics on DRM devices (well, this patch just introduces the
ref-count, anyway. Follow-up patches will replace open_count by it).
Also note that generic VFS revoke support could allow us to drop this
ref-count again. We could then just synchronously disable any fops->xy()
calls. However, this is not the case, yet, and no such patches are
in sight (and I seriously question the idea of dropping the ref-cnt
again).
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
2014-01-29 09:21:36 +00:00
|
|
|
kref_init(&dev->ref);
|
2013-10-02 09:23:34 +00:00
|
|
|
dev->dev = parent;
|
|
|
|
dev->driver = driver;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&dev->filelist);
|
|
|
|
INIT_LIST_HEAD(&dev->ctxlist);
|
|
|
|
INIT_LIST_HEAD(&dev->vmalist);
|
|
|
|
INIT_LIST_HEAD(&dev->maplist);
|
|
|
|
INIT_LIST_HEAD(&dev->vblank_event_list);
|
|
|
|
|
2013-12-16 10:21:06 +00:00
|
|
|
spin_lock_init(&dev->buf_lock);
|
2013-10-02 09:23:34 +00:00
|
|
|
spin_lock_init(&dev->event_lock);
|
|
|
|
mutex_init(&dev->struct_mutex);
|
|
|
|
mutex_init(&dev->ctxlist_mutex);
|
2014-02-25 18:57:44 +00:00
|
|
|
mutex_init(&dev->master_mutex);
|
2013-10-02 09:23:34 +00:00
|
|
|
|
2014-01-03 13:24:19 +00:00
|
|
|
dev->anon_inode = drm_fs_inode_new();
|
|
|
|
if (IS_ERR(dev->anon_inode)) {
|
|
|
|
ret = PTR_ERR(dev->anon_inode);
|
|
|
|
DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret);
|
2013-10-02 09:23:34 +00:00
|
|
|
goto err_free;
|
2014-01-03 13:24:19 +00:00
|
|
|
}
|
|
|
|
|
2014-01-29 11:43:56 +00:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_MODESET)) {
|
|
|
|
ret = drm_minor_alloc(dev, DRM_MINOR_CONTROL);
|
|
|
|
if (ret)
|
|
|
|
goto err_minors;
|
|
|
|
}
|
|
|
|
|
2014-03-16 13:38:40 +00:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_RENDER)) {
|
2014-01-29 11:43:56 +00:00
|
|
|
ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
|
|
|
|
if (ret)
|
|
|
|
goto err_minors;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = drm_minor_alloc(dev, DRM_MINOR_LEGACY);
|
|
|
|
if (ret)
|
|
|
|
goto err_minors;
|
|
|
|
|
2014-01-03 13:24:19 +00:00
|
|
|
if (drm_ht_create(&dev->map_hash, 12))
|
2014-01-29 11:43:56 +00:00
|
|
|
goto err_minors;
|
2013-10-02 09:23:34 +00:00
|
|
|
|
2014-07-24 10:10:04 +00:00
|
|
|
ret = drm_legacy_ctxbitmap_init(dev);
|
2013-10-02 09:23:34 +00:00
|
|
|
if (ret) {
|
|
|
|
DRM_ERROR("Cannot allocate memory for context bitmap.\n");
|
|
|
|
goto err_ht;
|
|
|
|
}
|
|
|
|
|
2014-09-30 14:49:56 +00:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_GEM)) {
|
2013-10-02 09:23:34 +00:00
|
|
|
ret = drm_gem_init(dev);
|
|
|
|
if (ret) {
|
|
|
|
DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
|
|
|
|
goto err_ctxbitmap;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return dev;
|
|
|
|
|
|
|
|
err_ctxbitmap:
|
2014-07-24 10:10:04 +00:00
|
|
|
drm_legacy_ctxbitmap_cleanup(dev);
|
2013-10-02 09:23:34 +00:00
|
|
|
err_ht:
|
|
|
|
drm_ht_remove(&dev->map_hash);
|
2014-01-29 11:43:56 +00:00
|
|
|
err_minors:
|
2014-01-29 11:55:48 +00:00
|
|
|
drm_minor_free(dev, DRM_MINOR_LEGACY);
|
|
|
|
drm_minor_free(dev, DRM_MINOR_RENDER);
|
|
|
|
drm_minor_free(dev, DRM_MINOR_CONTROL);
|
2014-01-03 13:24:19 +00:00
|
|
|
drm_fs_inode_free(dev->anon_inode);
|
2013-10-02 09:23:34 +00:00
|
|
|
err_free:
|
2014-02-25 18:57:44 +00:00
|
|
|
mutex_destroy(&dev->master_mutex);
|
2013-10-02 09:23:34 +00:00
|
|
|
kfree(dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_alloc);
|
2013-10-02 09:23:35 +00:00
|
|
|
|
drm: provide device-refcount
Lets not trick ourselves into thinking "drm_device" objects are not
ref-counted. That's just utterly stupid. We manage "drm_minor" objects on
each drm-device and each minor can have an unlimited number of open
handles. Each of these handles has the drm_minor (and thus the drm_device)
as private-data in the file-handle. Therefore, we may not destroy
"drm_device" until all these handles are closed.
It is *not* possible to reset all these pointers atomically and restrict
access to them, and this is *not* how this is done! Instead, we use
ref-counts to make sure the object is valid and not freed.
Note that we currently use "dev->open_count" for that, which is *exactly*
the same as a reference-count, just open coded. So this patch doesn't
change any semantics on DRM devices (well, this patch just introduces the
ref-count, anyway. Follow-up patches will replace open_count by it).
Also note that generic VFS revoke support could allow us to drop this
ref-count again. We could then just synchronously disable any fops->xy()
calls. However, this is not the case, yet, and no such patches are
in sight (and I seriously question the idea of dropping the ref-cnt
again).
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
2014-01-29 09:21:36 +00:00
|
|
|
static void drm_dev_release(struct kref *ref)
|
2013-10-02 09:23:37 +00:00
|
|
|
{
|
drm: provide device-refcount
Lets not trick ourselves into thinking "drm_device" objects are not
ref-counted. That's just utterly stupid. We manage "drm_minor" objects on
each drm-device and each minor can have an unlimited number of open
handles. Each of these handles has the drm_minor (and thus the drm_device)
as private-data in the file-handle. Therefore, we may not destroy
"drm_device" until all these handles are closed.
It is *not* possible to reset all these pointers atomically and restrict
access to them, and this is *not* how this is done! Instead, we use
ref-counts to make sure the object is valid and not freed.
Note that we currently use "dev->open_count" for that, which is *exactly*
the same as a reference-count, just open coded. So this patch doesn't
change any semantics on DRM devices (well, this patch just introduces the
ref-count, anyway. Follow-up patches will replace open_count by it).
Also note that generic VFS revoke support could allow us to drop this
ref-count again. We could then just synchronously disable any fops->xy()
calls. However, this is not the case, yet, and no such patches are
in sight (and I seriously question the idea of dropping the ref-cnt
again).
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
2014-01-29 09:21:36 +00:00
|
|
|
struct drm_device *dev = container_of(ref, struct drm_device, ref);
|
2013-10-20 16:55:45 +00:00
|
|
|
|
2014-09-30 14:49:56 +00:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_GEM))
|
2013-10-02 09:23:37 +00:00
|
|
|
drm_gem_destroy(dev);
|
|
|
|
|
2014-07-24 10:10:04 +00:00
|
|
|
drm_legacy_ctxbitmap_cleanup(dev);
|
2013-10-02 09:23:37 +00:00
|
|
|
drm_ht_remove(&dev->map_hash);
|
2014-01-03 13:24:19 +00:00
|
|
|
drm_fs_inode_free(dev->anon_inode);
|
2013-10-02 09:23:37 +00:00
|
|
|
|
2014-01-29 11:55:48 +00:00
|
|
|
drm_minor_free(dev, DRM_MINOR_LEGACY);
|
|
|
|
drm_minor_free(dev, DRM_MINOR_RENDER);
|
|
|
|
drm_minor_free(dev, DRM_MINOR_CONTROL);
|
|
|
|
|
2014-02-25 18:57:44 +00:00
|
|
|
mutex_destroy(&dev->master_mutex);
|
2014-04-11 13:23:00 +00:00
|
|
|
kfree(dev->unique);
|
2013-10-02 09:23:37 +00:00
|
|
|
kfree(dev);
|
|
|
|
}
|
drm: provide device-refcount
Lets not trick ourselves into thinking "drm_device" objects are not
ref-counted. That's just utterly stupid. We manage "drm_minor" objects on
each drm-device and each minor can have an unlimited number of open
handles. Each of these handles has the drm_minor (and thus the drm_device)
as private-data in the file-handle. Therefore, we may not destroy
"drm_device" until all these handles are closed.
It is *not* possible to reset all these pointers atomically and restrict
access to them, and this is *not* how this is done! Instead, we use
ref-counts to make sure the object is valid and not freed.
Note that we currently use "dev->open_count" for that, which is *exactly*
the same as a reference-count, just open coded. So this patch doesn't
change any semantics on DRM devices (well, this patch just introduces the
ref-count, anyway. Follow-up patches will replace open_count by it).
Also note that generic VFS revoke support could allow us to drop this
ref-count again. We could then just synchronously disable any fops->xy()
calls. However, this is not the case, yet, and no such patches are
in sight (and I seriously question the idea of dropping the ref-cnt
again).
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
2014-01-29 09:21:36 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_dev_ref - Take reference of a DRM device
|
|
|
|
* @dev: device to take reference of or NULL
|
|
|
|
*
|
|
|
|
* This increases the ref-count of @dev by one. You *must* already own a
|
|
|
|
* reference when calling this. Use drm_dev_unref() to drop this reference
|
|
|
|
* again.
|
|
|
|
*
|
|
|
|
* This function never fails. However, this function does not provide *any*
|
|
|
|
* guarantee whether the device is alive or running. It only provides a
|
|
|
|
* reference to the object and the memory associated with it.
|
|
|
|
*/
|
|
|
|
void drm_dev_ref(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
if (dev)
|
|
|
|
kref_get(&dev->ref);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_ref);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_dev_unref - Drop reference of a DRM device
|
|
|
|
* @dev: device to drop reference of or NULL
|
|
|
|
*
|
|
|
|
* This decreases the ref-count of @dev by one. The device is destroyed if the
|
|
|
|
* ref-count drops to zero.
|
|
|
|
*/
|
|
|
|
void drm_dev_unref(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
if (dev)
|
|
|
|
kref_put(&dev->ref, drm_dev_release);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_unref);
|
2013-10-02 09:23:37 +00:00
|
|
|
|
2013-10-02 09:23:35 +00:00
|
|
|
/**
|
|
|
|
* drm_dev_register - Register DRM device
|
|
|
|
* @dev: Device to register
|
2014-05-19 11:39:07 +00:00
|
|
|
* @flags: Flags passed to the driver's .load() function
|
2013-10-02 09:23:35 +00:00
|
|
|
*
|
|
|
|
* Register the DRM device @dev with the system, advertise device to user-space
|
|
|
|
* and start normal device operation. @dev must be allocated via drm_dev_alloc()
|
|
|
|
* previously.
|
|
|
|
*
|
|
|
|
* Never call this twice on any device!
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* 0 on success, negative error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_dev_register(struct drm_device *dev, unsigned long flags)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&drm_global_mutex);
|
|
|
|
|
2014-01-29 11:57:05 +00:00
|
|
|
ret = drm_minor_register(dev, DRM_MINOR_CONTROL);
|
2014-01-29 11:43:56 +00:00
|
|
|
if (ret)
|
|
|
|
goto err_minors;
|
2013-10-02 09:23:35 +00:00
|
|
|
|
2014-01-29 11:57:05 +00:00
|
|
|
ret = drm_minor_register(dev, DRM_MINOR_RENDER);
|
2014-01-29 11:43:56 +00:00
|
|
|
if (ret)
|
|
|
|
goto err_minors;
|
2013-10-02 09:23:35 +00:00
|
|
|
|
2014-01-29 11:57:05 +00:00
|
|
|
ret = drm_minor_register(dev, DRM_MINOR_LEGACY);
|
2013-10-02 09:23:35 +00:00
|
|
|
if (ret)
|
2014-01-29 11:43:56 +00:00
|
|
|
goto err_minors;
|
2013-10-02 09:23:35 +00:00
|
|
|
|
|
|
|
if (dev->driver->load) {
|
|
|
|
ret = dev->driver->load(dev, flags);
|
|
|
|
if (ret)
|
2014-01-29 11:43:56 +00:00
|
|
|
goto err_minors;
|
2013-10-02 09:23:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* setup grouping for legacy outputs */
|
|
|
|
if (drm_core_check_feature(dev, DRIVER_MODESET)) {
|
|
|
|
ret = drm_mode_group_init_legacy_group(dev,
|
|
|
|
&dev->primary->mode_group);
|
|
|
|
if (ret)
|
|
|
|
goto err_unload;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
err_unload:
|
|
|
|
if (dev->driver->unload)
|
|
|
|
dev->driver->unload(dev);
|
2014-01-29 11:43:56 +00:00
|
|
|
err_minors:
|
2014-01-29 11:57:05 +00:00
|
|
|
drm_minor_unregister(dev, DRM_MINOR_LEGACY);
|
|
|
|
drm_minor_unregister(dev, DRM_MINOR_RENDER);
|
|
|
|
drm_minor_unregister(dev, DRM_MINOR_CONTROL);
|
2013-10-02 09:23:35 +00:00
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&drm_global_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_register);
|
2013-10-02 09:23:38 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_dev_unregister - Unregister DRM device
|
|
|
|
* @dev: Device to unregister
|
|
|
|
*
|
|
|
|
* Unregister the DRM device from the system. This does the reverse of
|
|
|
|
* drm_dev_register() but does not deallocate the device. The caller must call
|
drm: provide device-refcount
Lets not trick ourselves into thinking "drm_device" objects are not
ref-counted. That's just utterly stupid. We manage "drm_minor" objects on
each drm-device and each minor can have an unlimited number of open
handles. Each of these handles has the drm_minor (and thus the drm_device)
as private-data in the file-handle. Therefore, we may not destroy
"drm_device" until all these handles are closed.
It is *not* possible to reset all these pointers atomically and restrict
access to them, and this is *not* how this is done! Instead, we use
ref-counts to make sure the object is valid and not freed.
Note that we currently use "dev->open_count" for that, which is *exactly*
the same as a reference-count, just open coded. So this patch doesn't
change any semantics on DRM devices (well, this patch just introduces the
ref-count, anyway. Follow-up patches will replace open_count by it).
Also note that generic VFS revoke support could allow us to drop this
ref-count again. We could then just synchronously disable any fops->xy()
calls. However, this is not the case, yet, and no such patches are
in sight (and I seriously question the idea of dropping the ref-cnt
again).
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
2014-01-29 09:21:36 +00:00
|
|
|
* drm_dev_unref() to drop their final reference.
|
2013-10-02 09:23:38 +00:00
|
|
|
*/
|
|
|
|
void drm_dev_unregister(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_map_list *r_list, *list_temp;
|
|
|
|
|
|
|
|
drm_lastclose(dev);
|
|
|
|
|
|
|
|
if (dev->driver->unload)
|
|
|
|
dev->driver->unload(dev);
|
|
|
|
|
2013-12-11 10:34:38 +00:00
|
|
|
if (dev->agp)
|
|
|
|
drm_pci_agp_destroy(dev);
|
2013-10-02 09:23:38 +00:00
|
|
|
|
|
|
|
drm_vblank_cleanup(dev);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
|
2014-08-29 10:12:28 +00:00
|
|
|
drm_legacy_rmmap(dev, r_list->map);
|
2013-10-02 09:23:38 +00:00
|
|
|
|
2014-01-29 11:57:05 +00:00
|
|
|
drm_minor_unregister(dev, DRM_MINOR_LEGACY);
|
|
|
|
drm_minor_unregister(dev, DRM_MINOR_RENDER);
|
|
|
|
drm_minor_unregister(dev, DRM_MINOR_CONTROL);
|
2013-10-02 09:23:38 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_unregister);
|
2014-04-11 13:23:00 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_dev_set_unique - Set the unique name of a DRM device
|
|
|
|
* @dev: device of which to set the unique name
|
|
|
|
* @fmt: format string for unique name
|
|
|
|
*
|
|
|
|
* Sets the unique name of a DRM device using the specified format string and
|
|
|
|
* a variable list of arguments. Drivers can use this at driver probe time if
|
|
|
|
* the unique name of the devices they drive is static.
|
|
|
|
*
|
|
|
|
* Return: 0 on success or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_dev_set_unique(struct drm_device *dev, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
kfree(dev->unique);
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
dev->unique = kvasprintf(GFP_KERNEL, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
return dev->unique ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_set_unique);
|
2014-07-23 10:29:56 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* DRM Core
|
|
|
|
* The DRM core module initializes all global DRM objects and makes them
|
|
|
|
* available to drivers. Once setup, drivers can probe their respective
|
|
|
|
* devices.
|
|
|
|
* Currently, core management includes:
|
|
|
|
* - The "DRM-Global" key/value database
|
|
|
|
* - Global ID management for connectors
|
|
|
|
* - DRM major number allocation
|
|
|
|
* - DRM minor management
|
|
|
|
* - DRM sysfs class
|
|
|
|
* - DRM debugfs root
|
|
|
|
*
|
|
|
|
* Furthermore, the DRM core provides dynamic char-dev lookups. For each
|
|
|
|
* interface registered on a DRM device, you can request minor numbers from DRM
|
|
|
|
* core. DRM core takes care of major-number management and char-dev
|
|
|
|
* registration. A stub ->open() callback forwards any open() requests to the
|
|
|
|
* registered minor.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int drm_stub_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
const struct file_operations *new_fops;
|
|
|
|
struct drm_minor *minor;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
DRM_DEBUG("\n");
|
|
|
|
|
|
|
|
mutex_lock(&drm_global_mutex);
|
|
|
|
minor = drm_minor_acquire(iminor(inode));
|
|
|
|
if (IS_ERR(minor)) {
|
|
|
|
err = PTR_ERR(minor);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_fops = fops_get(minor->dev->driver->fops);
|
|
|
|
if (!new_fops) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto out_release;
|
|
|
|
}
|
|
|
|
|
|
|
|
replace_fops(filp, new_fops);
|
|
|
|
if (filp->f_op->open)
|
|
|
|
err = filp->f_op->open(inode, filp);
|
|
|
|
else
|
|
|
|
err = 0;
|
|
|
|
|
|
|
|
out_release:
|
|
|
|
drm_minor_release(minor);
|
|
|
|
out_unlock:
|
|
|
|
mutex_unlock(&drm_global_mutex);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations drm_stub_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = drm_stub_open,
|
|
|
|
.llseek = noop_llseek,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init drm_core_init(void)
|
|
|
|
{
|
|
|
|
int ret = -ENOMEM;
|
|
|
|
|
|
|
|
drm_global_init();
|
|
|
|
drm_connector_ida_init();
|
|
|
|
idr_init(&drm_minors_idr);
|
|
|
|
|
|
|
|
if (register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops))
|
|
|
|
goto err_p1;
|
|
|
|
|
|
|
|
drm_class = drm_sysfs_create(THIS_MODULE, "drm");
|
|
|
|
if (IS_ERR(drm_class)) {
|
|
|
|
printk(KERN_ERR "DRM: Error creating drm class.\n");
|
|
|
|
ret = PTR_ERR(drm_class);
|
|
|
|
goto err_p2;
|
|
|
|
}
|
|
|
|
|
|
|
|
drm_debugfs_root = debugfs_create_dir("dri", NULL);
|
|
|
|
if (!drm_debugfs_root) {
|
|
|
|
DRM_ERROR("Cannot create /sys/kernel/debug/dri\n");
|
|
|
|
ret = -1;
|
|
|
|
goto err_p3;
|
|
|
|
}
|
|
|
|
|
|
|
|
DRM_INFO("Initialized %s %d.%d.%d %s\n",
|
|
|
|
CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
|
|
|
|
return 0;
|
|
|
|
err_p3:
|
|
|
|
drm_sysfs_destroy();
|
|
|
|
err_p2:
|
|
|
|
unregister_chrdev(DRM_MAJOR, "drm");
|
|
|
|
|
|
|
|
idr_destroy(&drm_minors_idr);
|
|
|
|
err_p1:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit drm_core_exit(void)
|
|
|
|
{
|
|
|
|
debugfs_remove(drm_debugfs_root);
|
|
|
|
drm_sysfs_destroy();
|
|
|
|
|
|
|
|
unregister_chrdev(DRM_MAJOR, "drm");
|
|
|
|
|
|
|
|
drm_connector_ida_destroy();
|
|
|
|
idr_destroy(&drm_minors_idr);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(drm_core_init);
|
|
|
|
module_exit(drm_core_exit);
|