2005-04-16 16:20:36 -06: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 05:39:07 -06:00
|
|
|
* Author Rickard E. (Rik) Faith <faith@valinux.com>
|
|
|
|
*
|
2005-04-16 16:20:36 -06: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 04:29:56 -06:00
|
|
|
#include <linux/debugfs.h>
|
2014-01-03 06:09:47 -07:00
|
|
|
#include <linux/fs.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
2014-01-03 06:09:47 -07:00
|
|
|
#include <linux/mount.h>
|
2019-03-25 10:38:24 -06:00
|
|
|
#include <linux/pseudo_fs.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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2018-03-28 01:38:35 -06:00
|
|
|
#include <linux/srcu.h>
|
2016-11-14 04:58:19 -07:00
|
|
|
|
2018-07-03 10:03:47 -06:00
|
|
|
#include <drm/drm_client.h>
|
2019-05-26 11:35:35 -06:00
|
|
|
#include <drm/drm_color_mgmt.h>
|
2016-11-14 04:58:19 -07:00
|
|
|
#include <drm/drm_drv.h>
|
2019-05-26 11:35:35 -06:00
|
|
|
#include <drm/drm_file.h>
|
2020-03-23 08:49:03 -06:00
|
|
|
#include <drm/drm_managed.h>
|
2019-05-26 11:35:35 -06:00
|
|
|
#include <drm/drm_mode_object.h>
|
|
|
|
#include <drm/drm_print.h>
|
2016-11-14 04:58:19 -07:00
|
|
|
|
2016-06-21 08:37:09 -06:00
|
|
|
#include "drm_crtc_internal.h"
|
2014-09-10 04:43:53 -06:00
|
|
|
#include "drm_internal.h"
|
2019-05-26 11:35:35 -06:00
|
|
|
#include "drm_legacy.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
drm: drop obsolete drm_core.h
The drm_core.h header contains a set of constants meant to be used
throughout DRM. However, as it turns out, they're each used just once and
don't bring any benefit. They're also grossly mis-named and lack
name-spacing. This patch inlines them, or moves them into drm_internal.h
as appropriate:
- CORE_AUTHOR and CORE_DESC are inlined into corresponding MODULE_*()
macros. It's just confusing having to follow 2 pointers when trying to
find the definition of these fields. Grep'ping for MODULE_AUTHOR()
should reveal the full information, if there's no strong reason not to.
- CORE_NAME, CORE_DATE, CORE_MAJOR, CORE_MINOR, and CORE_PATCHLEVEL are
inlined into the sysfs 'version' attribute. They're stripped
everywhere else (which is just some printk() statements). CORE_NAME
just doesn't make *any* sense, as we hard-code it in many places,
anyway. The other constants are outdated and just serve
binary-compatibility purposes. Hence, inline them in 'version' sysfs
attribute (we might even try dropping it..).
- DRM_IF_MAJOR and DRM_IF_MINOR are moved into drm_internal.h as they're
only used by the global ioctl handlers. Furthermore, versioning
interfaces breaks backports and as such is deprecated, anyway. We just
keep them for historic reasons. I doubt anyone will ever modify them
again.
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/20160901124837.680-6-dh.herrmann@gmail.com
2016-09-01 06:48:36 -06:00
|
|
|
MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl");
|
|
|
|
MODULE_DESCRIPTION("DRM shared core routines");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_LICENSE("GPL and additional rights");
|
|
|
|
|
2014-02-24 07:53:25 -07:00
|
|
|
static DEFINE_SPINLOCK(drm_minor_lock);
|
2014-07-23 04:29:56 -06:00
|
|
|
static struct idr drm_minors_idr;
|
2008-04-21 00:47:32 -06:00
|
|
|
|
2017-07-08 15:43:52 -06:00
|
|
|
/*
|
|
|
|
* If the drm core fails to init for whatever reason,
|
|
|
|
* we should prevent any drivers from registering with it.
|
|
|
|
* It's best to check this at drm_dev_init(), as some drivers
|
|
|
|
* prefer to embed struct drm_device into their own device
|
|
|
|
* structure and call drm_dev_init() themselves.
|
|
|
|
*/
|
|
|
|
static bool drm_core_init_complete = false;
|
|
|
|
|
2014-07-23 04:29:56 -06:00
|
|
|
static struct dentry *drm_debugfs_root;
|
2011-04-17 21:35:51 -06:00
|
|
|
|
2018-03-28 01:38:35 -06:00
|
|
|
DEFINE_STATIC_SRCU(drm_unplug_srcu);
|
|
|
|
|
2014-02-24 07:53:25 -07: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 16:20:36 -06:00
|
|
|
*
|
2014-02-24 07:53:25 -07: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 16:20:36 -06:00
|
|
|
*/
|
2014-02-24 07:53:25 -07:00
|
|
|
|
2014-01-29 04:43:56 -07:00
|
|
|
static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
|
|
|
|
unsigned int type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
2016-08-03 12:04:25 -06:00
|
|
|
case DRM_MINOR_PRIMARY:
|
2014-01-29 04:43:56 -07:00
|
|
|
return &dev->primary;
|
|
|
|
case DRM_MINOR_RENDER:
|
|
|
|
return &dev->render;
|
|
|
|
default:
|
2018-02-20 12:11:57 -07:00
|
|
|
BUG();
|
2014-01-29 04:43:56 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-24 14:39:36 -06:00
|
|
|
static void drm_minor_alloc_release(struct drm_device *dev, void *data)
|
|
|
|
{
|
|
|
|
struct drm_minor *minor = data;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2020-03-23 08:49:25 -06:00
|
|
|
WARN_ON(dev != minor->dev);
|
|
|
|
|
2020-03-24 14:39:36 -06:00
|
|
|
put_device(minor->kdev);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&drm_minor_lock, flags);
|
|
|
|
idr_remove(&drm_minors_idr, minor->index);
|
|
|
|
spin_unlock_irqrestore(&drm_minor_lock, flags);
|
|
|
|
}
|
|
|
|
|
2014-01-29 04:43:56 -07:00
|
|
|
static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
|
|
|
|
{
|
|
|
|
struct drm_minor *minor;
|
2014-07-23 02:34:52 -06:00
|
|
|
unsigned long flags;
|
|
|
|
int r;
|
2014-01-29 04:43:56 -07:00
|
|
|
|
2020-03-24 14:39:36 -06:00
|
|
|
minor = drmm_kzalloc(dev, sizeof(*minor), GFP_KERNEL);
|
2014-01-29 04:43:56 -07:00
|
|
|
if (!minor)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
minor->type = type;
|
|
|
|
minor->dev = dev;
|
|
|
|
|
2014-07-23 02:34:52 -06: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)
|
2020-03-24 14:39:36 -06:00
|
|
|
return r;
|
2014-07-23 02:34:52 -06:00
|
|
|
|
|
|
|
minor->index = r;
|
|
|
|
|
2020-03-24 14:39:36 -06:00
|
|
|
r = drmm_add_action_or_reset(dev, drm_minor_alloc_release, minor);
|
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
2014-07-23 03:38:38 -06:00
|
|
|
minor->kdev = drm_sysfs_minor_alloc(minor);
|
2020-03-24 14:39:36 -06:00
|
|
|
if (IS_ERR(minor->kdev))
|
|
|
|
return PTR_ERR(minor->kdev);
|
2014-07-23 03:38:38 -06:00
|
|
|
|
2014-01-29 04:43:56 -07:00
|
|
|
*drm_minor_get_slot(dev, type) = minor;
|
|
|
|
return 0;
|
2014-01-29 04:55:48 -07:00
|
|
|
}
|
|
|
|
|
2014-01-29 04:57:05 -07:00
|
|
|
static int drm_minor_register(struct drm_device *dev, unsigned int type)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-07-23 02:34:52 -06:00
|
|
|
struct drm_minor *minor;
|
2014-02-24 07:53:25 -07:00
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
DRM_DEBUG("\n");
|
|
|
|
|
2014-07-23 02:34:52 -06:00
|
|
|
minor = *drm_minor_get_slot(dev, type);
|
|
|
|
if (!minor)
|
2014-01-29 04:43:56 -07:00
|
|
|
return 0;
|
|
|
|
|
2014-07-23 02:34:52 -06:00
|
|
|
ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
|
2009-02-17 18:08:49 -07:00
|
|
|
if (ret) {
|
2009-06-02 00:01:37 -06:00
|
|
|
DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
|
2017-01-26 15:56:04 -07:00
|
|
|
goto err_debugfs;
|
2009-02-17 18:08:49 -07:00
|
|
|
}
|
2008-04-21 00:47:32 -06:00
|
|
|
|
2014-07-23 03:38:38 -06:00
|
|
|
ret = device_add(minor->kdev);
|
|
|
|
if (ret)
|
2013-08-08 07:41:34 -06:00
|
|
|
goto err_debugfs;
|
2008-04-21 00:47:32 -06:00
|
|
|
|
2014-02-24 07:53:25 -07:00
|
|
|
/* replace NULL with @minor so lookups will succeed from now on */
|
|
|
|
spin_lock_irqsave(&drm_minor_lock, flags);
|
2014-07-23 02:34:52 -06:00
|
|
|
idr_replace(&drm_minors_idr, minor, minor->index);
|
2014-02-24 07:53:25 -07:00
|
|
|
spin_unlock_irqrestore(&drm_minor_lock, flags);
|
2008-04-21 00:47:32 -06:00
|
|
|
|
2014-07-23 02:34:52 -06:00
|
|
|
DRM_DEBUG("new minor registered %d\n", minor->index);
|
2008-04-21 00:47:32 -06:00
|
|
|
return 0;
|
|
|
|
|
2013-08-08 07:41:34 -06:00
|
|
|
err_debugfs:
|
2014-07-23 02:34:52 -06:00
|
|
|
drm_debugfs_cleanup(minor);
|
2005-04-16 16:20:36 -06:00
|
|
|
return ret;
|
|
|
|
}
|
2005-09-24 22:28:13 -06:00
|
|
|
|
2014-01-29 04:57:05 -07:00
|
|
|
static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
|
2013-10-20 10:55:40 -06:00
|
|
|
{
|
2014-01-29 04:57:05 -07:00
|
|
|
struct drm_minor *minor;
|
2014-02-24 07:53:25 -07:00
|
|
|
unsigned long flags;
|
2014-01-29 04:57:05 -07:00
|
|
|
|
|
|
|
minor = *drm_minor_get_slot(dev, type);
|
2014-07-23 03:38:38 -06:00
|
|
|
if (!minor || !device_is_registered(minor->kdev))
|
2013-10-20 10:55:40 -06:00
|
|
|
return;
|
|
|
|
|
2014-07-23 02:34:52 -06:00
|
|
|
/* replace @minor with NULL so lookups will fail from now on */
|
2014-02-24 07:53:25 -07:00
|
|
|
spin_lock_irqsave(&drm_minor_lock, flags);
|
2014-07-23 02:34:52 -06:00
|
|
|
idr_replace(&drm_minors_idr, NULL, minor->index);
|
2014-02-24 07:53:25 -07:00
|
|
|
spin_unlock_irqrestore(&drm_minor_lock, flags);
|
2013-10-20 10:55:43 -06:00
|
|
|
|
2014-07-23 03:38:38 -06:00
|
|
|
device_del(minor->kdev);
|
|
|
|
dev_set_drvdata(minor->kdev, NULL); /* safety belt */
|
2013-10-20 10:55:43 -06:00
|
|
|
drm_debugfs_cleanup(minor);
|
2013-10-20 10:55:40 -06:00
|
|
|
}
|
|
|
|
|
2016-11-14 04:58:19 -07:00
|
|
|
/*
|
2014-01-29 02:49:19 -07:00
|
|
|
* 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.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2014-01-29 02:49:19 -07:00
|
|
|
struct drm_minor *drm_minor_acquire(unsigned int minor_id)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-01-29 02:49:19 -07:00
|
|
|
struct drm_minor *minor;
|
2014-02-24 07:53:25 -07:00
|
|
|
unsigned long flags;
|
2014-01-29 02:49:19 -07:00
|
|
|
|
2014-02-24 07:53:25 -07:00
|
|
|
spin_lock_irqsave(&drm_minor_lock, flags);
|
2014-01-29 02:49:19 -07:00
|
|
|
minor = idr_find(&drm_minors_idr, minor_id);
|
2014-02-24 07:53:25 -07:00
|
|
|
if (minor)
|
2017-09-26 02:28:49 -06:00
|
|
|
drm_dev_get(minor->dev);
|
2014-02-24 07:53:25 -07:00
|
|
|
spin_unlock_irqrestore(&drm_minor_lock, flags);
|
|
|
|
|
|
|
|
if (!minor) {
|
|
|
|
return ERR_PTR(-ENODEV);
|
2017-08-02 05:56:02 -06:00
|
|
|
} else if (drm_dev_is_unplugged(minor->dev)) {
|
2017-09-26 02:28:49 -06:00
|
|
|
drm_dev_put(minor->dev);
|
2014-01-29 02:49:19 -07:00
|
|
|
return ERR_PTR(-ENODEV);
|
2014-02-24 07:53:25 -07:00
|
|
|
}
|
2008-07-30 13:06:12 -06:00
|
|
|
|
2014-01-29 02:49:19 -07:00
|
|
|
return minor;
|
|
|
|
}
|
2005-09-24 22:28:13 -06:00
|
|
|
|
2014-01-29 02:49:19 -07:00
|
|
|
void drm_minor_release(struct drm_minor *minor)
|
|
|
|
{
|
2017-09-26 02:28:49 -06:00
|
|
|
drm_dev_put(minor->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-01-04 14:55:33 -07:00
|
|
|
|
2015-09-28 13:46:35 -06:00
|
|
|
/**
|
|
|
|
* DOC: driver instance overview
|
|
|
|
*
|
2016-12-29 13:48:26 -07:00
|
|
|
* A device instance for a drm driver is represented by &struct drm_device. This
|
2020-09-02 01:26:27 -06:00
|
|
|
* is allocated and initialized with devm_drm_dev_alloc(), usually from
|
|
|
|
* bus-specific ->probe() callbacks implemented by the driver. The driver then
|
|
|
|
* needs to initialize all the various subsystems for the drm device like memory
|
|
|
|
* management, vblank handling, modesetting support and initial output
|
|
|
|
* configuration plus obviously initialize all the corresponding hardware bits.
|
|
|
|
* Finally when everything is up and running and ready for userspace the device
|
|
|
|
* instance can be published using drm_dev_register().
|
2015-09-28 13:46:35 -06:00
|
|
|
*
|
|
|
|
* There is also deprecated support for initalizing device instances using
|
2017-01-24 23:26:47 -07:00
|
|
|
* bus-specific helpers and the &drm_driver.load callback. But due to
|
2015-09-28 13:46:35 -06:00
|
|
|
* backwards-compatibility needs the device instance have to be published too
|
|
|
|
* early, which requires unpretty global locking to make safe and is therefore
|
|
|
|
* only support for existing drivers not yet converted to the new scheme.
|
|
|
|
*
|
|
|
|
* When cleaning up a device instance everything needs to be done in reverse:
|
|
|
|
* First unpublish the device instance with drm_dev_unregister(). Then clean up
|
|
|
|
* any other resources allocated at device initialization and drop the driver's
|
2017-09-26 02:28:49 -06:00
|
|
|
* reference to &drm_device using drm_dev_put().
|
2015-09-28 13:46:35 -06:00
|
|
|
*
|
drm: Add docs for managed resources
All collected together to provide a consistent story in one patch,
instead of the somewhat bumpy refactor-evolution leading to this.
Also some thoughts on what the next steps could be:
- Create a macro called devm_drm_dev_alloc() which essentially wraps
the kzalloc(); devm_drm_dev_init(); drmm_add_final_kfree() combo.
Needs to be a macro since we'll have to do some typeof trickery and
casting to make this fully generic for all drivers that embed struct
drm_device into their own thing.
- A lot of the simple drivers now have essentially just
drm_dev_unplug(); drm_atomic_helper_shutdown(); as their
$bus_driver->remove hook. We could create a devm_mode_config_reset
which sets drm_atomic_helper_shutdown as it's cleanup action, and a
devm_drm_dev_register with drm_dev_unplug as it's cleanup action,
and simple drivers wouldn't have a need for a ->remove function at
all, and we could delete them.
- For more complicated drivers we need drmm_ versions of a _lot_ more
things. All the userspace visible objects (crtc, plane, encoder,
crtc), anything else hanging of those (maybe a drmm_get_edid, at
least for panels and other built-in stuff).
Also some more thoughts on why we're not reusing devm_ with maybe a
fake struct device embedded into the drm_device (we can't use the
kdev, since that's in each drm_minor).
- Code review gets extremely tricky, since every time you see a devm_
you need to carefully check whether the fake device (with the
drm_device lifetim) or the real device (with the lifetim of the
underlying physical device and driver binding) are used. That's not
going to help at all, and we have enormous amounts of drivers who
use devm_ where they really shouldn't. Having different types makes
sure the compiler type checks this for us and ensures correctness.
- The set of functions are very much non-overlapping. E.g.
devm_ioremap makes total sense, drmm_ioremap has the wrong lifetime,
since hw resources need to be cleaned out at driver unbind and wont
outlive that like a drm_device. Similar, but other way round for
drmm_connector_init (which is the only correct version, devm_ for
drm_connector is just buggy). Simply not having the wrong version
again prevents bugs.
Finally I guess this opens a huge todo for all the drivers. I'm
semi-tempted to do a tree-wide s/devm_kzalloc/drmm_kzalloc/ since most
likely that'll fix an enormous amount of bugs and most likely not
cause any issues at all (aside from maybe holding onto memory slightly
too long).
v2:
- Doc improvements from Laurent.
- Also add kerneldoc for the new drmm_add_action_or_reset.
v3:
- Remove kerneldoc for drmm_remove_action.
Reviewed-by: Sam Ravnborg <sam@ravnborg.org>
Cc: Sam Ravnborg <sam@ravnborg.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: linux-doc@vger.kernel.org
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "Rafael J. Wysocki" <rafael@kernel.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
fixup docs
Link: https://patchwork.freedesktop.org/patch/msgid/20200323144950.3018436-52-daniel.vetter@ffwll.ch
2020-03-23 08:49:50 -06:00
|
|
|
* Note that any allocation or resource which is visible to userspace must be
|
|
|
|
* released only when the final drm_dev_put() is called, and not when the
|
|
|
|
* driver is unbound from the underlying physical struct &device. Best to use
|
|
|
|
* &drm_device managed resources with drmm_add_action(), drmm_kmalloc() and
|
|
|
|
* related functions.
|
|
|
|
*
|
|
|
|
* devres managed resources like devm_kmalloc() can only be used for resources
|
|
|
|
* directly related to the underlying hardware device, and only used in code
|
|
|
|
* paths fully protected by drm_dev_enter() and drm_dev_exit().
|
2019-02-25 07:42:28 -07:00
|
|
|
*
|
|
|
|
* Display driver example
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* The following example shows a typical structure of a DRM display driver.
|
|
|
|
* The example focus on the probe() function and the other functions that is
|
2020-09-02 01:26:27 -06:00
|
|
|
* almost always present and serves as a demonstration of devm_drm_dev_alloc().
|
2019-02-25 07:42:28 -07:00
|
|
|
*
|
|
|
|
* .. code-block:: c
|
|
|
|
*
|
|
|
|
* struct driver_device {
|
|
|
|
* struct drm_device drm;
|
|
|
|
* void *userspace_facing;
|
|
|
|
* struct clk *pclk;
|
|
|
|
* };
|
|
|
|
*
|
|
|
|
* static struct drm_driver driver_drm_driver = {
|
|
|
|
* [...]
|
|
|
|
* };
|
|
|
|
*
|
|
|
|
* static int driver_probe(struct platform_device *pdev)
|
|
|
|
* {
|
|
|
|
* struct driver_device *priv;
|
|
|
|
* struct drm_device *drm;
|
|
|
|
* int ret;
|
|
|
|
*
|
2020-09-02 01:26:27 -06:00
|
|
|
* priv = devm_drm_dev_alloc(&pdev->dev, &driver_drm_driver,
|
|
|
|
* struct driver_device, drm);
|
|
|
|
* if (IS_ERR(priv))
|
|
|
|
* return PTR_ERR(priv);
|
2019-02-25 07:42:28 -07:00
|
|
|
* drm = &priv->drm;
|
|
|
|
*
|
2020-03-23 08:49:25 -06:00
|
|
|
* ret = drmm_mode_config_init(drm);
|
|
|
|
* if (ret)
|
|
|
|
* return ret;
|
2019-02-25 07:42:28 -07:00
|
|
|
*
|
2020-03-23 08:49:18 -06:00
|
|
|
* priv->userspace_facing = drmm_kzalloc(..., GFP_KERNEL);
|
2019-02-25 07:42:28 -07:00
|
|
|
* if (!priv->userspace_facing)
|
|
|
|
* return -ENOMEM;
|
|
|
|
*
|
|
|
|
* priv->pclk = devm_clk_get(dev, "PCLK");
|
|
|
|
* if (IS_ERR(priv->pclk))
|
|
|
|
* return PTR_ERR(priv->pclk);
|
|
|
|
*
|
2019-08-08 10:36:28 -06:00
|
|
|
* // Further setup, display pipeline etc
|
2019-02-25 07:42:28 -07:00
|
|
|
*
|
|
|
|
* platform_set_drvdata(pdev, drm);
|
|
|
|
*
|
|
|
|
* drm_mode_config_reset(drm);
|
|
|
|
*
|
|
|
|
* ret = drm_dev_register(drm);
|
|
|
|
* if (ret)
|
|
|
|
* return ret;
|
|
|
|
*
|
|
|
|
* drm_fbdev_generic_setup(drm, 32);
|
|
|
|
*
|
|
|
|
* return 0;
|
|
|
|
* }
|
|
|
|
*
|
2019-08-08 10:36:28 -06:00
|
|
|
* // This function is called before the devm_ resources are released
|
2019-02-25 07:42:28 -07:00
|
|
|
* static int driver_remove(struct platform_device *pdev)
|
|
|
|
* {
|
|
|
|
* struct drm_device *drm = platform_get_drvdata(pdev);
|
|
|
|
*
|
|
|
|
* drm_dev_unregister(drm);
|
|
|
|
* drm_atomic_helper_shutdown(drm)
|
|
|
|
*
|
|
|
|
* return 0;
|
|
|
|
* }
|
|
|
|
*
|
2019-08-08 10:36:28 -06:00
|
|
|
* // This function is called on kernel restart and shutdown
|
2019-02-25 07:42:28 -07:00
|
|
|
* static void driver_shutdown(struct platform_device *pdev)
|
|
|
|
* {
|
|
|
|
* drm_atomic_helper_shutdown(platform_get_drvdata(pdev));
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* static int __maybe_unused driver_pm_suspend(struct device *dev)
|
|
|
|
* {
|
|
|
|
* return drm_mode_config_helper_suspend(dev_get_drvdata(dev));
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* static int __maybe_unused driver_pm_resume(struct device *dev)
|
|
|
|
* {
|
|
|
|
* drm_mode_config_helper_resume(dev_get_drvdata(dev));
|
|
|
|
*
|
|
|
|
* return 0;
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* static const struct dev_pm_ops driver_pm_ops = {
|
|
|
|
* SET_SYSTEM_SLEEP_PM_OPS(driver_pm_suspend, driver_pm_resume)
|
|
|
|
* };
|
|
|
|
*
|
|
|
|
* static struct platform_driver driver_driver = {
|
|
|
|
* .driver = {
|
|
|
|
* [...]
|
|
|
|
* .pm = &driver_pm_ops,
|
|
|
|
* },
|
|
|
|
* .probe = driver_probe,
|
|
|
|
* .remove = driver_remove,
|
|
|
|
* .shutdown = driver_shutdown,
|
|
|
|
* };
|
|
|
|
* module_platform_driver(driver_driver);
|
|
|
|
*
|
|
|
|
* Drivers that want to support device unplugging (USB, DT overlay unload) should
|
|
|
|
* use drm_dev_unplug() instead of drm_dev_unregister(). The driver must protect
|
|
|
|
* regions that is accessing device resources to prevent use after they're
|
|
|
|
* released. This is done using drm_dev_enter() and drm_dev_exit(). There is one
|
|
|
|
* shortcoming however, drm_dev_unplug() marks the drm_device as unplugged before
|
|
|
|
* drm_atomic_helper_shutdown() is called. This means that if the disable code
|
|
|
|
* paths are protected, they will not run on regular driver module unload,
|
|
|
|
* possibily leaving the hardware enabled.
|
2015-09-28 13:46:35 -06:00
|
|
|
*/
|
|
|
|
|
2009-01-04 14:55:33 -07:00
|
|
|
/**
|
2014-05-19 05:39:07 -06:00
|
|
|
* drm_put_dev - Unregister and release a DRM device
|
|
|
|
* @dev: DRM device
|
2009-01-04 14:55:33 -07:00
|
|
|
*
|
2014-05-19 05:39:07 -06:00
|
|
|
* Called at module unload time or when a PCI device is unplugged.
|
2009-01-04 14:55:33 -07:00
|
|
|
*
|
2014-05-19 05:39:07 -06:00
|
|
|
* Cleans up all DRM device, calling drm_lastclose().
|
2015-09-28 13:46:35 -06:00
|
|
|
*
|
|
|
|
* Note: Use of this function is deprecated. It will eventually go away
|
2017-09-26 02:28:49 -06:00
|
|
|
* completely. Please use drm_dev_unregister() and drm_dev_put() explicitly
|
2015-09-28 13:46:35 -06:00
|
|
|
* instead to make sure that the device isn't userspace accessible any more
|
|
|
|
* while teardown is in progress, ensuring that userspace can't access an
|
|
|
|
* inconsistent state.
|
2009-01-04 14:55:33 -07: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 03:23:38 -06:00
|
|
|
drm_dev_unregister(dev);
|
2017-09-26 02:28:49 -06:00
|
|
|
drm_dev_put(dev);
|
2009-01-04 14:55:33 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_put_dev);
|
2012-02-20 07:18:07 -07:00
|
|
|
|
2018-03-28 01:38:35 -06:00
|
|
|
/**
|
|
|
|
* drm_dev_enter - Enter device critical section
|
|
|
|
* @dev: DRM device
|
|
|
|
* @idx: Pointer to index that will be passed to the matching drm_dev_exit()
|
|
|
|
*
|
|
|
|
* This function marks and protects the beginning of a section that should not
|
|
|
|
* be entered after the device has been unplugged. The section end is marked
|
|
|
|
* with drm_dev_exit(). Calls to this function can be nested.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* True if it is OK to enter the section, false otherwise.
|
|
|
|
*/
|
|
|
|
bool drm_dev_enter(struct drm_device *dev, int *idx)
|
2017-08-02 05:56:02 -06:00
|
|
|
{
|
2018-03-28 01:38:35 -06:00
|
|
|
*idx = srcu_read_lock(&drm_unplug_srcu);
|
|
|
|
|
|
|
|
if (dev->unplugged) {
|
|
|
|
srcu_read_unlock(&drm_unplug_srcu, *idx);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
2017-08-02 05:56:02 -06:00
|
|
|
}
|
2018-03-28 01:38:35 -06:00
|
|
|
EXPORT_SYMBOL(drm_dev_enter);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_dev_exit - Exit device critical section
|
|
|
|
* @idx: index returned from drm_dev_enter()
|
|
|
|
*
|
|
|
|
* This function marks the end of a section that should not be entered after
|
|
|
|
* the device has been unplugged.
|
|
|
|
*/
|
|
|
|
void drm_dev_exit(int idx)
|
2017-08-02 05:56:02 -06:00
|
|
|
{
|
2018-03-28 01:38:35 -06:00
|
|
|
srcu_read_unlock(&drm_unplug_srcu, idx);
|
2017-08-02 05:56:02 -06:00
|
|
|
}
|
2018-03-28 01:38:35 -06:00
|
|
|
EXPORT_SYMBOL(drm_dev_exit);
|
2017-08-02 05:56:02 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_dev_unplug - unplug a DRM device
|
|
|
|
* @dev: DRM device
|
|
|
|
*
|
|
|
|
* This unplugs a hotpluggable DRM device, which makes it inaccessible to
|
2018-03-28 01:38:35 -06:00
|
|
|
* userspace operations. Entry-points can use drm_dev_enter() and
|
|
|
|
* drm_dev_exit() to protect device resources in a race free manner. This
|
2017-08-02 05:56:02 -06:00
|
|
|
* essentially unregisters the device like drm_dev_unregister(), but can be
|
|
|
|
* called while there are still open users of @dev.
|
|
|
|
*/
|
|
|
|
void drm_dev_unplug(struct drm_device *dev)
|
2012-02-20 07:18:07 -07:00
|
|
|
{
|
2018-03-28 01:38:35 -06:00
|
|
|
/*
|
|
|
|
* After synchronizing any critical read section is guaranteed to see
|
|
|
|
* the new value of ->unplugged, and any critical section which might
|
|
|
|
* still have seen the old value of ->unplugged is guaranteed to have
|
|
|
|
* finished.
|
|
|
|
*/
|
|
|
|
dev->unplugged = true;
|
|
|
|
synchronize_srcu(&drm_unplug_srcu);
|
2018-05-22 08:13:04 -06:00
|
|
|
|
|
|
|
drm_dev_unregister(dev);
|
2012-02-20 07:18:07 -07:00
|
|
|
}
|
2017-08-02 05:56:02 -06:00
|
|
|
EXPORT_SYMBOL(drm_dev_unplug);
|
2013-10-02 03:23:34 -06:00
|
|
|
|
2014-01-03 06:09:47 -07: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;
|
|
|
|
|
2019-03-25 10:38:24 -06:00
|
|
|
static int drm_fs_init_fs_context(struct fs_context *fc)
|
2014-01-03 06:09:47 -07:00
|
|
|
{
|
2019-03-25 10:38:24 -06:00
|
|
|
return init_pseudo(fc, 0x010203ff) ? 0 : -ENOMEM;
|
2014-01-03 06:09:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_system_type drm_fs_type = {
|
|
|
|
.name = "drm",
|
|
|
|
.owner = THIS_MODULE,
|
2019-03-25 10:38:24 -06:00
|
|
|
.init_fs_context = drm_fs_init_fs_context,
|
2014-01-03 06:09:47 -07:00
|
|
|
.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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-12 09:46:15 -07:00
|
|
|
/**
|
|
|
|
* DOC: component helper usage recommendations
|
|
|
|
*
|
|
|
|
* DRM drivers that drive hardware where a logical device consists of a pile of
|
|
|
|
* independent hardware blocks are recommended to use the :ref:`component helper
|
|
|
|
* library<component>`. For consistency and better options for code reuse the
|
|
|
|
* following guidelines apply:
|
|
|
|
*
|
|
|
|
* - The entire device initialization procedure should be run from the
|
2020-09-02 01:26:27 -06:00
|
|
|
* &component_master_ops.master_bind callback, starting with
|
|
|
|
* devm_drm_dev_alloc(), then binding all components with
|
|
|
|
* component_bind_all() and finishing with drm_dev_register().
|
2019-02-12 09:46:15 -07:00
|
|
|
*
|
|
|
|
* - The opaque pointer passed to all components through component_bind_all()
|
|
|
|
* should point at &struct drm_device of the device instance, not some driver
|
|
|
|
* specific private structure.
|
|
|
|
*
|
|
|
|
* - The component helper fills the niche where further standardization of
|
|
|
|
* interfaces is not practical. When there already is, or will be, a
|
|
|
|
* standardized interface like &drm_bridge or &drm_panel, providing its own
|
|
|
|
* functions to find such components at driver load time, like
|
|
|
|
* drm_of_find_panel_or_bridge(), then the component helper should not be
|
|
|
|
* used.
|
|
|
|
*/
|
|
|
|
|
2020-03-23 08:49:20 -06:00
|
|
|
static void drm_dev_init_release(struct drm_device *dev, void *res)
|
|
|
|
{
|
|
|
|
drm_legacy_ctxbitmap_cleanup(dev);
|
|
|
|
drm_legacy_remove_map_hash(dev);
|
|
|
|
drm_fs_inode_free(dev->anon_inode);
|
|
|
|
|
|
|
|
put_device(dev->dev);
|
|
|
|
/* Prevent use-after-free in drm_managed_release when debugging is
|
|
|
|
* enabled. Slightly awkward, but can't really be helped. */
|
|
|
|
dev->dev = NULL;
|
|
|
|
mutex_destroy(&dev->master_mutex);
|
|
|
|
mutex_destroy(&dev->clientlist_mutex);
|
|
|
|
mutex_destroy(&dev->filelist_mutex);
|
|
|
|
mutex_destroy(&dev->struct_mutex);
|
|
|
|
drm_legacy_destroy_members(dev);
|
|
|
|
}
|
|
|
|
|
2013-10-02 03:23:34 -06:00
|
|
|
/**
|
2016-06-15 06:17:46 -06:00
|
|
|
* drm_dev_init - Initialise new DRM device
|
|
|
|
* @dev: DRM device
|
|
|
|
* @driver: DRM driver
|
2013-10-02 03:23:34 -06:00
|
|
|
* @parent: Parent device object
|
|
|
|
*
|
2016-06-15 06:17:46 -06:00
|
|
|
* Initialize a new DRM device. No device registration is done.
|
2013-10-02 03:23:35 -06:00
|
|
|
* Call drm_dev_register() to advertice the device to user space and register it
|
2015-09-28 13:46:35 -06:00
|
|
|
* with other core subsystems. This should be done last in the device
|
|
|
|
* initialization sequence to make sure userspace can't access an inconsistent
|
|
|
|
* state.
|
2013-10-02 03:23:34 -06:00
|
|
|
*
|
2017-09-26 02:28:49 -06:00
|
|
|
* The initial ref-count of the object is 1. Use drm_dev_get() and
|
|
|
|
* drm_dev_put() to take and drop further ref-counts.
|
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 02:21:36 -07:00
|
|
|
*
|
2019-01-11 09:40:44 -07:00
|
|
|
* It is recommended that drivers embed &struct drm_device into their own device
|
|
|
|
* structure.
|
|
|
|
*
|
2016-06-15 06:17:46 -06:00
|
|
|
* Drivers that do not want to allocate their own device struct
|
2016-12-29 13:48:26 -07:00
|
|
|
* embedding &struct drm_device can call drm_dev_alloc() instead. For drivers
|
|
|
|
* that do embed &struct drm_device it must be placed first in the overall
|
2016-12-08 03:28:47 -07:00
|
|
|
* structure, and the overall structure must be allocated using kmalloc(): The
|
|
|
|
* drm core's release function unconditionally calls kfree() on the @dev pointer
|
2017-02-02 02:36:32 -07:00
|
|
|
* when the final reference is released. To override this behaviour, and so
|
|
|
|
* allow embedding of the drm_device inside the driver's device struct at an
|
|
|
|
* arbitrary offset, you must supply a &drm_driver.release callback and control
|
|
|
|
* the finalization explicitly.
|
2016-06-15 06:17:46 -06:00
|
|
|
*
|
drm: Add docs for managed resources
All collected together to provide a consistent story in one patch,
instead of the somewhat bumpy refactor-evolution leading to this.
Also some thoughts on what the next steps could be:
- Create a macro called devm_drm_dev_alloc() which essentially wraps
the kzalloc(); devm_drm_dev_init(); drmm_add_final_kfree() combo.
Needs to be a macro since we'll have to do some typeof trickery and
casting to make this fully generic for all drivers that embed struct
drm_device into their own thing.
- A lot of the simple drivers now have essentially just
drm_dev_unplug(); drm_atomic_helper_shutdown(); as their
$bus_driver->remove hook. We could create a devm_mode_config_reset
which sets drm_atomic_helper_shutdown as it's cleanup action, and a
devm_drm_dev_register with drm_dev_unplug as it's cleanup action,
and simple drivers wouldn't have a need for a ->remove function at
all, and we could delete them.
- For more complicated drivers we need drmm_ versions of a _lot_ more
things. All the userspace visible objects (crtc, plane, encoder,
crtc), anything else hanging of those (maybe a drmm_get_edid, at
least for panels and other built-in stuff).
Also some more thoughts on why we're not reusing devm_ with maybe a
fake struct device embedded into the drm_device (we can't use the
kdev, since that's in each drm_minor).
- Code review gets extremely tricky, since every time you see a devm_
you need to carefully check whether the fake device (with the
drm_device lifetim) or the real device (with the lifetim of the
underlying physical device and driver binding) are used. That's not
going to help at all, and we have enormous amounts of drivers who
use devm_ where they really shouldn't. Having different types makes
sure the compiler type checks this for us and ensures correctness.
- The set of functions are very much non-overlapping. E.g.
devm_ioremap makes total sense, drmm_ioremap has the wrong lifetime,
since hw resources need to be cleaned out at driver unbind and wont
outlive that like a drm_device. Similar, but other way round for
drmm_connector_init (which is the only correct version, devm_ for
drm_connector is just buggy). Simply not having the wrong version
again prevents bugs.
Finally I guess this opens a huge todo for all the drivers. I'm
semi-tempted to do a tree-wide s/devm_kzalloc/drmm_kzalloc/ since most
likely that'll fix an enormous amount of bugs and most likely not
cause any issues at all (aside from maybe holding onto memory slightly
too long).
v2:
- Doc improvements from Laurent.
- Also add kerneldoc for the new drmm_add_action_or_reset.
v3:
- Remove kerneldoc for drmm_remove_action.
Reviewed-by: Sam Ravnborg <sam@ravnborg.org>
Cc: Sam Ravnborg <sam@ravnborg.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: linux-doc@vger.kernel.org
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "Rafael J. Wysocki" <rafael@kernel.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
fixup docs
Link: https://patchwork.freedesktop.org/patch/msgid/20200323144950.3018436-52-daniel.vetter@ffwll.ch
2020-03-23 08:49:50 -06:00
|
|
|
* Note that drivers must call drmm_add_final_kfree() after this function has
|
|
|
|
* completed successfully.
|
|
|
|
*
|
2013-10-02 03:23:34 -06:00
|
|
|
* RETURNS:
|
2016-06-15 06:17:46 -06:00
|
|
|
* 0 on success, or error code on failure.
|
2013-10-02 03:23:34 -06:00
|
|
|
*/
|
2016-06-15 06:17:46 -06:00
|
|
|
int drm_dev_init(struct drm_device *dev,
|
|
|
|
struct drm_driver *driver,
|
|
|
|
struct device *parent)
|
2013-10-02 03:23:34 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2017-07-08 15:43:52 -06:00
|
|
|
if (!drm_core_init_complete) {
|
|
|
|
DRM_ERROR("DRM core is not initialized\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2019-12-15 12:43:44 -07:00
|
|
|
if (WARN_ON(!parent))
|
|
|
|
return -EINVAL;
|
2018-10-23 10:35:49 -06: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 02:21:36 -07:00
|
|
|
kref_init(&dev->ref);
|
2019-02-25 07:42:26 -07:00
|
|
|
dev->dev = get_device(parent);
|
2013-10-02 03:23:34 -06:00
|
|
|
dev->driver = driver;
|
|
|
|
|
drm: add managed resources tied to drm_device
We have lots of these. And the cleanup code tends to be of dubious
quality. The biggest wrong pattern is that developers use devm_, which
ties the release action to the underlying struct device, whereas
all the userspace visible stuff attached to a drm_device can long
outlive that one (e.g. after a hotunplug while userspace has open
files and mmap'ed buffers). Give people what they want, but with more
correctness.
Mostly copied from devres.c, with types adjusted to fit drm_device and
a few simplifications - I didn't (yet) copy over everything. Since
the types don't match code sharing looked like a hopeless endeavour.
For now it's only super simplified, no groups, you can't remove
actions (but kfree exists, we'll need that soon). Plus all specific to
drm_device ofc, including the logging. Which I didn't bother to make
compile-time optional, since none of the other drm logging is compile
time optional either.
One tricky bit here is the chicken&egg between allocating your
drm_device structure and initiliazing it with drm_dev_init. For
perfect onion unwinding we'd need to have the action to kfree the
allocation registered before drm_dev_init registers any of its own
release handlers. But drm_dev_init doesn't know where exactly the
drm_device is emebedded into the overall structure, and by the time it
returns it'll all be too late. And forcing drivers to be able clean up
everything except the one kzalloc is silly.
Work around this by having a very special final_kfree pointer. This
also avoids troubles with the list head possibly disappearing from
underneath us when we release all resources attached to the
drm_device.
v2: Do all the kerneldoc at the end, to avoid lots of fairly pointless
shuffling while getting everything into shape.
v3: Add static to add/del_dr (Neil)
Move typo fix to the right patch (Neil)
v4: Enforce contract for drmm_add_final_kfree:
Use ksize() to check that the drm_device is indeed contained somewhere
in the final kfree(). Because we need that or the entire managed
release logic blows up in a pile of use-after-frees. Motivated by a
discussion with Laurent.
v5: Review from Laurent:
- %zu instead of casting size_t
- header guards
- sorting of includes
- guarding of data assignment if we didn't allocate it for a NULL
pointer
- delete spurious newline
- cast void* data parameter correctly in ->release call, no idea how
this even worked before
v6: Review from Sam
- Add the kerneldoc for the managed sub-struct back in, even if it
doesn't show up in the generated html somehow.
- Explain why __always_inline.
- Fix bisectability around the final kfree() in drm_dev_relase(). This
is just interim code which will disappear again.
- Some whitespace polish.
- Add debug output when drmm_add_action or drmm_kmalloc fail.
v7: My bisectability fix wasn't up to par as noticed by smatch.
v8: Remove unecessary {} around if else
v9: Use kstrdup_const, which requires kfree_const and introducing a free_dr()
helper (Thomas).
v10: kfree_const goes boom on the plain "kmalloc" assignment, somehow
we need to wrap that in kstrdup_const() too!! Also renumber revision
log, I somehow reset it midway thruh.
Reviewed-by: Sam Ravnborg <sam@ravnborg.org>
Cc: Thomas Zimmermann <tzimmermann@suse.de>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Sam Ravnborg <sam@ravnborg.org>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Cc: Neil Armstrong <narmstrong@baylibre.com
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "Rafael J. Wysocki" <rafael@kernel.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20200324124540.3227396-1-daniel.vetter@ffwll.ch
2020-03-24 06:45:40 -06:00
|
|
|
INIT_LIST_HEAD(&dev->managed.resources);
|
|
|
|
spin_lock_init(&dev->managed.lock);
|
|
|
|
|
2018-09-13 07:16:21 -06:00
|
|
|
/* no per-device feature limits by default */
|
|
|
|
dev->driver_features = ~0u;
|
|
|
|
|
2019-04-22 17:47:27 -06:00
|
|
|
drm_legacy_init_members(dev);
|
2013-10-02 03:23:34 -06:00
|
|
|
INIT_LIST_HEAD(&dev->filelist);
|
2018-07-03 10:03:47 -06:00
|
|
|
INIT_LIST_HEAD(&dev->filelist_internal);
|
|
|
|
INIT_LIST_HEAD(&dev->clientlist);
|
2013-10-02 03:23:34 -06:00
|
|
|
INIT_LIST_HEAD(&dev->vblank_event_list);
|
|
|
|
|
|
|
|
spin_lock_init(&dev->event_lock);
|
|
|
|
mutex_init(&dev->struct_mutex);
|
2016-04-26 11:29:41 -06:00
|
|
|
mutex_init(&dev->filelist_mutex);
|
2018-07-03 10:03:47 -06:00
|
|
|
mutex_init(&dev->clientlist_mutex);
|
2014-02-25 11:57:44 -07:00
|
|
|
mutex_init(&dev->master_mutex);
|
2013-10-02 03:23:34 -06:00
|
|
|
|
2020-03-23 08:49:20 -06:00
|
|
|
ret = drmm_add_action(dev, drm_dev_init_release, NULL);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2014-01-03 06:24:19 -07: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);
|
2020-03-23 08:49:20 -06:00
|
|
|
goto err;
|
2014-01-03 06:24:19 -07:00
|
|
|
}
|
|
|
|
|
2014-03-16 07:38:40 -06:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_RENDER)) {
|
2014-01-29 04:43:56 -07:00
|
|
|
ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
|
|
|
|
if (ret)
|
2020-03-24 14:39:36 -06:00
|
|
|
goto err;
|
2014-01-29 04:43:56 -07:00
|
|
|
}
|
|
|
|
|
2016-08-03 12:04:25 -06:00
|
|
|
ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY);
|
2014-01-29 04:43:56 -07:00
|
|
|
if (ret)
|
2020-03-24 14:39:36 -06:00
|
|
|
goto err;
|
2014-01-29 04:43:56 -07:00
|
|
|
|
2019-04-22 17:40:54 -06:00
|
|
|
ret = drm_legacy_create_map_hash(dev);
|
2016-06-15 06:17:46 -06:00
|
|
|
if (ret)
|
2020-03-24 14:39:36 -06:00
|
|
|
goto err;
|
2013-10-02 03:23:34 -06:00
|
|
|
|
2015-06-23 03:22:36 -06:00
|
|
|
drm_legacy_ctxbitmap_init(dev);
|
2013-10-02 03:23:34 -06:00
|
|
|
|
2014-09-30 08:49:56 -06:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_GEM)) {
|
2013-10-02 03:23:34 -06:00
|
|
|
ret = drm_gem_init(dev);
|
|
|
|
if (ret) {
|
|
|
|
DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
|
2020-03-24 14:39:36 -06:00
|
|
|
goto err;
|
2013-10-02 03:23:34 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-23 10:35:49 -06:00
|
|
|
ret = drm_dev_set_unique(dev, dev_name(parent));
|
2016-06-21 02:54:14 -06:00
|
|
|
if (ret)
|
2020-03-23 08:49:22 -06:00
|
|
|
goto err;
|
2015-12-11 03:20:28 -07:00
|
|
|
|
2016-06-15 06:17:46 -06:00
|
|
|
return 0;
|
2013-10-02 03:23:34 -06:00
|
|
|
|
2020-03-23 08:49:20 -06:00
|
|
|
err:
|
|
|
|
drm_managed_release(dev);
|
|
|
|
|
2016-06-15 06:17:46 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_init);
|
|
|
|
|
2019-02-25 07:42:27 -07:00
|
|
|
static void devm_drm_dev_init_release(void *data)
|
|
|
|
{
|
|
|
|
drm_dev_put(data);
|
|
|
|
}
|
|
|
|
|
2020-09-02 01:26:27 -06:00
|
|
|
static int devm_drm_dev_init(struct device *parent,
|
|
|
|
struct drm_device *dev,
|
|
|
|
struct drm_driver *driver)
|
2019-02-25 07:42:27 -07:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = drm_dev_init(dev, driver, parent);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = devm_add_action(parent, devm_drm_dev_init_release, dev);
|
|
|
|
if (ret)
|
|
|
|
devm_drm_dev_init_release(dev);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-04-15 01:39:36 -06:00
|
|
|
void *__devm_drm_dev_alloc(struct device *parent, struct drm_driver *driver,
|
|
|
|
size_t size, size_t offset)
|
|
|
|
{
|
|
|
|
void *container;
|
|
|
|
struct drm_device *drm;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
container = kzalloc(size, GFP_KERNEL);
|
|
|
|
if (!container)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
drm = container + offset;
|
|
|
|
ret = devm_drm_dev_init(parent, drm, driver);
|
|
|
|
if (ret) {
|
|
|
|
kfree(container);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
|
|
|
drmm_add_final_kfree(drm, container);
|
|
|
|
|
|
|
|
return container;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__devm_drm_dev_alloc);
|
|
|
|
|
2016-06-15 06:17:46 -06:00
|
|
|
/**
|
|
|
|
* drm_dev_alloc - Allocate new DRM device
|
|
|
|
* @driver: DRM driver to allocate device for
|
|
|
|
* @parent: Parent device object
|
|
|
|
*
|
2020-09-02 01:26:27 -06:00
|
|
|
* This is the deprecated version of devm_drm_dev_alloc(), which does not support
|
|
|
|
* subclassing through embedding the struct &drm_device in a driver private
|
|
|
|
* structure, and which does not support automatic cleanup through devres.
|
2016-06-15 06:17:46 -06:00
|
|
|
*
|
|
|
|
* RETURNS:
|
2016-09-21 08:59:19 -06:00
|
|
|
* Pointer to new DRM device, or ERR_PTR on failure.
|
2016-06-15 06:17:46 -06:00
|
|
|
*/
|
|
|
|
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)
|
2016-09-21 08:59:19 -06:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2016-06-15 06:17:46 -06:00
|
|
|
|
|
|
|
ret = drm_dev_init(dev, driver, parent);
|
|
|
|
if (ret) {
|
|
|
|
kfree(dev);
|
2016-09-21 08:59:19 -06:00
|
|
|
return ERR_PTR(ret);
|
2016-06-15 06:17:46 -06:00
|
|
|
}
|
|
|
|
|
2020-03-23 08:49:03 -06:00
|
|
|
drmm_add_final_kfree(dev, dev);
|
|
|
|
|
2016-06-15 06:17:46 -06:00
|
|
|
return dev;
|
2013-10-02 03:23:34 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_alloc);
|
2013-10-02 03:23:35 -06: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 02:21:36 -07:00
|
|
|
static void drm_dev_release(struct kref *ref)
|
2013-10-02 03:23:37 -06: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 02:21:36 -07:00
|
|
|
struct drm_device *dev = container_of(ref, struct drm_device, ref);
|
2013-10-20 10:55:45 -06:00
|
|
|
|
drm: add managed resources tied to drm_device
We have lots of these. And the cleanup code tends to be of dubious
quality. The biggest wrong pattern is that developers use devm_, which
ties the release action to the underlying struct device, whereas
all the userspace visible stuff attached to a drm_device can long
outlive that one (e.g. after a hotunplug while userspace has open
files and mmap'ed buffers). Give people what they want, but with more
correctness.
Mostly copied from devres.c, with types adjusted to fit drm_device and
a few simplifications - I didn't (yet) copy over everything. Since
the types don't match code sharing looked like a hopeless endeavour.
For now it's only super simplified, no groups, you can't remove
actions (but kfree exists, we'll need that soon). Plus all specific to
drm_device ofc, including the logging. Which I didn't bother to make
compile-time optional, since none of the other drm logging is compile
time optional either.
One tricky bit here is the chicken&egg between allocating your
drm_device structure and initiliazing it with drm_dev_init. For
perfect onion unwinding we'd need to have the action to kfree the
allocation registered before drm_dev_init registers any of its own
release handlers. But drm_dev_init doesn't know where exactly the
drm_device is emebedded into the overall structure, and by the time it
returns it'll all be too late. And forcing drivers to be able clean up
everything except the one kzalloc is silly.
Work around this by having a very special final_kfree pointer. This
also avoids troubles with the list head possibly disappearing from
underneath us when we release all resources attached to the
drm_device.
v2: Do all the kerneldoc at the end, to avoid lots of fairly pointless
shuffling while getting everything into shape.
v3: Add static to add/del_dr (Neil)
Move typo fix to the right patch (Neil)
v4: Enforce contract for drmm_add_final_kfree:
Use ksize() to check that the drm_device is indeed contained somewhere
in the final kfree(). Because we need that or the entire managed
release logic blows up in a pile of use-after-frees. Motivated by a
discussion with Laurent.
v5: Review from Laurent:
- %zu instead of casting size_t
- header guards
- sorting of includes
- guarding of data assignment if we didn't allocate it for a NULL
pointer
- delete spurious newline
- cast void* data parameter correctly in ->release call, no idea how
this even worked before
v6: Review from Sam
- Add the kerneldoc for the managed sub-struct back in, even if it
doesn't show up in the generated html somehow.
- Explain why __always_inline.
- Fix bisectability around the final kfree() in drm_dev_relase(). This
is just interim code which will disappear again.
- Some whitespace polish.
- Add debug output when drmm_add_action or drmm_kmalloc fail.
v7: My bisectability fix wasn't up to par as noticed by smatch.
v8: Remove unecessary {} around if else
v9: Use kstrdup_const, which requires kfree_const and introducing a free_dr()
helper (Thomas).
v10: kfree_const goes boom on the plain "kmalloc" assignment, somehow
we need to wrap that in kstrdup_const() too!! Also renumber revision
log, I somehow reset it midway thruh.
Reviewed-by: Sam Ravnborg <sam@ravnborg.org>
Cc: Thomas Zimmermann <tzimmermann@suse.de>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Sam Ravnborg <sam@ravnborg.org>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Cc: Neil Armstrong <narmstrong@baylibre.com
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "Rafael J. Wysocki" <rafael@kernel.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20200324124540.3227396-1-daniel.vetter@ffwll.ch
2020-03-24 06:45:40 -06:00
|
|
|
if (dev->driver->release)
|
2017-02-02 02:36:32 -07:00
|
|
|
dev->driver->release(dev);
|
drm: add managed resources tied to drm_device
We have lots of these. And the cleanup code tends to be of dubious
quality. The biggest wrong pattern is that developers use devm_, which
ties the release action to the underlying struct device, whereas
all the userspace visible stuff attached to a drm_device can long
outlive that one (e.g. after a hotunplug while userspace has open
files and mmap'ed buffers). Give people what they want, but with more
correctness.
Mostly copied from devres.c, with types adjusted to fit drm_device and
a few simplifications - I didn't (yet) copy over everything. Since
the types don't match code sharing looked like a hopeless endeavour.
For now it's only super simplified, no groups, you can't remove
actions (but kfree exists, we'll need that soon). Plus all specific to
drm_device ofc, including the logging. Which I didn't bother to make
compile-time optional, since none of the other drm logging is compile
time optional either.
One tricky bit here is the chicken&egg between allocating your
drm_device structure and initiliazing it with drm_dev_init. For
perfect onion unwinding we'd need to have the action to kfree the
allocation registered before drm_dev_init registers any of its own
release handlers. But drm_dev_init doesn't know where exactly the
drm_device is emebedded into the overall structure, and by the time it
returns it'll all be too late. And forcing drivers to be able clean up
everything except the one kzalloc is silly.
Work around this by having a very special final_kfree pointer. This
also avoids troubles with the list head possibly disappearing from
underneath us when we release all resources attached to the
drm_device.
v2: Do all the kerneldoc at the end, to avoid lots of fairly pointless
shuffling while getting everything into shape.
v3: Add static to add/del_dr (Neil)
Move typo fix to the right patch (Neil)
v4: Enforce contract for drmm_add_final_kfree:
Use ksize() to check that the drm_device is indeed contained somewhere
in the final kfree(). Because we need that or the entire managed
release logic blows up in a pile of use-after-frees. Motivated by a
discussion with Laurent.
v5: Review from Laurent:
- %zu instead of casting size_t
- header guards
- sorting of includes
- guarding of data assignment if we didn't allocate it for a NULL
pointer
- delete spurious newline
- cast void* data parameter correctly in ->release call, no idea how
this even worked before
v6: Review from Sam
- Add the kerneldoc for the managed sub-struct back in, even if it
doesn't show up in the generated html somehow.
- Explain why __always_inline.
- Fix bisectability around the final kfree() in drm_dev_relase(). This
is just interim code which will disappear again.
- Some whitespace polish.
- Add debug output when drmm_add_action or drmm_kmalloc fail.
v7: My bisectability fix wasn't up to par as noticed by smatch.
v8: Remove unecessary {} around if else
v9: Use kstrdup_const, which requires kfree_const and introducing a free_dr()
helper (Thomas).
v10: kfree_const goes boom on the plain "kmalloc" assignment, somehow
we need to wrap that in kstrdup_const() too!! Also renumber revision
log, I somehow reset it midway thruh.
Reviewed-by: Sam Ravnborg <sam@ravnborg.org>
Cc: Thomas Zimmermann <tzimmermann@suse.de>
Cc: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Sam Ravnborg <sam@ravnborg.org>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Cc: Neil Armstrong <narmstrong@baylibre.com
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "Rafael J. Wysocki" <rafael@kernel.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20200324124540.3227396-1-daniel.vetter@ffwll.ch
2020-03-24 06:45:40 -06:00
|
|
|
|
|
|
|
drm_managed_release(dev);
|
|
|
|
|
2020-07-22 21:27:42 -06:00
|
|
|
kfree(dev->managed.final_kfree);
|
2013-10-02 03:23:37 -06: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 02:21:36 -07:00
|
|
|
|
|
|
|
/**
|
2017-09-26 02:28:49 -06:00
|
|
|
* drm_dev_get - Take reference of a DRM device
|
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 02:21:36 -07:00
|
|
|
* @dev: device to take reference of or NULL
|
|
|
|
*
|
|
|
|
* This increases the ref-count of @dev by one. You *must* already own a
|
2017-09-26 02:28:49 -06:00
|
|
|
* reference when calling this. Use drm_dev_put() to drop this reference
|
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 02:21:36 -07:00
|
|
|
* 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.
|
|
|
|
*/
|
2017-09-26 02:28:49 -06:00
|
|
|
void drm_dev_get(struct drm_device *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 02:21:36 -07:00
|
|
|
{
|
|
|
|
if (dev)
|
|
|
|
kref_get(&dev->ref);
|
|
|
|
}
|
2017-09-26 02:28:49 -06:00
|
|
|
EXPORT_SYMBOL(drm_dev_get);
|
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 02:21:36 -07:00
|
|
|
|
|
|
|
/**
|
2017-09-26 02:28:49 -06:00
|
|
|
* drm_dev_put - Drop reference of a DRM device
|
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 02:21:36 -07:00
|
|
|
* @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.
|
|
|
|
*/
|
2017-09-26 02:28:49 -06:00
|
|
|
void drm_dev_put(struct drm_device *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 02:21:36 -07:00
|
|
|
{
|
|
|
|
if (dev)
|
|
|
|
kref_put(&dev->ref, drm_dev_release);
|
|
|
|
}
|
2017-09-26 02:28:49 -06:00
|
|
|
EXPORT_SYMBOL(drm_dev_put);
|
|
|
|
|
2016-12-09 06:56:56 -07:00
|
|
|
static int create_compat_control_link(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_minor *minor;
|
|
|
|
char *name;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
|
|
|
|
if (!minor)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some existing userspace out there uses the existing of the controlD*
|
|
|
|
* sysfs files to figure out whether it's a modeset driver. It only does
|
|
|
|
* readdir, hence a symlink is sufficient (and the least confusing
|
|
|
|
* option). Otherwise controlD* is entirely unused.
|
|
|
|
*
|
|
|
|
* Old controlD chardev have been allocated in the range
|
|
|
|
* 64-127.
|
|
|
|
*/
|
|
|
|
name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);
|
|
|
|
if (!name)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = sysfs_create_link(minor->kdev->kobj.parent,
|
|
|
|
&minor->kdev->kobj,
|
|
|
|
name);
|
|
|
|
|
|
|
|
kfree(name);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void remove_compat_control_link(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_minor *minor;
|
|
|
|
char *name;
|
|
|
|
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
|
|
return;
|
|
|
|
|
|
|
|
minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
|
|
|
|
if (!minor)
|
|
|
|
return;
|
|
|
|
|
2018-05-10 22:15:42 -06:00
|
|
|
name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);
|
2016-12-09 06:56:56 -07:00
|
|
|
if (!name)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sysfs_remove_link(minor->kdev->kobj.parent, name);
|
|
|
|
|
|
|
|
kfree(name);
|
|
|
|
}
|
|
|
|
|
2013-10-02 03:23:35 -06:00
|
|
|
/**
|
|
|
|
* drm_dev_register - Register DRM device
|
|
|
|
* @dev: Device to register
|
2014-05-19 05:39:07 -06:00
|
|
|
* @flags: Flags passed to the driver's .load() function
|
2013-10-02 03:23:35 -06:00
|
|
|
*
|
|
|
|
* Register the DRM device @dev with the system, advertise device to user-space
|
2019-01-11 09:40:44 -07:00
|
|
|
* and start normal device operation. @dev must be initialized via drm_dev_init()
|
2016-06-17 02:25:17 -06:00
|
|
|
* previously.
|
2013-10-02 03:23:35 -06:00
|
|
|
*
|
|
|
|
* Never call this twice on any device!
|
|
|
|
*
|
2015-09-28 13:46:35 -06:00
|
|
|
* NOTE: To ensure backward compatibility with existing drivers method this
|
2017-01-24 23:26:47 -07:00
|
|
|
* function calls the &drm_driver.load method after registering the device
|
|
|
|
* nodes, creating race conditions. Usage of the &drm_driver.load methods is
|
|
|
|
* therefore deprecated, drivers must perform all initialization before calling
|
2015-09-28 13:46:35 -06:00
|
|
|
* drm_dev_register().
|
|
|
|
*
|
2013-10-02 03:23:35 -06:00
|
|
|
* RETURNS:
|
|
|
|
* 0 on success, negative error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_dev_register(struct drm_device *dev, unsigned long flags)
|
|
|
|
{
|
2016-12-28 07:32:11 -07:00
|
|
|
struct drm_driver *driver = dev->driver;
|
2013-10-02 03:23:35 -06:00
|
|
|
int ret;
|
|
|
|
|
2020-02-11 09:22:02 -07:00
|
|
|
if (!driver->load)
|
|
|
|
drm_mode_config_validate(dev);
|
|
|
|
|
2020-03-23 08:49:18 -06:00
|
|
|
WARN_ON(!dev->managed.final_kfree);
|
|
|
|
|
2020-02-04 08:01:46 -07:00
|
|
|
if (drm_dev_needs_global_mutex(dev))
|
|
|
|
mutex_lock(&drm_global_mutex);
|
2013-10-02 03:23:35 -06:00
|
|
|
|
2014-01-29 04:57:05 -07:00
|
|
|
ret = drm_minor_register(dev, DRM_MINOR_RENDER);
|
2014-01-29 04:43:56 -07:00
|
|
|
if (ret)
|
|
|
|
goto err_minors;
|
2013-10-02 03:23:35 -06:00
|
|
|
|
2016-08-03 12:04:25 -06:00
|
|
|
ret = drm_minor_register(dev, DRM_MINOR_PRIMARY);
|
2013-10-02 03:23:35 -06:00
|
|
|
if (ret)
|
2014-01-29 04:43:56 -07:00
|
|
|
goto err_minors;
|
2013-10-02 03:23:35 -06:00
|
|
|
|
2016-12-09 06:56:56 -07:00
|
|
|
ret = create_compat_control_link(dev);
|
|
|
|
if (ret)
|
|
|
|
goto err_minors;
|
|
|
|
|
2019-09-17 06:09:35 -06:00
|
|
|
dev->registered = true;
|
|
|
|
|
2013-10-02 03:23:35 -06:00
|
|
|
if (dev->driver->load) {
|
|
|
|
ret = dev->driver->load(dev, flags);
|
|
|
|
if (ret)
|
2014-01-29 04:43:56 -07:00
|
|
|
goto err_minors;
|
2013-10-02 03:23:35 -06:00
|
|
|
}
|
|
|
|
|
2016-06-18 07:46:41 -06:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_MODESET))
|
2016-06-21 08:37:09 -06:00
|
|
|
drm_modeset_register_all(dev);
|
2016-06-17 02:25:17 -06:00
|
|
|
|
2013-10-02 03:23:35 -06:00
|
|
|
ret = 0;
|
2016-12-28 07:32:11 -07:00
|
|
|
|
|
|
|
DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
|
|
|
|
driver->name, driver->major, driver->minor,
|
2016-12-30 07:16:39 -07:00
|
|
|
driver->patchlevel, driver->date,
|
|
|
|
dev->dev ? dev_name(dev->dev) : "virtual device",
|
2016-12-28 07:32:11 -07:00
|
|
|
dev->primary->index);
|
|
|
|
|
2013-10-02 03:23:35 -06:00
|
|
|
goto out_unlock;
|
|
|
|
|
2014-01-29 04:43:56 -07:00
|
|
|
err_minors:
|
2016-12-09 06:56:56 -07:00
|
|
|
remove_compat_control_link(dev);
|
2016-08-03 12:04:25 -06:00
|
|
|
drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
|
2014-01-29 04:57:05 -07:00
|
|
|
drm_minor_unregister(dev, DRM_MINOR_RENDER);
|
2013-10-02 03:23:35 -06:00
|
|
|
out_unlock:
|
2020-02-04 08:01:46 -07:00
|
|
|
if (drm_dev_needs_global_mutex(dev))
|
|
|
|
mutex_unlock(&drm_global_mutex);
|
2013-10-02 03:23:35 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_register);
|
2013-10-02 03:23:38 -06: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
|
2017-09-26 02:28:49 -06:00
|
|
|
* drm_dev_put() to drop their final reference.
|
2015-09-28 13:46:35 -06:00
|
|
|
*
|
2017-08-02 05:56:02 -06:00
|
|
|
* A special form of unregistering for hotpluggable devices is drm_dev_unplug(),
|
|
|
|
* which can be called while there are still open users of @dev.
|
|
|
|
*
|
2015-09-28 13:46:35 -06:00
|
|
|
* This should be called first in the device teardown code to make sure
|
|
|
|
* userspace can't access the device instance any more.
|
2013-10-02 03:23:38 -06:00
|
|
|
*/
|
|
|
|
void drm_dev_unregister(struct drm_device *dev)
|
|
|
|
{
|
drm: Only lastclose on unload for legacy drivers
The only thing modern drivers are supposed to do in lastclose is
restore the fb emulation state. Which is entirely optional, and
there's really no reason to do that. So restrict it to legacy drivers
(where the driver cleanup essentially happens in lastclose).
This will also allow us to share the unregister function with
drm_dev_unplug().
Quoting my reply to Alex on dri-devel:
On Thu, Aug 3, 2017 at 1:17 AM, Daniel Vetter <daniel.vetter@ffwll.ch> wrote:
> On Wed, Aug 2, 2017 at 10:50 PM, Alex Deucher <alexdeucher@gmail.com> wrote:
>> On Wed, Aug 2, 2017 at 7:56 AM, Daniel Vetter <daniel.vetter@ffwll.ch> wrote:
>>> The only thing modern drivers are supposed to do in lastclose is
>>> restore the fb emulation state. Which is entirely optional, and
>>> there's really no reason to do that. So restrict it to legacy drivers
>>> (where the driver cleanup essentially happens in lastclose).
>>
>> vga_switcheroo_process_delayed_switch() gets called in lastclose.
>> Won't that need to get moved elsewhere for this to work?
>
> Hm right, I forgot the lazy way to do runtime pm by keeping the device
> alive as long as anyone has an open fd for it ... This shouldn't be a
> problem, since you need to unregister from vgaswitcheroo anyway on
> unload. Maybe that blows up, I'll check the code and augment the patch
> as needed.
So I think there's 3 cases:
- Trying to unload the module. You can't do that while anyone has the
fd still open, so lastclose is guaranteeed to run.
- Forcefully unbinding the driver through sysfs. Not any better, since
the can_switch stuff checks for the open count, and so will delay the
delayed switch no matter what.
- Actual hotremoval: a) not implemented since none of the drivers
taking part in vgaswitcheroo correctly unplug the drm device and b)
you can't hotremove a chip from a laptop.
v2: Extend commit message with m-l discussion.
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20170802115604.12734-4-daniel.vetter@ffwll.ch
2017-08-02 05:56:03 -06:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_LEGACY))
|
|
|
|
drm_lastclose(dev);
|
2013-10-02 03:23:38 -06:00
|
|
|
|
2017-01-12 09:15:56 -07:00
|
|
|
dev->registered = false;
|
|
|
|
|
2018-07-03 10:03:47 -06:00
|
|
|
drm_client_dev_unregister(dev);
|
|
|
|
|
2016-06-18 07:46:41 -06:00
|
|
|
if (drm_core_check_feature(dev, DRIVER_MODESET))
|
2016-06-21 08:37:09 -06:00
|
|
|
drm_modeset_unregister_all(dev);
|
2016-06-17 02:25:17 -06:00
|
|
|
|
2013-10-02 03:23:38 -06:00
|
|
|
if (dev->driver->unload)
|
|
|
|
dev->driver->unload(dev);
|
|
|
|
|
2013-12-11 03:34:38 -07:00
|
|
|
if (dev->agp)
|
|
|
|
drm_pci_agp_destroy(dev);
|
2013-10-02 03:23:38 -06:00
|
|
|
|
2019-04-22 16:45:12 -06:00
|
|
|
drm_legacy_rmmaps(dev);
|
2013-10-02 03:23:38 -06:00
|
|
|
|
2016-12-09 06:56:56 -07:00
|
|
|
remove_compat_control_link(dev);
|
2016-08-03 12:04:25 -06:00
|
|
|
drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
|
2014-01-29 04:57:05 -07:00
|
|
|
drm_minor_unregister(dev, DRM_MINOR_RENDER);
|
2013-10-02 03:23:38 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_unregister);
|
2014-04-11 07:23:00 -06:00
|
|
|
|
2016-10-04 03:09:35 -06:00
|
|
|
/**
|
|
|
|
* drm_dev_set_unique - Set the unique name of a DRM device
|
|
|
|
* @dev: device of which to set the unique name
|
|
|
|
* @name: unique name
|
|
|
|
*
|
2019-01-11 09:40:44 -07:00
|
|
|
* Sets the unique name of a DRM device using the specified string. This is
|
|
|
|
* already done by drm_dev_init(), drivers should only override the default
|
|
|
|
* unique name for backwards compatibility reasons.
|
2016-10-04 03:09:35 -06:00
|
|
|
*
|
|
|
|
* Return: 0 on success or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_dev_set_unique(struct drm_device *dev, const char *name)
|
|
|
|
{
|
2020-03-23 08:49:19 -06:00
|
|
|
drmm_kfree(dev, dev->unique);
|
|
|
|
dev->unique = drmm_kstrdup(dev, name, GFP_KERNEL);
|
2016-10-04 03:09:35 -06:00
|
|
|
|
|
|
|
return dev->unique ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(drm_dev_set_unique);
|
|
|
|
|
2014-07-23 04:29:56 -06: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");
|
|
|
|
|
|
|
|
minor = drm_minor_acquire(iminor(inode));
|
2020-02-04 08:01:45 -07:00
|
|
|
if (IS_ERR(minor))
|
|
|
|
return PTR_ERR(minor);
|
2014-07-23 04:29:56 -06:00
|
|
|
|
|
|
|
new_fops = fops_get(minor->dev->driver->fops);
|
|
|
|
if (!new_fops) {
|
|
|
|
err = -ENODEV;
|
2020-02-04 08:01:45 -07:00
|
|
|
goto out;
|
2014-07-23 04:29:56 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
replace_fops(filp, new_fops);
|
|
|
|
if (filp->f_op->open)
|
|
|
|
err = filp->f_op->open(inode, filp);
|
|
|
|
else
|
|
|
|
err = 0;
|
|
|
|
|
2020-02-04 08:01:45 -07:00
|
|
|
out:
|
2014-07-23 04:29:56 -06:00
|
|
|
drm_minor_release(minor);
|
2020-02-04 08:01:45 -07:00
|
|
|
|
2014-07-23 04:29:56 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations drm_stub_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = drm_stub_open,
|
|
|
|
.llseek = noop_llseek,
|
|
|
|
};
|
|
|
|
|
drm: cleanup drm_core_{init,exit}()
Various cleanups to the DRM core initialization and exit handlers:
- Register chrdev last: Once register_chrdev() returns, open() will
succeed on the given chrdevs. This is usually not an issue, as no
chardevs are registered, yet. However, nodes can be created by
user-space via mknod(2), even though such major/minor combinations are
unknown to the kernel. Avoid calling into drm_stub_open() in those
cases.
Again, drm_stub_open() would just bail out as the inode is unknown,
but it's really non-obvious if you hack on drm_stub_open().
- Unify error-paths into just one label. All the error-path helpers can
be called even though the constructors were not called yet, or failed.
Hence, just call all cleanups unconditionally.
- Call into drm_global_release(). This is a no-op, but provides
debugging helpers in case there're GLOBALS left on module unload. This
function was unused until now.
- Use DRM_ERROR() instead of printk(), and also print the error-code on
failure (even if it is static!).
- Don't throw away error-codes of register_chrdev()!
- Don't hardcode -1 as errno. This is just plain wrong.
- Order exit-handlers in the exact reverse order of initialization
(except if the order actually matters for syncing-reasons, which is
not the case here, though).
v2:
- Call drm_core_exit() directly from the init-error-handler. Requires to
drop __exit annotation, though.
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/20160901124837.680-7-dh.herrmann@gmail.com
2016-09-01 06:48:37 -06:00
|
|
|
static void drm_core_exit(void)
|
|
|
|
{
|
|
|
|
unregister_chrdev(DRM_MAJOR, "drm");
|
|
|
|
debugfs_remove(drm_debugfs_root);
|
|
|
|
drm_sysfs_destroy();
|
|
|
|
idr_destroy(&drm_minors_idr);
|
|
|
|
drm_connector_ida_destroy();
|
|
|
|
}
|
|
|
|
|
2014-07-23 04:29:56 -06:00
|
|
|
static int __init drm_core_init(void)
|
|
|
|
{
|
drm: cleanup drm_core_{init,exit}()
Various cleanups to the DRM core initialization and exit handlers:
- Register chrdev last: Once register_chrdev() returns, open() will
succeed on the given chrdevs. This is usually not an issue, as no
chardevs are registered, yet. However, nodes can be created by
user-space via mknod(2), even though such major/minor combinations are
unknown to the kernel. Avoid calling into drm_stub_open() in those
cases.
Again, drm_stub_open() would just bail out as the inode is unknown,
but it's really non-obvious if you hack on drm_stub_open().
- Unify error-paths into just one label. All the error-path helpers can
be called even though the constructors were not called yet, or failed.
Hence, just call all cleanups unconditionally.
- Call into drm_global_release(). This is a no-op, but provides
debugging helpers in case there're GLOBALS left on module unload. This
function was unused until now.
- Use DRM_ERROR() instead of printk(), and also print the error-code on
failure (even if it is static!).
- Don't throw away error-codes of register_chrdev()!
- Don't hardcode -1 as errno. This is just plain wrong.
- Order exit-handlers in the exact reverse order of initialization
(except if the order actually matters for syncing-reasons, which is
not the case here, though).
v2:
- Call drm_core_exit() directly from the init-error-handler. Requires to
drop __exit annotation, though.
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/20160901124837.680-7-dh.herrmann@gmail.com
2016-09-01 06:48:37 -06:00
|
|
|
int ret;
|
2014-07-23 04:29:56 -06:00
|
|
|
|
|
|
|
drm_connector_ida_init();
|
|
|
|
idr_init(&drm_minors_idr);
|
|
|
|
|
2015-09-09 06:21:30 -06:00
|
|
|
ret = drm_sysfs_init();
|
|
|
|
if (ret < 0) {
|
drm: cleanup drm_core_{init,exit}()
Various cleanups to the DRM core initialization and exit handlers:
- Register chrdev last: Once register_chrdev() returns, open() will
succeed on the given chrdevs. This is usually not an issue, as no
chardevs are registered, yet. However, nodes can be created by
user-space via mknod(2), even though such major/minor combinations are
unknown to the kernel. Avoid calling into drm_stub_open() in those
cases.
Again, drm_stub_open() would just bail out as the inode is unknown,
but it's really non-obvious if you hack on drm_stub_open().
- Unify error-paths into just one label. All the error-path helpers can
be called even though the constructors were not called yet, or failed.
Hence, just call all cleanups unconditionally.
- Call into drm_global_release(). This is a no-op, but provides
debugging helpers in case there're GLOBALS left on module unload. This
function was unused until now.
- Use DRM_ERROR() instead of printk(), and also print the error-code on
failure (even if it is static!).
- Don't throw away error-codes of register_chrdev()!
- Don't hardcode -1 as errno. This is just plain wrong.
- Order exit-handlers in the exact reverse order of initialization
(except if the order actually matters for syncing-reasons, which is
not the case here, though).
v2:
- Call drm_core_exit() directly from the init-error-handler. Requires to
drop __exit annotation, though.
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/20160901124837.680-7-dh.herrmann@gmail.com
2016-09-01 06:48:37 -06:00
|
|
|
DRM_ERROR("Cannot create DRM class: %d\n", ret);
|
|
|
|
goto error;
|
2014-07-23 04:29:56 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
drm_debugfs_root = debugfs_create_dir("dri", NULL);
|
|
|
|
|
drm: cleanup drm_core_{init,exit}()
Various cleanups to the DRM core initialization and exit handlers:
- Register chrdev last: Once register_chrdev() returns, open() will
succeed on the given chrdevs. This is usually not an issue, as no
chardevs are registered, yet. However, nodes can be created by
user-space via mknod(2), even though such major/minor combinations are
unknown to the kernel. Avoid calling into drm_stub_open() in those
cases.
Again, drm_stub_open() would just bail out as the inode is unknown,
but it's really non-obvious if you hack on drm_stub_open().
- Unify error-paths into just one label. All the error-path helpers can
be called even though the constructors were not called yet, or failed.
Hence, just call all cleanups unconditionally.
- Call into drm_global_release(). This is a no-op, but provides
debugging helpers in case there're GLOBALS left on module unload. This
function was unused until now.
- Use DRM_ERROR() instead of printk(), and also print the error-code on
failure (even if it is static!).
- Don't throw away error-codes of register_chrdev()!
- Don't hardcode -1 as errno. This is just plain wrong.
- Order exit-handlers in the exact reverse order of initialization
(except if the order actually matters for syncing-reasons, which is
not the case here, though).
v2:
- Call drm_core_exit() directly from the init-error-handler. Requires to
drop __exit annotation, though.
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/20160901124837.680-7-dh.herrmann@gmail.com
2016-09-01 06:48:37 -06:00
|
|
|
ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops);
|
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
|
2017-07-08 15:43:52 -06:00
|
|
|
drm_core_init_complete = true;
|
|
|
|
|
2016-12-29 06:37:29 -07:00
|
|
|
DRM_DEBUG("Initialized\n");
|
2014-07-23 04:29:56 -06:00
|
|
|
return 0;
|
|
|
|
|
drm: cleanup drm_core_{init,exit}()
Various cleanups to the DRM core initialization and exit handlers:
- Register chrdev last: Once register_chrdev() returns, open() will
succeed on the given chrdevs. This is usually not an issue, as no
chardevs are registered, yet. However, nodes can be created by
user-space via mknod(2), even though such major/minor combinations are
unknown to the kernel. Avoid calling into drm_stub_open() in those
cases.
Again, drm_stub_open() would just bail out as the inode is unknown,
but it's really non-obvious if you hack on drm_stub_open().
- Unify error-paths into just one label. All the error-path helpers can
be called even though the constructors were not called yet, or failed.
Hence, just call all cleanups unconditionally.
- Call into drm_global_release(). This is a no-op, but provides
debugging helpers in case there're GLOBALS left on module unload. This
function was unused until now.
- Use DRM_ERROR() instead of printk(), and also print the error-code on
failure (even if it is static!).
- Don't throw away error-codes of register_chrdev()!
- Don't hardcode -1 as errno. This is just plain wrong.
- Order exit-handlers in the exact reverse order of initialization
(except if the order actually matters for syncing-reasons, which is
not the case here, though).
v2:
- Call drm_core_exit() directly from the init-error-handler. Requires to
drop __exit annotation, though.
Signed-off-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/20160901124837.680-7-dh.herrmann@gmail.com
2016-09-01 06:48:37 -06:00
|
|
|
error:
|
|
|
|
drm_core_exit();
|
2014-07-23 04:29:56 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(drm_core_init);
|
|
|
|
module_exit(drm_core_exit);
|