/usr/src/sys/dev/pci/drm/include/drm/drm

Bug Summary

File:	dev/pci/drm/include/drm/drm_drv.h
Warning:	line 563, column 3 1st function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name drm_drv.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/pci/drm/drm_drv.c

/usr/src/sys/dev/pci/drm/drm_drv.c

→

1/*
* Created: Fri Jan 19 10:48:35 2001 by faith@acm.org
*
* Copyright 2001 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Author Rickard E. (Rik) Faith <faith@valinux.com>
*
* 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.
*/

29#include <sys/param.h>
30#include <sys/fcntl.h>
31#include <sys/specdev.h>
32#include <sys/vnode.h>

34#include <machine/bus.h>

36#ifdef __HAVE_ACPI
37#include <dev/acpi/acpidev.h>
38#include <dev/acpi/acpivar.h>
39#include <dev/acpi/dsdt.h>
40#endif

42#include <linux/debugfs.h>
43#include <linux/fs.h>
44#include <linux/module.h>
45#include <linux/moduleparam.h>
46#include <linux/mount.h>
47#include <linux/pseudo_fs.h>
48#include <linux/slab.h>
49#include <linux/srcu.h>

51#include <drm/drm_cache.h>
52#include <drm/drm_client.h>
53#include <drm/drm_color_mgmt.h>
54#include <drm/drm_drv.h>
55#include <drm/drm_file.h>
56#include <drm/drm_managed.h>
57#include <drm/drm_mode_object.h>
58#include <drm/drm_print.h>
59#include <drm/drm_privacy_screen_machine.h>

61#include <drm/drm_gem.h>

63#include "drm_crtc_internal.h"
64#include "drm_internal.h"
65#include "drm_legacy.h"

67MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl");
68MODULE_DESCRIPTION("DRM shared core routines");
69MODULE_LICENSE("GPL and additional rights");

71static DEFINE_SPINLOCK(drm_minor_lock)struct mutex drm_minor_lock = { ((void *)0), ((((0x9)) > 0x0
 && ((0x9)) < 0x9) ? 0x9 : ((0x9))), 0x0 };
72static struct idr drm_minors_idr;

74/*
* 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.
*/
81static bool_Bool drm_core_init_complete;

83static struct dentry *drm_debugfs_root;

85#ifdef notyet
86DEFINE_STATIC_SRCU(drm_unplug_srcu);
87#endif

89/*
* Some functions are only called once on init regardless of how many times
* drm attaches.  In linux this is handled via module_init()/module_exit()
*/
93int drm_refcnt; 

95struct drm_softc {
struct device		sc_dev;
struct drm_device 	*sc_drm;
int			sc_allocated;
99};

101struct drm_attach_args {
struct drm_device		*drm;
const struct drm_driver		*driver;
char				*busid;
bus_dma_tag_t			 dmat;
bus_space_tag_t			 bst;
size_t				 busid_len;
int				 is_agp;
struct pci_attach_args		*pa;
int				 primary;
111};

113void	drm_linux_init(void);
114void	drm_linux_exit(void);
115int	drm_linux_acpi_notify(struct aml_node *, int, void *);

117int	drm_dequeue_event(struct drm_device *, struct drm_file *, size_t,
   struct drm_pending_event **);

120int	drmprint(void *, const char *);
121int	drmsubmatch(struct device *, void *, void *);
122const struct pci_device_id *
drm_find_description(int, int, const struct pci_device_id *);

125int	drm_file_cmp(struct drm_file *, struct drm_file *);
126SPLAY_PROTOTYPE(drm_file_tree, drm_file, link, drm_file_cmp)void drm_file_tree_SPLAY(struct drm_file_tree *, struct drm_file
 *); void drm_file_tree_SPLAY_MINMAX(struct drm_file_tree *, int
); struct drm_file *drm_file_tree_SPLAY_INSERT(struct drm_file_tree
 *, struct drm_file *); struct drm_file *drm_file_tree_SPLAY_REMOVE
(struct drm_file_tree *, struct drm_file *); static __attribute__
((__unused__)) __inline struct drm_file * drm_file_tree_SPLAY_FIND
(struct drm_file_tree *head, struct drm_file *elm) { if (((head
)->sph_root == ((void *)0))) return(((void *)0)); drm_file_tree_SPLAY
(head, elm); if ((drm_file_cmp)(elm, (head)->sph_root) == 0
) return (head->sph_root); return (((void *)0)); } static __attribute__
((__unused__)) __inline struct drm_file * drm_file_tree_SPLAY_NEXT
(struct drm_file_tree *head, struct drm_file *elm) { drm_file_tree_SPLAY
(head, elm); if ((elm)->link.spe_right != ((void *)0)) { elm
 = (elm)->link.spe_right; while ((elm)->link.spe_left !=
 ((void *)0)) { elm = (elm)->link.spe_left; } } else elm =
 ((void *)0); return (elm); } static __attribute__((__unused__
)) __inline struct drm_file * drm_file_tree_SPLAY_MIN_MAX(struct
 drm_file_tree *head, int val) { drm_file_tree_SPLAY_MINMAX(head
, val); return ((head)->sph_root); };

128#define DRMDEVCF_PRIMARY0	0
129#define drmdevcf_primarycf_loc[0]	cf_loc[DRMDEVCF_PRIMARY0]	/* spec'd as primary? */
130#define DRMDEVCF_PRIMARY_UNK-1	-1

132/*
* 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.
*
* 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.
*/

145static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
			     unsigned int type)
147{
switch (type) {
case DRM_MINOR_PRIMARY:
return &dev->primary;
case DRM_MINOR_RENDER:
return &dev->render;
default:
BUG()do { panic("BUG at %s:%d", "/usr/src/sys/dev/pci/drm/drm_drv.c"
, 154); } while (0);
}
156}

158static void drm_minor_alloc_release(struct drm_device *dev, void *data)
159{
struct drm_minor *minor = data;
unsigned long flags;

WARN_ON(dev != minor->dev)({ int __ret = !!(dev != minor->dev); if (__ret) printf("WARNING %s failed at %s:%d\n"
, "dev != minor->dev", "/usr/src/sys/dev/pci/drm/drm_drv.c"
, 163); __builtin_expect(!!(__ret), 0); });

165#ifdef __linux__
put_device(minor->kdev);
167#endif

spin_lock_irqsave(&drm_minor_lock, flags)do { flags = 0; mtx_enter(&drm_minor_lock); } while (0);
idr_remove(&drm_minors_idr, minor->index);
spin_unlock_irqrestore(&drm_minor_lock, flags)do { (void)(flags); mtx_leave(&drm_minor_lock); } while (
0);
172}

174static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
175{
struct drm_minor *minor;
unsigned long flags;
int r;

minor = drmm_kzalloc(dev, sizeof(*minor), GFP_KERNEL(0x0001 | 0x0004));
if (!minor)
return -ENOMEM12;

minor->type = type;
minor->dev = dev;

idr_preload(GFP_KERNEL(0x0001 | 0x0004));
spin_lock_irqsave(&drm_minor_lock, flags)do { flags = 0; mtx_enter(&drm_minor_lock); } while (0);
r = idr_alloc(&drm_minors_idr,
      NULL((void *)0),
      64 * type,
      64 * (type + 1),
      GFP_NOWAIT0x0002);
spin_unlock_irqrestore(&drm_minor_lock, flags)do { (void)(flags); mtx_leave(&drm_minor_lock); } while (
0);
idr_preload_end();

if (r < 0)
return r;

minor->index = r;

r = drmm_add_action_or_reset(dev, drm_minor_alloc_release, minor);
if (r)
return r;

206#ifdef __linux__
minor->kdev = drm_sysfs_minor_alloc(minor);
if (IS_ERR(minor->kdev))
return PTR_ERR(minor->kdev);
210#endif

*drm_minor_get_slot(dev, type) = minor;
return 0;
214}

216static int drm_minor_register(struct drm_device *dev, unsigned int type)
217{
struct drm_minor *minor;
unsigned long flags;
220#ifdef __linux__
int ret;
222#endif

DRM_DEBUG("\n")___drm_dbg(((void *)0), DRM_UT_CORE, "\n");

minor = *drm_minor_get_slot(dev, type);
if (!minor)
return 0;

230#ifdef __linux__
ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
if (ret) {
DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n")__drm_err("DRM: Failed to initialize /sys/kernel/debug/dri.\n"
);
goto err_debugfs;
}

ret = device_add(minor->kdev);
if (ret)
goto err_debugfs;
240#else
drm_debugfs_root = NULL((void *)0);
242#endif

/* replace NULL with @minor so lookups will succeed from now on */
spin_lock_irqsave(&drm_minor_lock, flags)do { flags = 0; mtx_enter(&drm_minor_lock); } while (0);
idr_replace(&drm_minors_idr, minor, minor->index);
spin_unlock_irqrestore(&drm_minor_lock, flags)do { (void)(flags); mtx_leave(&drm_minor_lock); } while (
0);

DRM_DEBUG("new minor registered %d\n", minor->index)___drm_dbg(((void *)0), DRM_UT_CORE, "new minor registered %d\n"
, minor->index);
return 0;

252#ifdef __linux__
253err_debugfs:
drm_debugfs_cleanup(minor);
return ret;
256#endif
257}

259static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
260{
struct drm_minor *minor;
unsigned long flags;

minor = *drm_minor_get_slot(dev, type);
265#ifdef __linux__
if (!minor || !device_is_registered(minor->kdev))
267#else
if (!minor)
269#endif
return;

/* replace @minor with NULL so lookups will fail from now on */
spin_lock_irqsave(&drm_minor_lock, flags)do { flags = 0; mtx_enter(&drm_minor_lock); } while (0);
idr_replace(&drm_minors_idr, NULL((void *)0), minor->index);
spin_unlock_irqrestore(&drm_minor_lock, flags)do { (void)(flags); mtx_leave(&drm_minor_lock); } while (
0);

277#ifdef __linux__
device_del(minor->kdev);
279#endif
dev_set_drvdata(minor->kdev, NULL((void *)0)); /* safety belt */
drm_debugfs_cleanup(minor);
282}

284/*
* 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.
*/
293struct drm_minor *drm_minor_acquire(unsigned int minor_id)
294{
struct drm_minor *minor;
unsigned long flags;

spin_lock_irqsave(&drm_minor_lock, flags)do { flags = 0; mtx_enter(&drm_minor_lock); } while (0);
1
Loop condition is false.  Exiting loop→
minor = idr_find(&drm_minors_idr, minor_id);
if (minor)
2
←
Assuming 'minor' is non-null→
3
←
Taking true branch→
drm_dev_get(minor->dev);
spin_unlock_irqrestore(&drm_minor_lock, flags)do { (void)(flags); mtx_leave(&drm_minor_lock); } while (
0);
4
←
Loop condition is false.  Exiting loop→

if (!minor4.1
'minor' is non-null
1
'minor' is non-null
) {
5
←
Taking false branch→
return ERR_PTR(-ENODEV19);
} else if (drm_dev_is_unplugged(minor->dev)) {
6
←
Calling 'drm_dev_is_unplugged'→
drm_dev_put(minor->dev);
return ERR_PTR(-ENODEV19);
}

return minor;
312}

314void drm_minor_release(struct drm_minor *minor)
315{
drm_dev_put(minor->dev);
317}

319/**
* DOC: driver instance overview
*
* A device instance for a drm driver is represented by &struct drm_device. This
* 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().
*
* There is also deprecated support for initializing device instances using
* bus-specific helpers and the &drm_driver.load callback. But due to
* 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
* reference to &drm_device using drm_dev_put().
*
* 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().
*
* 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
* almost always present and serves as a demonstration of devm_drm_dev_alloc().
*
* .. code-block:: c
*
*	struct driver_device {
*		struct drm_device drm;
*		void *userspace_facing;
*		struct clk *pclk;
*	};
*
*	static const struct drm_driver driver_drm_driver = {
*		[...]
*	};
*
*	static int driver_probe(struct platform_device *pdev)
*	{
*		struct driver_device *priv;
*		struct drm_device *drm;
*		int ret;
*
*		priv = devm_drm_dev_alloc(&pdev->dev, &driver_drm_driver,
*					  struct driver_device, drm);
*		if (IS_ERR(priv))
*			return PTR_ERR(priv);
*		drm = &priv->drm;
*
*		ret = drmm_mode_config_init(drm);
*		if (ret)
*			return ret;
*
*		priv->userspace_facing = drmm_kzalloc(..., GFP_KERNEL);
*		if (!priv->userspace_facing)
*			return -ENOMEM;
*
*		priv->pclk = devm_clk_get(dev, "PCLK");
*		if (IS_ERR(priv->pclk))
*			return PTR_ERR(priv->pclk);
*
*		// Further setup, display pipeline etc
*
*		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;
*	}
*
*	// This function is called before the devm_ resources are released
*	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;
*	}
*
*	// This function is called on kernel restart and shutdown
*	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,
* possibly leaving the hardware enabled.
*/

464/**
* drm_put_dev - Unregister and release a DRM device
* @dev: DRM device
*
* Called at module unload time or when a PCI device is unplugged.
*
* Cleans up all DRM device, calling drm_lastclose().
*
* Note: Use of this function is deprecated. It will eventually go away
* completely.  Please use drm_dev_unregister() and drm_dev_put() explicitly
* 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.
*/
478void drm_put_dev(struct drm_device *dev)
479{
DRM_DEBUG("\n")___drm_dbg(((void *)0), DRM_UT_CORE, "\n");

if (!dev) {
DRM_ERROR("cleanup called no dev\n")__drm_err("cleanup called no dev\n");
return;
}

drm_dev_unregister(dev);
drm_dev_put(dev);
489}
490EXPORT_SYMBOL(drm_put_dev);

492/**
* 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.
*/
504bool_Bool drm_dev_enter(struct drm_device *dev, int *idx)
505{
506#ifdef notyet
*idx = srcu_read_lock(&drm_unplug_srcu)0;

if (dev->unplugged) {
srcu_read_unlock(&drm_unplug_srcu, *idx);
return false0;
}
513#endif

return true1;
9
←
Returning without writing to '*idx'→
516}
517EXPORT_SYMBOL(drm_dev_enter);

519/**
* 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.
*/
526void drm_dev_exit(int idx)
527{
528#ifdef notyet
srcu_read_unlock(&drm_unplug_srcu, idx);
530#endif
531}
532EXPORT_SYMBOL(drm_dev_exit);

534/**
* drm_dev_unplug - unplug a DRM device
* @dev: DRM device
*
* This unplugs a hotpluggable DRM device, which makes it inaccessible to
* userspace operations. Entry-points can use drm_dev_enter() and
* drm_dev_exit() to protect device resources in a race free manner. This
* essentially unregisters the device like drm_dev_unregister(), but can be
* called while there are still open users of @dev.
*/
544void drm_dev_unplug(struct drm_device *dev)
545{
STUB()do { printf("%s: stub\n", __func__); } while(0);
547#ifdef notyet
/*
* 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 = true1;
synchronize_srcu(&drm_unplug_srcu);

drm_dev_unregister(dev);

/* Clear all CPU mappings pointing to this device */
unmap_mapping_range(dev->anon_inode->i_mapping, 0, 0, 1);
561#endif
562}
563EXPORT_SYMBOL(drm_dev_unplug);

565#ifdef __linux__
566/*
* 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.
*/

584static int drm_fs_cnt;
585static struct vfsmount *drm_fs_mnt;

587static int drm_fs_init_fs_context(struct fs_context *fc)
588{
return init_pseudo(fc, 0x010203ff) ? 0 : -ENOMEM12;
590}

592static struct file_system_type drm_fs_type = {
.name		= "drm",
.owner		= THIS_MODULE((void *)0),
.init_fs_context = drm_fs_init_fs_context,
.kill_sb	= kill_anon_super,
597};

599static struct inode *drm_fs_inode_new(void)
600{
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)__drm_err("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;
615}

617static void drm_fs_inode_free(struct inode *inode)
618{
if (inode) {
iput(inode);
simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
}
623}

625#endif /* __linux__ */

627/**
* 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
*    &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().
*
*  - 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.
*/

652static void drm_dev_init_release(struct drm_device *dev, void *res)
653{
drm_legacy_ctxbitmap_cleanup(dev);
drm_legacy_remove_map_hash(dev);
656#ifdef __linux__
drm_fs_inode_free(dev->anon_inode);

put_device(dev->dev);
660#endif
/* Prevent use-after-free in drm_managed_release when debugging is
* enabled. Slightly awkward, but can't really be helped. */
dev->dev = NULL((void *)0);
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);
669}

671#ifdef notyet

673static int drm_dev_init(struct drm_device *dev,
	const struct drm_driver *driver,
	struct device *parent)
676{
struct inode *inode;
int ret;

if (!drm_core_init_complete) {
DRM_ERROR("DRM core is not initialized\n")__drm_err("DRM core is not initialized\n");
return -ENODEV19;
}

if (WARN_ON(!parent)({ int __ret = !!(!parent); if (__ret) printf("WARNING %s failed at %s:%d\n"
, "!parent", "/usr/src/sys/dev/pci/drm/drm_drv.c", 685); __builtin_expect
(!!(__ret), 0); }))
return -EINVAL22;

kref_init(&dev->ref);
dev->dev = get_device(parent);
dev->driver = driver;

INIT_LIST_HEAD(&dev->managed.resources);
spin_lock_init(&dev->managed.lock);

/* no per-device feature limits by default */
dev->driver_features = ~0u;

drm_legacy_init_members(dev);
INIT_LIST_HEAD(&dev->filelist);
INIT_LIST_HEAD(&dev->filelist_internal);
INIT_LIST_HEAD(&dev->clientlist);
INIT_LIST_HEAD(&dev->vblank_event_list);

spin_lock_init(&dev->event_lock);
mutex_init(&dev->struct_mutex);
mutex_init(&dev->filelist_mutex);
mutex_init(&dev->clientlist_mutex);
mutex_init(&dev->master_mutex);

ret = drmm_add_action_or_reset(dev, drm_dev_init_release, NULL((void *)0));
if (ret)
return ret;

inode = drm_fs_inode_new();
if (IS_ERR(inode)) {
ret = PTR_ERR(inode);
DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret)__drm_err("Cannot allocate anonymous inode: %d\n", ret);
goto err;
}

dev->anon_inode = inode;

if (drm_core_check_feature(dev, DRIVER_RENDER)) {
ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
if (ret)
	goto err;
}

ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY);
if (ret)
goto err;

ret = drm_legacy_create_map_hash(dev);
if (ret)
goto err;

drm_legacy_ctxbitmap_init(dev);

if (drm_core_check_feature(dev, DRIVER_GEM)) {
ret = drm_gem_init(dev);
if (ret) {
	DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n")__drm_err("Cannot initialize graphics execution manager (GEM)\n"
);
	goto err;
}
}

ret = drm_dev_set_unique(dev, dev_name(parent)"");
if (ret)
goto err;

return 0;

753err:
drm_managed_release(dev);

return ret;
757}

759static void devm_drm_dev_init_release(void *data)
760{
drm_dev_put(data);
762}

764static int devm_drm_dev_init(struct device *parent,
	     struct drm_device *dev,
	     const struct drm_driver *driver)
767{
int ret;

ret = drm_dev_init(dev, driver, parent);
if (ret)
return ret;

return devm_add_action_or_reset(parent,
			devm_drm_dev_init_release, dev);
776}

778#endif

780void *__devm_drm_dev_alloc(struct device *parent,
	   const struct drm_driver *driver,
	   size_t size, size_t offset)
783{
void *container;
struct drm_device *drm;
786#ifdef notyet
int ret;
788#endif

container = kzalloc(size, GFP_KERNEL(0x0001 | 0x0004));
if (!container)
return ERR_PTR(-ENOMEM12);

drm = container + offset;
795#ifdef notyet
ret = devm_drm_dev_init(parent, drm, driver);
if (ret) {
kfree(container);
return ERR_PTR(ret);
}
drmm_add_final_kfree(drm, container);
802#endif

return container;
805}
806EXPORT_SYMBOL(__devm_drm_dev_alloc);

808#ifdef notyet

810/**
* drm_dev_alloc - Allocate new DRM device
* @driver: DRM driver to allocate device for
* @parent: Parent device object
*
* 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.
*
* RETURNS:
* Pointer to new DRM device, or ERR_PTR on failure.
*/
822struct drm_device *drm_dev_alloc(const struct drm_driver *driver,
		 struct device *parent)
824{
struct drm_device *dev;
int ret;

dev = kzalloc(sizeof(*dev), GFP_KERNEL(0x0001 | 0x0004));
if (!dev)
return ERR_PTR(-ENOMEM12);

ret = drm_dev_init(dev, driver, parent);
if (ret) {
kfree(dev);
return ERR_PTR(ret);
}

drmm_add_final_kfree(dev, dev);

return dev;
841}
842EXPORT_SYMBOL(drm_dev_alloc);

844#endif

846static void drm_dev_release(struct kref *ref)
847{
struct drm_device *dev = container_of(ref, struct drm_device, ref)({ const __typeof( ((struct drm_device *)0)->ref ) *__mptr
 = (ref); (struct drm_device *)( (char *)__mptr - __builtin_offsetof
(struct drm_device, ref) );});

if (dev->driver->release)
dev->driver->release(dev);

drm_managed_release(dev);

kfree(dev->managed.final_kfree);
856}

858/**
* drm_dev_get - Take reference of a DRM device
* @dev: device to take reference of or NULL
*
* This increases the ref-count of @dev by one. You *must* already own a
* reference when calling this. Use drm_dev_put() to drop this reference
* again.
*
* This function never fails. However, this function does not provide *any*
* guarantee whether the device is alive or running. It only provides a
* reference to the object and the memory associated with it.
*/
870void drm_dev_get(struct drm_device *dev)
871{
if (dev)
kref_get(&dev->ref);
874}
875EXPORT_SYMBOL(drm_dev_get);

877/**
* drm_dev_put - Drop reference of a DRM device
* @dev: device to drop reference of or NULL
*
* This decreases the ref-count of @dev by one. The device is destroyed if the
* ref-count drops to zero.
*/
884void drm_dev_put(struct drm_device *dev)
885{
if (dev)
kref_put(&dev->ref, drm_dev_release);
888}
889EXPORT_SYMBOL(drm_dev_put);

891static int create_compat_control_link(struct drm_device *dev)
892{
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(0x0001 | 0x0004), "controlD%d", minor->index + 64);
if (!name)
return -ENOMEM12;

ret = sysfs_create_link(minor->kdev->kobj.parent,0
		&minor->kdev->kobj,0
		name)0;

kfree(name);

return ret;
924}

926static void remove_compat_control_link(struct drm_device *dev)
927{
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;

name = kasprintf(GFP_KERNEL(0x0001 | 0x0004), "controlD%d", minor->index + 64);
if (!name)
return;

sysfs_remove_link(minor->kdev->kobj.parent, name);

kfree(name);
945}

947/**
* drm_dev_register - Register DRM device
* @dev: Device to register
* @flags: Flags passed to the driver's .load() function
*
* Register the DRM device @dev with the system, advertise device to user-space
* and start normal device operation. @dev must be initialized via drm_dev_init()
* previously.
*
* Never call this twice on any device!
*
* NOTE: To ensure backward compatibility with existing drivers method this
* 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
* drm_dev_register().
*
* RETURNS:
* 0 on success, negative error code on failure.
*/
967int drm_dev_register(struct drm_device *dev, unsigned long flags)
968{
const struct drm_driver *driver = dev->driver;
int ret;

if (!driver->load)
drm_mode_config_validate(dev);

WARN_ON(!dev->managed.final_kfree)({ int __ret = !!(!dev->managed.final_kfree); if (__ret) printf
("WARNING %s failed at %s:%d\n", "!dev->managed.final_kfree"
, "/usr/src/sys/dev/pci/drm/drm_drv.c", 975); __builtin_expect
(!!(__ret), 0); });

if (drm_dev_needs_global_mutex(dev))
mutex_lock(&drm_global_mutex)rw_enter_write(&drm_global_mutex);

ret = drm_minor_register(dev, DRM_MINOR_RENDER);
if (ret)
goto err_minors;

ret = drm_minor_register(dev, DRM_MINOR_PRIMARY);
if (ret)
goto err_minors;

ret = create_compat_control_link(dev);
if (ret)
goto err_minors;

dev->registered = true1;

if (dev->driver->load) {
ret = dev->driver->load(dev, flags);
if (ret)
	goto err_minors;
}

if (drm_core_check_feature(dev, DRIVER_MODESET))
drm_modeset_register_all(dev);

DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",printk("\0016" "[" "drm" "] " "Initialized %s %d.%d.%d %s for %s on minor %d\n"
, driver->name, driver->major, driver->minor, driver
->patchlevel, driver->date, dev->dev ? "" : "virtual device"
, dev->primary->index)
 driver->name, driver->major, driver->minor,printk("\0016" "[" "drm" "] " "Initialized %s %d.%d.%d %s for %s on minor %d\n"
, driver->name, driver->major, driver->minor, driver
->patchlevel, driver->date, dev->dev ? "" : "virtual device"
, dev->primary->index)
 driver->patchlevel, driver->date,printk("\0016" "[" "drm" "] " "Initialized %s %d.%d.%d %s for %s on minor %d\n"
, driver->name, driver->major, driver->minor, driver
->patchlevel, driver->date, dev->dev ? "" : "virtual device"
, dev->primary->index)
 dev->dev ? dev_name(dev->dev) : "virtual device",printk("\0016" "[" "drm" "] " "Initialized %s %d.%d.%d %s for %s on minor %d\n"
, driver->name, driver->major, driver->minor, driver
->patchlevel, driver->date, dev->dev ? "" : "virtual device"
, dev->primary->index)
 dev->primary->index)printk("\0016" "[" "drm" "] " "Initialized %s %d.%d.%d %s for %s on minor %d\n"
, driver->name, driver->major, driver->minor, driver
->patchlevel, driver->date, dev->dev ? "" : "virtual device"
, dev->primary->index);

goto out_unlock;

1011err_minors:
remove_compat_control_link(dev);
drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
drm_minor_unregister(dev, DRM_MINOR_RENDER);
1015out_unlock:
if (drm_dev_needs_global_mutex(dev))
mutex_unlock(&drm_global_mutex)rw_exit_write(&drm_global_mutex);
return ret;
1019}
1020EXPORT_SYMBOL(drm_dev_register);

1022/**
* drm_dev_unregister - Unregister DRM device
* @dev: Device to unregister
*
* Unregister the DRM device from the system. This does the reverse of
* drm_dev_register() but does not deallocate the device. The caller must call
* drm_dev_put() to drop their final reference.
*
* A special form of unregistering for hotpluggable devices is drm_dev_unplug(),
* which can be called while there are still open users of @dev.
*
* This should be called first in the device teardown code to make sure
* userspace can't access the device instance any more.
*/
1036void drm_dev_unregister(struct drm_device *dev)
1037{
if (drm_core_check_feature(dev, DRIVER_LEGACY))
drm_lastclose(dev);

dev->registered = false0;

drm_client_dev_unregister(dev);

if (drm_core_check_feature(dev, DRIVER_MODESET))
drm_modeset_unregister_all(dev);

if (dev->driver->unload)
dev->driver->unload(dev);

drm_legacy_pci_agp_destroy(dev);
drm_legacy_rmmaps(dev);

remove_compat_control_link(dev);
drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
drm_minor_unregister(dev, DRM_MINOR_RENDER);
1057}
1058EXPORT_SYMBOL(drm_dev_unregister);

1060/**
* drm_dev_set_unique - Set the unique name of a DRM device
* @dev: device of which to set the unique name
* @name: unique name
*
* 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.
*
* Return: 0 on success or a negative error code on failure.
*/
1071int drm_dev_set_unique(struct drm_device *dev, const char *name)
1072{
drmm_kfree(dev, dev->unique);
dev->unique = drmm_kstrdup(dev, name, GFP_KERNEL(0x0001 | 0x0004));

return dev->unique ? 0 : -ENOMEM12;
1077}
1078EXPORT_SYMBOL(drm_dev_set_unique);

1080/*
* 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.
*/

1100#ifdef __linux__
1101static int drm_stub_open(struct inode *inode, struct file *filp)
1102{
const struct file_operations *new_fops;
struct drm_minor *minor;
int err;

DRM_DEBUG("\n")___drm_dbg(((void *)0), DRM_UT_CORE, "\n");

minor = drm_minor_acquire(iminor(inode));
if (IS_ERR(minor))
return PTR_ERR(minor);

new_fops = fops_get(minor->dev->driver->fops);
if (!new_fops) {
err = -ENODEV19;
goto out;
}

replace_fops(filp, new_fops);
if (filp->f_op->open)
err = filp->f_op->open(inode, filp);
else
err = 0;

1125out:
drm_minor_release(minor);

return err;
1129}

1131static const struct file_operations drm_stub_fops = {
.owner = THIS_MODULE((void *)0),
.open = drm_stub_open,
.llseek = noop_llseek,
1135};
1136#endif /* __linux__ */

1138static void drm_core_exit(void)
1139{
drm_privacy_screen_lookup_exit();
1141#ifdef __linux__
unregister_chrdev(DRM_MAJOR, "drm");
debugfs_remove(drm_debugfs_root);
drm_sysfs_destroy();
1145#endif
idr_destroy(&drm_minors_idr);
drm_connector_ida_destroy();
1148}

1150static int __init drm_core_init(void)
1151{
1152#ifdef __linux__
int ret;
1154#endif

drm_connector_ida_init();
idr_init(&drm_minors_idr);
drm_memcpy_init_early();

1160#ifdef __linux__
ret = drm_sysfs_init();
if (ret < 0) {
DRM_ERROR("Cannot create DRM class: %d\n", ret)__drm_err("Cannot create DRM class: %d\n", ret);
goto error;
}

drm_debugfs_root = debugfs_create_dir("dri", NULL)ERR_PTR(-78);

ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops);
if (ret < 0)
goto error;
1172#endif

drm_privacy_screen_lookup_init();

drm_core_init_complete = true1;

DRM_DEBUG("Initialized\n")___drm_dbg(((void *)0), DRM_UT_CORE, "Initialized\n");
return 0;
1180#ifdef __linux__
1181error:
drm_core_exit();
return ret;
1184#endif
1185}

1187#ifdef __linux__
1188module_init(drm_core_init);
1189module_exit(drm_core_exit);
1190#endif

1192void
1193drm_attach_platform(struct drm_driver *driver, bus_space_tag_t iot,
  bus_dma_tag_t dmat, struct device *dev, struct drm_device *drm)
1195{
struct drm_attach_args arg;

memset(&arg, 0, sizeof(arg))__builtin_memset((&arg), (0), (sizeof(arg)));
arg.driver = driver;
arg.bst = iot;
arg.dmat = dmat;
arg.drm = drm;

arg.busid = dev->dv_xname;
arg.busid_len = strlen(dev->dv_xname) + 1;
config_found_sm(dev, &arg, drmprint, drmsubmatch);
1207}

1209struct drm_device *
1210drm_attach_pci(const struct drm_driver *driver, struct pci_attach_args *pa,
  int is_agp, int primary, struct device *dev, struct drm_device *drm)
1212{
struct drm_attach_args arg;
struct drm_softc *sc;

arg.drm = drm;
arg.driver = driver;
arg.dmat = pa->pa_dmat;
arg.bst = pa->pa_memt;
arg.is_agp = is_agp;
arg.primary = primary;
arg.pa = pa;

arg.busid_len = 20;
arg.busid = malloc(arg.busid_len + 1, M_DRM145, M_NOWAIT0x0002);
if (arg.busid == NULL((void *)0)) {
printf("%s: no memory for drm\n", dev->dv_xname);
return (NULL((void *)0));
}
snprintf(arg.busid, arg.busid_len, "pci:%04x:%02x:%02x.%1x",
   pa->pa_domain, pa->pa_bus, pa->pa_device, pa->pa_function);

sc = (struct drm_softc *)config_found_sm(dev, &arg, drmprint, drmsubmatch);
if (sc == NULL((void *)0))
return NULL((void *)0);

return sc->sc_drm;
1238}

1240int
1241drmprint(void *aux, const char *pnp)
1242{
if (pnp != NULL((void *)0))
printf("drm at %s", pnp);
return (UNCONF1);
1246}

1248int
1249drmsubmatch(struct device *parent, void *match, void *aux)
1250{
extern struct cfdriver drm_cd;
struct cfdata *cf = match;

/* only allow drm to attach */
if (cf->cf_driver == &drm_cd)
return ((*cf->cf_attach->ca_match)(parent, match, aux));
return (0);
1258}

1260int
1261drm_pciprobe(struct pci_attach_args *pa, const struct pci_device_id *idlist)
1262{
const struct pci_device_id *id_entry;

id_entry = drm_find_description(PCI_VENDOR(pa->pa_id)(((pa->pa_id) >> 0) & 0xffff),
   PCI_PRODUCT(pa->pa_id)(((pa->pa_id) >> 16) & 0xffff), idlist);
if (id_entry != NULL((void *)0))
return 1;

return 0;
1271}

1273int
1274drm_probe(struct device *parent, void *match, void *aux)
1275{
struct cfdata *cf = match;
struct drm_attach_args *da = aux;

if (cf->drmdevcf_primarycf_loc[0] != DRMDEVCF_PRIMARY_UNK-1) {
/*
 * If primary-ness of device specified, either match
 * exactly (at high priority), or fail.
 */
if (cf->drmdevcf_primarycf_loc[0] != 0 && da->primary != 0)
	return (10);
else
	return (0);
}

/* If primary-ness unspecified, it wins. */
return (1);
1292}

1294int drm_buddy_module_init(void);
1295void drm_buddy_module_exit(void);

1297void
1298drm_attach(struct device *parent, struct device *self, void *aux)
1299{
struct drm_softc *sc = (struct drm_softc *)self;
struct drm_attach_args *da = aux;
struct drm_device *dev = da->drm;
int ret;

if (drm_refcnt == 0) {
drm_linux_init();
drm_core_init();
drm_buddy_module_init();
}
drm_refcnt++;

if (dev == NULL((void *)0)) {
dev = malloc(sizeof(struct drm_device), M_DRM145,
    M_WAITOK0x0001 | M_ZERO0x0008);
sc->sc_allocated = 1;
}

sc->sc_drm = dev;

kref_init(&dev->ref);
dev->dev = self;
dev->dev_private = parent;
dev->driver = da->driver;

INIT_LIST_HEAD(&dev->managed.resources);
mtx_init(&dev->managed.lock, IPL_TTY)do { (void)(((void *)0)); (void)(0); __mtx_init((&dev->
managed.lock), ((((0x9)) > 0x0 && ((0x9)) < 0x9
) ? 0x9 : ((0x9)))); } while (0);

/* no per-device feature limits by default */
dev->driver_features = ~0u;

dev->dmat = da->dmat;
dev->bst = da->bst;
dev->unique = da->busid;

if (da->pa) {
struct pci_attach_args *pa = da->pa;
pcireg_t subsys;

subsys = pci_conf_read(pa->pa_pc, pa->pa_tag,
    PCI_SUBSYS_ID_REG0x2c);

dev->pdev = &dev->_pdev;
dev->pdev->vendor = PCI_VENDOR(pa->pa_id)(((pa->pa_id) >> 0) & 0xffff);
dev->pdev->device = PCI_PRODUCT(pa->pa_id)(((pa->pa_id) >> 16) & 0xffff);
dev->pdev->subsystem_vendor = PCI_VENDOR(subsys)(((subsys) >> 0) & 0xffff);
dev->pdev->subsystem_device = PCI_PRODUCT(subsys)(((subsys) >> 16) & 0xffff);
dev->pdev->revision = PCI_REVISION(pa->pa_class)(((pa->pa_class) >> 0) & 0xff);
dev->pdev->class = (PCI_CLASS(pa->pa_class)(((pa->pa_class) >> 24) & 0xff) << 16) |
    (PCI_SUBCLASS(pa->pa_class)(((pa->pa_class) >> 16) & 0xff) << 8) |
    PCI_INTERFACE(pa->pa_class)(((pa->pa_class) >> 8) & 0xff);

dev->pdev->devfn = PCI_DEVFN(pa->pa_device, pa->pa_function)((pa->pa_device) << 3 | (pa->pa_function));
dev->pdev->bus = &dev->pdev->_bus;
dev->pdev->bus->pc = pa->pa_pc;
dev->pdev->bus->number = pa->pa_bus;
dev->pdev->bus->domain_nr = pa->pa_domain;
dev->pdev->bus->bridgetag = pa->pa_bridgetag;

if (pa->pa_bridgetag != NULL((void *)0)) {
	dev->pdev->bus->self = malloc(sizeof(struct pci_dev),
	    M_DRM145, M_WAITOK0x0001 | M_ZERO0x0008);
	dev->pdev->bus->self->pc = pa->pa_pc;
	dev->pdev->bus->self->tag = *pa->pa_bridgetag;
}

dev->pdev->pc = pa->pa_pc;
dev->pdev->tag = pa->pa_tag;
dev->pdev->pci = (struct pci_softc *)parent->dv_parent;

1370#ifdef CONFIG_ACPI1
dev->pdev->dev.node = acpi_find_pci(pa->pa_pc, pa->pa_tag);
aml_register_notify(dev->pdev->dev.node, NULL((void *)0),
    drm_linux_acpi_notify, NULL((void *)0), ACPIDEV_NOPOLL0);
1374#endif
}

mtx_init(&dev->quiesce_mtx, IPL_NONE)do { (void)(((void *)0)); (void)(0); __mtx_init((&dev->
quiesce_mtx), ((((0x0)) > 0x0 && ((0x0)) < 0x9)
 ? 0x9 : ((0x0)))); } while (0);
mtx_init(&dev->event_lock, IPL_TTY)do { (void)(((void *)0)); (void)(0); __mtx_init((&dev->
event_lock), ((((0x9)) > 0x0 && ((0x9)) < 0x9) ?
 0x9 : ((0x9)))); } while (0);
rw_init(&dev->struct_mutex, "drmdevlk")_rw_init_flags(&dev->struct_mutex, "drmdevlk", 0, ((void
 *)0));
rw_init(&dev->filelist_mutex, "drmflist")_rw_init_flags(&dev->filelist_mutex, "drmflist", 0, ((
void *)0));
rw_init(&dev->clientlist_mutex, "drmclist")_rw_init_flags(&dev->clientlist_mutex, "drmclist", 0, (
(void *)0));
rw_init(&dev->master_mutex, "drmmast")_rw_init_flags(&dev->master_mutex, "drmmast", 0, ((void
 *)0));

ret = drmm_add_action(dev, drm_dev_init_release, NULL((void *)0));
if (ret)
goto error;

SPLAY_INIT(&dev->files)do { (&dev->files)->sph_root = ((void *)0); } while
 (0);
INIT_LIST_HEAD(&dev->filelist_internal);
INIT_LIST_HEAD(&dev->clientlist);
INIT_LIST_HEAD(&dev->vblank_event_list);

if (drm_core_check_feature(dev, DRIVER_RENDER)) {
ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
if (ret)
	goto error;
}

ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY);
if (ret)
goto error;

1403#ifdef CONFIG_DRM_LEGACY
if (drm_core_check_feature(dev, DRIVER_USE_AGP)) {
1405#if IS_ENABLED(CONFIG_AGP)1
if (da->is_agp)
	dev->agp = drm_agp_init();
1408#endif
if (dev->agp != NULL((void *)0)) {
	if (drm_mtrr_add(dev->agp->info.ai_aperture_base,
	    dev->agp->info.ai_aperture_size, DRM_MTRR_WC(1<<1)) == 0)
		dev->agp->mtrr = 1;
}
}
1415#endif

if (dev->driver->gem_size > 0) {
KASSERT(dev->driver->gem_size >= sizeof(struct drm_gem_object))((dev->driver->gem_size >= sizeof(struct drm_gem_object
)) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/pci/drm/drm_drv.c"
, 1418, "dev->driver->gem_size >= sizeof(struct drm_gem_object)"
));
/* XXX unique name */
pool_init(&dev->objpl, dev->driver->gem_size, 0, IPL_NONE0x0, 0,
    "drmobjpl", NULL((void *)0));
}

if (drm_core_check_feature(dev, DRIVER_GEM)) {
ret = drm_gem_init(dev);
if (ret) {
	DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n")__drm_err("Cannot initialize graphics execution manager (GEM)\n"
);
	goto error;
}
}

drmm_add_final_kfree(dev, dev);

printf("\n");
return;

1437error:
drm_managed_release(dev);
dev->dev_private = NULL((void *)0);
1440}

1442int
1443drm_detach(struct device *self, int flags)
1444{
struct drm_softc *sc = (struct drm_softc *)self;
struct drm_device *dev = sc->sc_drm;

drm_refcnt--;
if (drm_refcnt == 0) {
drm_buddy_module_exit();
drm_core_exit();
drm_linux_exit();
}

drm_lastclose(dev);

if (drm_core_check_feature(dev, DRIVER_GEM)) {
if (dev->driver->gem_size > 0)
	pool_destroy(&dev->objpl);
}

1462#ifdef CONFIG_DRM_LEGACY
if (dev->agp && dev->agp->mtrr) {
int retcode;

retcode = drm_mtrr_del(0, dev->agp->info.ai_aperture_base,
    dev->agp->info.ai_aperture_size, DRM_MTRR_WC(1<<1));
DRM_DEBUG("mtrr_del = %d", retcode)___drm_dbg(((void *)0), DRM_UT_CORE, "mtrr_del = %d", retcode
);
}

free(dev->agp, M_DRM145, 0);
1472#endif
if (dev->pdev && dev->pdev->bus)
free(dev->pdev->bus->self, M_DRM145, sizeof(struct pci_dev));

if (sc->sc_allocated)
free(dev, M_DRM145, sizeof(struct drm_device));

return 0;
1480}

1482void
1483drm_quiesce(struct drm_device *dev)
1484{
mtx_enter(&dev->quiesce_mtx);
dev->quiesce = 1;
while (dev->quiesce_count > 0) {
msleep_nsec(&dev->quiesce_count, &dev->quiesce_mtx,
    PZERO22, "drmqui", INFSLP0xffffffffffffffffULL);
}
mtx_leave(&dev->quiesce_mtx);
1492}

1494void
1495drm_wakeup(struct drm_device *dev)
1496{
mtx_enter(&dev->quiesce_mtx);
dev->quiesce = 0;
wakeup(&dev->quiesce);
mtx_leave(&dev->quiesce_mtx);
1501}

1503int
1504drm_activate(struct device *self, int act)
1505{
struct drm_softc *sc = (struct drm_softc *)self;
struct drm_device *dev = sc->sc_drm;

switch (act) {
case DVACT_QUIESCE2:
drm_quiesce(dev);
break;
case DVACT_WAKEUP5:
drm_wakeup(dev);
break;
}

return (0);
1519}

1521const struct cfattach drm_ca = {
sizeof(struct drm_softc), drm_probe, drm_attach,
drm_detach, drm_activate
1524};

1526struct cfdriver drm_cd = {
0, "drm", DV_DULL
1528};

1530const struct pci_device_id *
1531drm_find_description(int vendor, int device, const struct pci_device_id *idlist)
1532{
int i = 0;

for (i = 0; idlist[i].vendor != 0; i++) {
if ((idlist[i].vendor == vendor) &&
    (idlist[i].device == device ||
     idlist[i].device == PCI_ANY_ID(uint16_t) (~0U)) &&
    (idlist[i].subvendor == PCI_ANY_ID(uint16_t) (~0U)) &&
    (idlist[i].subdevice == PCI_ANY_ID(uint16_t) (~0U)))
	return &idlist[i];
}
return NULL((void *)0);
1544}

1546int
1547drm_file_cmp(struct drm_file *f1, struct drm_file *f2)
1548{
return (f1->fminor < f2->fminor ? -1 : f1->fminor > f2->fminor);
1550}

1552SPLAY_GENERATE(drm_file_tree, drm_file, link, drm_file_cmp)struct drm_file * drm_file_tree_SPLAY_INSERT(struct drm_file_tree
 *head, struct drm_file *elm) { if (((head)->sph_root == (
(void *)0))) { (elm)->link.spe_left = (elm)->link.spe_right
 = ((void *)0); } else { int __comp; drm_file_tree_SPLAY(head
, elm); __comp = (drm_file_cmp)(elm, (head)->sph_root); if
(__comp < 0) { (elm)->link.spe_left = ((head)->sph_root
)->link.spe_left; (elm)->link.spe_right = (head)->sph_root
; ((head)->sph_root)->link.spe_left = ((void *)0); } else
 if (__comp > 0) { (elm)->link.spe_right = ((head)->
sph_root)->link.spe_right; (elm)->link.spe_left = (head
)->sph_root; ((head)->sph_root)->link.spe_right = ((
void *)0); } else return ((head)->sph_root); } (head)->
sph_root = (elm); return (((void *)0)); } struct drm_file * drm_file_tree_SPLAY_REMOVE
(struct drm_file_tree *head, struct drm_file *elm) { struct drm_file
 *__tmp; if (((head)->sph_root == ((void *)0))) return (((
void *)0)); drm_file_tree_SPLAY(head, elm); if ((drm_file_cmp
)(elm, (head)->sph_root) == 0) { if (((head)->sph_root)
->link.spe_left == ((void *)0)) { (head)->sph_root = ((
head)->sph_root)->link.spe_right; } else { __tmp = ((head
)->sph_root)->link.spe_right; (head)->sph_root = ((head
)->sph_root)->link.spe_left; drm_file_tree_SPLAY(head, elm
); ((head)->sph_root)->link.spe_right = __tmp; } return
 (elm); } return (((void *)0)); } void drm_file_tree_SPLAY(struct
 drm_file_tree *head, struct drm_file *elm) { struct drm_file
 __node, *__left, *__right, *__tmp; int __comp; (&__node)
->link.spe_left = (&__node)->link.spe_right = ((void
 *)0); __left = __right = &__node; while ((__comp = (drm_file_cmp
)(elm, (head)->sph_root))) { if (__comp < 0) { __tmp = (
(head)->sph_root)->link.spe_left; if (__tmp == ((void *
)0)) break; if ((drm_file_cmp)(elm, __tmp) < 0){ do { ((head
)->sph_root)->link.spe_left = (__tmp)->link.spe_right
; (__tmp)->link.spe_right = (head)->sph_root; (head)->
sph_root = __tmp; } while (0); if (((head)->sph_root)->
link.spe_left == ((void *)0)) break; } do { (__right)->link
.spe_left = (head)->sph_root; __right = (head)->sph_root
; (head)->sph_root = ((head)->sph_root)->link.spe_left
; } while (0); } else if (__comp > 0) { __tmp = ((head)->
sph_root)->link.spe_right; if (__tmp == ((void *)0)) break
; if ((drm_file_cmp)(elm, __tmp) > 0){ do { ((head)->sph_root
)->link.spe_right = (__tmp)->link.spe_left; (__tmp)->
link.spe_left = (head)->sph_root; (head)->sph_root = __tmp
; } while (0); if (((head)->sph_root)->link.spe_right ==
 ((void *)0)) break; } do { (__left)->link.spe_right = (head
)->sph_root; __left = (head)->sph_root; (head)->sph_root
 = ((head)->sph_root)->link.spe_right; } while (0); } }
 do { (__left)->link.spe_right = ((head)->sph_root)->
link.spe_left; (__right)->link.spe_left = ((head)->sph_root
)->link.spe_right; ((head)->sph_root)->link.spe_left
 = (&__node)->link.spe_right; ((head)->sph_root)->
link.spe_right = (&__node)->link.spe_left; } while (0)
; } void drm_file_tree_SPLAY_MINMAX(struct drm_file_tree *head
, int __comp) { struct drm_file __node, *__left, *__right, *__tmp
; (&__node)->link.spe_left = (&__node)->link.spe_right
 = ((void *)0); __left = __right = &__node; while (1) { if
 (__comp < 0) { __tmp = ((head)->sph_root)->link.spe_left
; if (__tmp == ((void *)0)) break; if (__comp < 0){ do { (
(head)->sph_root)->link.spe_left = (__tmp)->link.spe_right
; (__tmp)->link.spe_right = (head)->sph_root; (head)->
sph_root = __tmp; } while (0); if (((head)->sph_root)->
link.spe_left == ((void *)0)) break; } do { (__right)->link
.spe_left = (head)->sph_root; __right = (head)->sph_root
; (head)->sph_root = ((head)->sph_root)->link.spe_left
; } while (0); } else if (__comp > 0) { __tmp = ((head)->
sph_root)->link.spe_right; if (__tmp == ((void *)0)) break
; if (__comp > 0) { do { ((head)->sph_root)->link.spe_right
 = (__tmp)->link.spe_left; (__tmp)->link.spe_left = (head
)->sph_root; (head)->sph_root = __tmp; } while (0); if (
((head)->sph_root)->link.spe_right == ((void *)0)) break
; } do { (__left)->link.spe_right = (head)->sph_root; __left
 = (head)->sph_root; (head)->sph_root = ((head)->sph_root
)->link.spe_right; } while (0); } } do { (__left)->link
.spe_right = ((head)->sph_root)->link.spe_left; (__right
)->link.spe_left = ((head)->sph_root)->link.spe_right
; ((head)->sph_root)->link.spe_left = (&__node)->
link.spe_right; ((head)->sph_root)->link.spe_right = (&
__node)->link.spe_left; } while (0); };

1554struct drm_file *
1555drm_find_file_by_minor(struct drm_device *dev, int minor)
1556{
struct drm_file	key;

key.fminor = minor;
return (SPLAY_FIND(drm_file_tree, &dev->files, &key)drm_file_tree_SPLAY_FIND(&dev->files, &key));
1561}

1563struct drm_device *
1564drm_get_device_from_kdev(dev_t kdev)
1565{
int unit = minor(kdev)((unsigned)((kdev) & 0xff) | (((kdev) & 0xffff0000) >>
 8)) & ((1 << CLONE_SHIFT8) - 1);
/* render */
if (unit >= 128)
unit -= 128;
struct drm_softc *sc;

if (unit < drm_cd.cd_ndevs) {
sc = (struct drm_softc *)drm_cd.cd_devs[unit];
if (sc)
	return sc->sc_drm;
}

return NULL((void *)0);
1579}

1581void
1582filt_drmdetach(struct knote *kn)
1583{
struct drm_device *dev = kn->kn_hook;
int s;

s = spltty()splraise(0x9);
klist_remove_locked(&dev->note, kn);
splx(s)spllower(s);
1590}

1592int
1593filt_drmkms(struct knote *kn, long hint)
1594{
if (kn->kn_sfflags & hint)
kn->kn_fflagskn_kevent.fflags |= hint;
return (kn->kn_fflagskn_kevent.fflags != 0);
1598}

1600void
1601filt_drmreaddetach(struct knote *kn)
1602{
struct drm_file		*file_priv = kn->kn_hook;
int s;

s = spltty()splraise(0x9);
klist_remove_locked(&file_priv->rsel.si_note, kn);
splx(s)spllower(s);
1609}

1611int
1612filt_drmread(struct knote *kn, long hint)
1613{
struct drm_file		*file_priv = kn->kn_hook;
int			 val = 0;

if ((hint & NOTE_SUBMIT0x01000000) == 0)
mtx_enter(&file_priv->minor->dev->event_lock);
val = !list_empty(&file_priv->event_list);
if ((hint & NOTE_SUBMIT0x01000000) == 0)
mtx_leave(&file_priv->minor->dev->event_lock);
return (val);
1623}

1625const struct filterops drm_filtops = {
.f_flags	= FILTEROP_ISFD0x00000001,
.f_attach	= NULL((void *)0),
.f_detach	= filt_drmdetach,
.f_event	= filt_drmkms,
1630};

1632const struct filterops drmread_filtops = {
.f_flags	= FILTEROP_ISFD0x00000001,
.f_attach	= NULL((void *)0),
.f_detach	= filt_drmreaddetach,
.f_event	= filt_drmread,
1637};

1639int
1640drmkqfilter(dev_t kdev, struct knote *kn)
1641{
struct drm_device	*dev = NULL((void *)0);
struct drm_file		*file_priv = NULL((void *)0);
int			 s;

dev = drm_get_device_from_kdev(kdev);
if (dev == NULL((void *)0) || dev->dev_private == NULL((void *)0))
return (ENXIO6);

switch (kn->kn_filterkn_kevent.filter) {
case EVFILT_READ(-1):
mutex_lock(&dev->struct_mutex)rw_enter_write(&dev->struct_mutex);
file_priv = drm_find_file_by_minor(dev, minor(kdev)((unsigned)((kdev) & 0xff) | (((kdev) & 0xffff0000) >>
 8)));
mutex_unlock(&dev->struct_mutex)rw_exit_write(&dev->struct_mutex);
if (file_priv == NULL((void *)0))
	return (ENXIO6);

kn->kn_fop = &drmread_filtops;
kn->kn_hook = file_priv;

s = spltty()splraise(0x9);
klist_insert_locked(&file_priv->rsel.si_note, kn);
splx(s)spllower(s);
break;
case EVFILT_DEVICE(-8):
kn->kn_fop = &drm_filtops;
kn->kn_hook = dev;

s = spltty()splraise(0x9);
klist_insert_locked(&dev->note, kn);
splx(s)spllower(s);
break;
default:
return (EINVAL22);
}

return (0);
1678}

1680int
1681drmopen(dev_t kdev, int flags, int fmt, struct proc *p)
1682{
struct drm_device	*dev = NULL((void *)0);
struct drm_file		*file_priv;
struct drm_minor	*dm;
int			 ret = 0;
int			 dminor, realminor, minor_type;
int need_setup = 0;

dev = drm_get_device_from_kdev(kdev);
if (dev == NULL((void *)0) || dev->dev_private == NULL((void *)0))
return (ENXIO6);

DRM_DEBUG("open_count = %d\n", atomic_read(&dev->open_count))___drm_dbg(((void *)0), DRM_UT_CORE, "open_count = %d\n", ({ typeof
(*(&dev->open_count)) __tmp = *(volatile typeof(*(&
dev->open_count)) *)&(*(&dev->open_count)); membar_datadep_consumer
(); __tmp; }));

if (flags & O_EXCL0x0800)
return (EBUSY16); /* No exclusive opens */

if (drm_dev_needs_global_mutex(dev))
mutex_lock(&drm_global_mutex)rw_enter_write(&drm_global_mutex);

if (!atomic_fetch_inc(&dev->open_count)__sync_fetch_and_add(&dev->open_count, 1))
need_setup = 1;

dminor = minor(kdev)((unsigned)((kdev) & 0xff) | (((kdev) & 0xffff0000) >>
 8));
realminor =  dminor & ((1 << CLONE_SHIFT8) - 1);
if (realminor < 64)
minor_type = DRM_MINOR_PRIMARY;
else if (realminor >= 128 && realminor < 192)
minor_type = DRM_MINOR_RENDER;
else {
ret = ENXIO6;
goto err;
}

dm = *drm_minor_get_slot(dev, minor_type);
if (dm == NULL((void *)0)) {
ret = ENXIO6;
goto err;
}
dm->index = minor(kdev)((unsigned)((kdev) & 0xff) | (((kdev) & 0xffff0000) >>
 8));

file_priv = drm_file_alloc(dm);
if (IS_ERR(file_priv)) {
ret = ENOMEM12;
goto err;
}

/* first opener automatically becomes master */
if (drm_is_primary_client(file_priv)) {
ret = drm_master_open(file_priv);
if (ret != 0)
	goto out_file_free;
}

file_priv->filp = (void *)file_priv;
file_priv->fminor = minor(kdev)((unsigned)((kdev) & 0xff) | (((kdev) & 0xffff0000) >>
 8));

mutex_lock(&dev->filelist_mutex)rw_enter_write(&dev->filelist_mutex);
SPLAY_INSERT(drm_file_tree, &dev->files, file_priv)drm_file_tree_SPLAY_INSERT(&dev->files, file_priv);
mutex_unlock(&dev->filelist_mutex)rw_exit_write(&dev->filelist_mutex);

if (need_setup) {
ret = drm_legacy_setup(dev);
if (ret)
	goto out_file_free;
}

if (drm_dev_needs_global_mutex(dev))
mutex_unlock(&drm_global_mutex)rw_exit_write(&drm_global_mutex);

return 0;

1754out_file_free:
drm_file_free(file_priv);
1756err:
atomic_dec(&dev->open_count)__sync_fetch_and_sub(&dev->open_count, 1);
if (drm_dev_needs_global_mutex(dev))
mutex_unlock(&drm_global_mutex)rw_exit_write(&drm_global_mutex);
return (ret);
1761}

1763int
1764drmclose(dev_t kdev, int flags, int fmt, struct proc *p)
1765{
struct drm_device		*dev = drm_get_device_from_kdev(kdev);
struct drm_file			*file_priv;
int				 retcode = 0;

if (dev == NULL((void *)0))
return (ENXIO6);

if (drm_dev_needs_global_mutex(dev))
mutex_lock(&drm_global_mutex)rw_enter_write(&drm_global_mutex);

DRM_DEBUG("open_count = %d\n", atomic_read(&dev->open_count))___drm_dbg(((void *)0), DRM_UT_CORE, "open_count = %d\n", ({ typeof
(*(&dev->open_count)) __tmp = *(volatile typeof(*(&
dev->open_count)) *)&(*(&dev->open_count)); membar_datadep_consumer
(); __tmp; }));

mutex_lock(&dev->filelist_mutex)rw_enter_write(&dev->filelist_mutex);
file_priv = drm_find_file_by_minor(dev, minor(kdev)((unsigned)((kdev) & 0xff) | (((kdev) & 0xffff0000) >>
 8)));
if (file_priv == NULL((void *)0)) {
DRM_ERROR("can't find authenticator\n")__drm_err("can't find authenticator\n");
retcode = EINVAL22;
mutex_unlock(&dev->filelist_mutex)rw_exit_write(&dev->filelist_mutex);
goto done;
}

SPLAY_REMOVE(drm_file_tree, &dev->files, file_priv)drm_file_tree_SPLAY_REMOVE(&dev->files, file_priv);
mutex_unlock(&dev->filelist_mutex)rw_exit_write(&dev->filelist_mutex);
drm_file_free(file_priv);
1790done:
if (atomic_dec_and_test(&dev->open_count)(__sync_sub_and_fetch((&dev->open_count), 1) == 0))
drm_lastclose(dev);

if (drm_dev_needs_global_mutex(dev))
mutex_unlock(&drm_global_mutex)rw_exit_write(&drm_global_mutex);

return (retcode);
1798}

1800int
1801drmread(dev_t kdev, struct uio *uio, int ioflag)
1802{
struct drm_device		*dev = drm_get_device_from_kdev(kdev);
struct drm_file			*file_priv;
struct drm_pending_event	*ev;
int		 		 error = 0;

if (dev == NULL((void *)0))
return (ENXIO6);

mutex_lock(&dev->filelist_mutex)rw_enter_write(&dev->filelist_mutex);
file_priv = drm_find_file_by_minor(dev, minor(kdev)((unsigned)((kdev) & 0xff) | (((kdev) & 0xffff0000) >>
 8)));
mutex_unlock(&dev->filelist_mutex)rw_exit_write(&dev->filelist_mutex);
if (file_priv == NULL((void *)0))
return (ENXIO6);

/*
* The semantics are a little weird here. We will wait until we
* have events to process, but as soon as we have events we will
* only deliver as many as we have.
* Note that events are atomic, if the read buffer will not fit in
* a whole event, we won't read any of it out.
*/
mtx_enter(&dev->event_lock);
while (error == 0 && list_empty(&file_priv->event_list)) {
if (ioflag & IO_NDELAY0x10) {
	mtx_leave(&dev->event_lock);
	return (EAGAIN35);
}
error = msleep_nsec(&file_priv->event_wait, &dev->event_lock,
    PWAIT32 | PCATCH0x100, "drmread", INFSLP0xffffffffffffffffULL);
}
if (error) {
mtx_leave(&dev->event_lock);
return (error);
}
while (drm_dequeue_event(dev, file_priv, uio->uio_resid, &ev)) {
MUTEX_ASSERT_UNLOCKED(&dev->event_lock)do { if (((&dev->event_lock)->mtx_owner == ({struct
 cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci
) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;
})) && !(panicstr || db_active)) panic("mutex %p held in %s"
, (&dev->event_lock), __func__); } while (0);
/* XXX we always destroy the event on error. */
error = uiomove(ev->event, ev->event->length, uio);
kfree(ev);
if (error)
	break;
mtx_enter(&dev->event_lock);
}
MUTEX_ASSERT_UNLOCKED(&dev->event_lock)do { if (((&dev->event_lock)->mtx_owner == ({struct
 cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci
) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;
})) && !(panicstr || db_active)) panic("mutex %p held in %s"
, (&dev->event_lock), __func__); } while (0);

return (error);
1849}

1851/*
* Deqeue an event from the file priv in question. returning 1 if an
* event was found. We take the resid from the read as a parameter because
* we will only dequeue and event if the read buffer has space to fit the
* entire thing.
*
* We are called locked, but we will *unlock* the queue on return so that
* we may sleep to copyout the event.
*/
1860int
1861drm_dequeue_event(struct drm_device *dev, struct drm_file *file_priv,
  size_t resid, struct drm_pending_event **out)
1863{
struct drm_pending_event *e = NULL((void *)0);
int gotone = 0;

MUTEX_ASSERT_LOCKED(&dev->event_lock)do { if (((&dev->event_lock)->mtx_owner != ({struct
 cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci
) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;
})) && !(panicstr || db_active)) panic("mutex %p not held in %s"
, (&dev->event_lock), __func__); } while (0);

*out = NULL((void *)0);
if (list_empty(&file_priv->event_list))
goto out;
e = list_first_entry(&file_priv->event_list,({ const __typeof( ((struct drm_pending_event *)0)->link )
 *__mptr = ((&file_priv->event_list)->next); (struct
 drm_pending_event *)( (char *)__mptr - __builtin_offsetof(struct
 drm_pending_event, link) );})
	     struct drm_pending_event, link)({ const __typeof( ((struct drm_pending_event *)0)->link )
 *__mptr = ((&file_priv->event_list)->next); (struct
 drm_pending_event *)( (char *)__mptr - __builtin_offsetof(struct
 drm_pending_event, link) );});
if (e->event->length > resid)
goto out;

file_priv->event_space += e->event->length;
list_del(&e->link);
*out = e;
gotone = 1;

1882out:
mtx_leave(&dev->event_lock);

return (gotone);
1886}

1888paddr_t
1889drmmmap(dev_t kdev, off_t offset, int prot)
1890{
return -1;
1892}

1894struct drm_dmamem *
1895drm_dmamem_alloc(bus_dma_tag_t dmat, bus_size_t size, bus_size_t alignment,
  int nsegments, bus_size_t maxsegsz, int mapflags, int loadflags)
1897{
struct drm_dmamem	*mem;
size_t			 strsize;
/*
* segs is the last member of the struct since we modify the size 
* to allow extra segments if more than one are allowed.
*/
strsize = sizeof(*mem) + (sizeof(bus_dma_segment_t) * (nsegments - 1));
mem = malloc(strsize, M_DRM145, M_NOWAIT0x0002 | M_ZERO0x0008);
if (mem == NULL((void *)0))
return (NULL((void *)0));

mem->size = size;

if (bus_dmamap_create(dmat, size, nsegments, maxsegsz, 0,(*(dmat)->_dmamap_create)((dmat), (size), (nsegments), (maxsegsz
), (0), (0x0001 | 0x0002), (&mem->map))
   BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &mem->map)(*(dmat)->_dmamap_create)((dmat), (size), (nsegments), (maxsegsz
), (0), (0x0001 | 0x0002), (&mem->map)) != 0)
goto strfree;

if (bus_dmamem_alloc(dmat, size, alignment, 0, mem->segs, nsegments,(*(dmat)->_dmamem_alloc)((dmat), (size), (alignment), (0),
 (mem->segs), (nsegments), (&mem->nsegs), (0x0001 |
 0x1000))
   &mem->nsegs, BUS_DMA_NOWAIT | BUS_DMA_ZERO)(*(dmat)->_dmamem_alloc)((dmat), (size), (alignment), (0),
 (mem->segs), (nsegments), (&mem->nsegs), (0x0001 |
 0x1000)) != 0)
goto destroy;

if (bus_dmamem_map(dmat, mem->segs, mem->nsegs, size,(*(dmat)->_dmamem_map)((dmat), (mem->segs), (mem->nsegs
), (size), (&mem->kva), (0x0001 | mapflags)) 
   &mem->kva, BUS_DMA_NOWAIT | mapflags)(*(dmat)->_dmamem_map)((dmat), (mem->segs), (mem->nsegs
), (size), (&mem->kva), (0x0001 | mapflags)) != 0)
goto free;

if (bus_dmamap_load(dmat, mem->map, mem->kva, size,(*(dmat)->_dmamap_load)((dmat), (mem->map), (mem->kva
), (size), (((void *)0)), (0x0001 | loadflags))
   NULL, BUS_DMA_NOWAIT | loadflags)(*(dmat)->_dmamap_load)((dmat), (mem->map), (mem->kva
), (size), (((void *)0)), (0x0001 | loadflags)) != 0)
goto unmap;

return (mem);

1929unmap:
bus_dmamem_unmap(dmat, mem->kva, size)(*(dmat)->_dmamem_unmap)((dmat), (mem->kva), (size));
1931free:
bus_dmamem_free(dmat, mem->segs, mem->nsegs)(*(dmat)->_dmamem_free)((dmat), (mem->segs), (mem->nsegs
));
1933destroy:
bus_dmamap_destroy(dmat, mem->map)(*(dmat)->_dmamap_destroy)((dmat), (mem->map));
1935strfree:
free(mem, M_DRM145, 0);

return (NULL((void *)0));
1939}

1941void
1942drm_dmamem_free(bus_dma_tag_t dmat, struct drm_dmamem *mem)
1943{
if (mem == NULL((void *)0))
return;

bus_dmamap_unload(dmat, mem->map)(*(dmat)->_dmamap_unload)((dmat), (mem->map));
bus_dmamem_unmap(dmat, mem->kva, mem->size)(*(dmat)->_dmamem_unmap)((dmat), (mem->kva), (mem->size
));
bus_dmamem_free(dmat, mem->segs, mem->nsegs)(*(dmat)->_dmamem_free)((dmat), (mem->segs), (mem->nsegs
));
bus_dmamap_destroy(dmat, mem->map)(*(dmat)->_dmamap_destroy)((dmat), (mem->map));
free(mem, M_DRM145, 0);
1952}

1954struct drm_dma_handle *
1955drm_pci_alloc(struct drm_device *dev, size_t size, size_t align)
1956{
struct drm_dma_handle *dmah;

dmah = malloc(sizeof(*dmah), M_DRM145, M_WAITOK0x0001);
dmah->mem = drm_dmamem_alloc(dev->dmat, size, align, 1, size,
   BUS_DMA_NOCACHE0x0800, 0);
if (dmah->mem == NULL((void *)0)) {
free(dmah, M_DRM145, sizeof(*dmah));
return NULL((void *)0);
}
dmah->busaddr = dmah->mem->segs[0].ds_addr;
dmah->size = dmah->mem->size;
dmah->vaddr = dmah->mem->kva;
return (dmah);
1970}

1972void
1973drm_pci_free(struct drm_device *dev, struct drm_dma_handle *dmah)
1974{
if (dmah == NULL((void *)0))
return;

drm_dmamem_free(dev->dmat, dmah->mem);
free(dmah, M_DRM145, sizeof(*dmah));
1980}

1982/*
* Compute order.  Can be made faster.
*/
1985int
1986drm_order(unsigned long size)
1987{
int order;
unsigned long tmp;

for (order = 0, tmp = size; tmp >>= 1; ++order)
;

if (size & ~(1 << order))
++order;

return order;
1998}

2000int
2001drm_getpciinfo(struct drm_device *dev, void *data, struct drm_file *file_priv)
2002{
struct drm_pciinfo *info = data;

if (dev->pdev == NULL((void *)0))
return -ENOTTY25;

info->domain = dev->pdev->bus->domain_nr;
info->bus = dev->pdev->bus->number;
info->dev = PCI_SLOT(dev->pdev->devfn)((dev->pdev->devfn) >> 3);
info->func = PCI_FUNC(dev->pdev->devfn)((dev->pdev->devfn) & 0x7);
info->vendor_id = dev->pdev->vendor;
info->device_id = dev->pdev->device;
info->subvendor_id = dev->pdev->subsystem_vendor;
info->subdevice_id = dev->pdev->subsystem_device;
info->revision_id = 0;

return 0;
2019}

←

/usr/src/sys/dev/pci/drm/include/drm/drm_drv.h

1/*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* Copyright (c) 2009-2010, Code Aurora Forum.
* Copyright 2016 Intel Corp.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/

27#ifndef _DRM_DRV_H_
28#define _DRM_DRV_H_

30#include <linux/list.h>
31#include <linux/irqreturn.h>

33#include <drm/drm_device.h>

35#include <uvm/uvm_extern.h>

37struct drm_file;
38struct drm_gem_object;
39struct drm_master;
40struct drm_minor;
41struct dma_buf;
42struct dma_buf_attachment;
43struct drm_display_mode;
44struct drm_mode_create_dumb;
45struct drm_printer;
46struct sg_table;

48/**
* enum drm_driver_feature - feature flags
*
* See &drm_driver.driver_features, drm_device.driver_features and
* drm_core_check_feature().
*/
54enum drm_driver_feature {
/**
* @DRIVER_GEM:
*
* Driver use the GEM memory manager. This should be set for all modern
* drivers.
*/
DRIVER_GEM			= BIT(0)(1UL << (0)),
/**
* @DRIVER_MODESET:
*
* Driver supports mode setting interfaces (KMS).
*/
DRIVER_MODESET			= BIT(1)(1UL << (1)),
/**
* @DRIVER_RENDER:
*
* Driver supports dedicated render nodes. See also the :ref:`section on
* render nodes <drm_render_node>` for details.
*/
DRIVER_RENDER			= BIT(3)(1UL << (3)),
/**
* @DRIVER_ATOMIC:
*
* Driver supports the full atomic modesetting userspace API. Drivers
* which only use atomic internally, but do not support the full
* userspace API (e.g. not all properties converted to atomic, or
* multi-plane updates are not guaranteed to be tear-free) should not
* set this flag.
*/
DRIVER_ATOMIC			= BIT(4)(1UL << (4)),
/**
* @DRIVER_SYNCOBJ:
*
* Driver supports &drm_syncobj for explicit synchronization of command
* submission.
*/
DRIVER_SYNCOBJ                  = BIT(5)(1UL << (5)),
/**
* @DRIVER_SYNCOBJ_TIMELINE:
*
* Driver supports the timeline flavor of &drm_syncobj for explicit
* synchronization of command submission.
*/
DRIVER_SYNCOBJ_TIMELINE         = BIT(6)(1UL << (6)),

/* IMPORTANT: Below are all the legacy flags, add new ones above. */

/**
* @DRIVER_USE_AGP:
*
* Set up DRM AGP support, see drm_agp_init(), the DRM core will manage
* AGP resources. New drivers don't need this.
*/
DRIVER_USE_AGP			= BIT(25)(1UL << (25)),
/**
* @DRIVER_LEGACY:
*
* Denote a legacy driver using shadow attach. Do not use.
*/
DRIVER_LEGACY			= BIT(26)(1UL << (26)),
/**
* @DRIVER_PCI_DMA:
*
* Driver is capable of PCI DMA, mapping of PCI DMA buffers to userspace
* will be enabled. Only for legacy drivers. Do not use.
*/
DRIVER_PCI_DMA			= BIT(27)(1UL << (27)),
/**
* @DRIVER_SG:
*
* Driver can perform scatter/gather DMA, allocation and mapping of
* scatter/gather buffers will be enabled. Only for legacy drivers. Do
* not use.
*/
DRIVER_SG			= BIT(28)(1UL << (28)),

/**
* @DRIVER_HAVE_DMA:
*
* Driver supports DMA, the userspace DMA API will be supported. Only
* for legacy drivers. Do not use.
*/
DRIVER_HAVE_DMA			= BIT(29)(1UL << (29)),
/**
* @DRIVER_HAVE_IRQ:
*
* Legacy irq support. Only for legacy drivers. Do not use.
*/
DRIVER_HAVE_IRQ			= BIT(30)(1UL << (30)),
/**
* @DRIVER_KMS_LEGACY_CONTEXT:
*
* Used only by nouveau for backwards compatibility with existing
* userspace.  Do not use.
*/
DRIVER_KMS_LEGACY_CONTEXT	= BIT(31)(1UL << (31)),
151};

153/**
* struct drm_driver - DRM driver structure
*
* This structure represent the common code for a family of cards. There will be
* one &struct drm_device for each card present in this family. It contains lots
* of vfunc entries, and a pile of those probably should be moved to more
* appropriate places like &drm_mode_config_funcs or into a new operations
* structure for GEM drivers.
*/
162struct drm_driver {
/**
* @load:
*
* Backward-compatible driver callback to complete initialization steps
* after the driver is registered.  For this reason, may suffer from
* race conditions and its use is deprecated for new drivers.  It is
* therefore only supported for existing drivers not yet converted to
* the new scheme.  See devm_drm_dev_alloc() and drm_dev_register() for
* proper and race-free way to set up a &struct drm_device.
*
* This is deprecated, do not use!
*
* Returns:
*
* Zero on success, non-zero value on failure.
*/
int (*load) (struct drm_device *, unsigned long flags);

/**
* @open:
*
* Driver callback when a new &struct drm_file is opened. Useful for
* setting up driver-private data structures like buffer allocators,
* execution contexts or similar things. Such driver-private resources
* must be released again in @postclose.
*
* Since the display/modeset side of DRM can only be owned by exactly
* one &struct drm_file (see &drm_file.is_master and &drm_device.master)
* there should never be a need to set up any modeset related resources
* in this callback. Doing so would be a driver design bug.
*
* Returns:
*
* 0 on success, a negative error code on failure, which will be
* promoted to userspace as the result of the open() system call.
*/
int (*open) (struct drm_device *, struct drm_file *);

/**
* @postclose:
*
* One of the driver callbacks when a new &struct drm_file is closed.
* Useful for tearing down driver-private data structures allocated in
* @open like buffer allocators, execution contexts or similar things.
*
* Since the display/modeset side of DRM can only be owned by exactly
* one &struct drm_file (see &drm_file.is_master and &drm_device.master)
* there should never be a need to tear down any modeset related
* resources in this callback. Doing so would be a driver design bug.
*/
void (*postclose) (struct drm_device *, struct drm_file *);

/**
* @lastclose:
*
* Called when the last &struct drm_file has been closed and there's
* currently no userspace client for the &struct drm_device.
*
* Modern drivers should only use this to force-restore the fbdev
* framebuffer using drm_fb_helper_restore_fbdev_mode_unlocked().
* Anything else would indicate there's something seriously wrong.
* Modern drivers can also use this to execute delayed power switching
* state changes, e.g. in conjunction with the :ref:`vga_switcheroo`
* infrastructure.
*
* This is called after @postclose hook has been called.
*
* NOTE:
*
* All legacy drivers use this callback to de-initialize the hardware.
* This is purely because of the shadow-attach model, where the DRM
* kernel driver does not really own the hardware. Instead ownershipe is
* handled with the help of userspace through an inheritedly racy dance
* to set/unset the VT into raw mode.
*
* Legacy drivers initialize the hardware in the @firstopen callback,
* which isn't even called for modern drivers.
*/
void (*lastclose) (struct drm_device *);

/**
* @unload:
*
* Reverse the effects of the driver load callback.  Ideally,
* the clean up performed by the driver should happen in the
* reverse order of the initialization.  Similarly to the load
* hook, this handler is deprecated and its usage should be
* dropped in favor of an open-coded teardown function at the
* driver layer.  See drm_dev_unregister() and drm_dev_put()
* for the proper way to remove a &struct drm_device.
*
* The unload() hook is called right after unregistering
* the device.
*
*/
void (*unload) (struct drm_device *);

/**
* @release:
*
* Optional callback for destroying device data after the final
* reference is released, i.e. the device is being destroyed.
*
* This is deprecated, clean up all memory allocations associated with a
* &drm_device using drmm_add_action(), drmm_kmalloc() and related
* managed resources functions.
*/
void (*release) (struct drm_device *);

/**
* @master_set:
*
* Called whenever the minor master is set. Only used by vmwgfx.
*/
void (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
	   bool_Bool from_open);
/**
* @master_drop:
*
* Called whenever the minor master is dropped. Only used by vmwgfx.
*/
void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv);

/**
* @debugfs_init:
*
* Allows drivers to create driver-specific debugfs files.
*/
void (*debugfs_init)(struct drm_minor *minor);

/**
* @gem_create_object: constructor for gem objects
*
* Hook for allocating the GEM object struct, for use by the CMA
* and SHMEM GEM helpers. Returns a GEM object on success, or an
* ERR_PTR()-encoded error code otherwise.
*/
struct drm_gem_object *(*gem_create_object)(struct drm_device *dev,
				    size_t size);

/**
* @prime_handle_to_fd:
*
* Main PRIME export function. Should be implemented with
* drm_gem_prime_handle_to_fd() for GEM based drivers.
*
* For an in-depth discussion see :ref:`PRIME buffer sharing
* documentation <prime_buffer_sharing>`.
*/
int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
		uint32_t handle, uint32_t flags, int *prime_fd);
/**
* @prime_fd_to_handle:
*
* Main PRIME import function. Should be implemented with
* drm_gem_prime_fd_to_handle() for GEM based drivers.
*
* For an in-depth discussion see :ref:`PRIME buffer sharing
* documentation <prime_buffer_sharing>`.
*/
int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
		int prime_fd, uint32_t *handle);

/**
* @gem_prime_import:
*
* Import hook for GEM drivers.
*
* This defaults to drm_gem_prime_import() if not set.
*/
struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
		struct dma_buf *dma_buf);
/**
* @gem_prime_import_sg_table:
*
* Optional hook used by the PRIME helper functions
* drm_gem_prime_import() respectively drm_gem_prime_import_dev().
*/
struct drm_gem_object *(*gem_prime_import_sg_table)(
		struct drm_device *dev,
		struct dma_buf_attachment *attach,
		struct sg_table *sgt);
/**
* @gem_prime_mmap:
*
* mmap hook for GEM drivers, used to implement dma-buf mmap in the
* PRIME helpers.
*
* This hook only exists for historical reasons. Drivers must use
* drm_gem_prime_mmap() to implement it.
*
* FIXME: Convert all drivers to implement mmap in struct
* &drm_gem_object_funcs and inline drm_gem_prime_mmap() into
* its callers. This hook should be removed afterwards.
*/
358#ifdef __linux__
int (*gem_prime_mmap)(struct drm_gem_object *obj, struct vm_area_struct *vma);
360#else
struct uvm_object *(*gem_prime_mmap)(struct file *, vm_prot_t, voff_t, vsize_t);
362#endif

364#ifdef __OpenBSD__1
struct uvm_object *(*mmap)(struct file *, vm_prot_t, voff_t, vsize_t);
size_t gem_size;
367#endif

/**
* @dumb_create:
*
* This creates a new dumb buffer in the driver's backing storage manager (GEM,
* TTM or something else entirely) and returns the resulting buffer handle. This
* handle can then be wrapped up into a framebuffer modeset object.
*
* Note that userspace is not allowed to use such objects for render
* acceleration - drivers must create their own private ioctls for such a use
* case.
*
* Width, height and depth are specified in the &drm_mode_create_dumb
* argument. The callback needs to fill the handle, pitch and size for
* the created buffer.
*
* Called by the user via ioctl.
*
* Returns:
*
* Zero on success, negative errno on failure.
*/
int (*dumb_create)(struct drm_file *file_priv,
	   struct drm_device *dev,
	   struct drm_mode_create_dumb *args);
/**
* @dumb_map_offset:
*
* Allocate an offset in the drm device node's address space to be able to
* memory map a dumb buffer.
*
* The default implementation is drm_gem_create_mmap_offset(). GEM based
* drivers must not overwrite this.
*
* Called by the user via ioctl.
*
* Returns:
*
* Zero on success, negative errno on failure.
*/
int (*dumb_map_offset)(struct drm_file *file_priv,
	       struct drm_device *dev, uint32_t handle,
	       uint64_t *offset);
/**
* @dumb_destroy:
*
* This destroys the userspace handle for the given dumb backing storage buffer.
* Since buffer objects must be reference counted in the kernel a buffer object
* won't be immediately freed if a framebuffer modeset object still uses it.
*
* Called by the user via ioctl.
*
* The default implementation is drm_gem_dumb_destroy(). GEM based drivers
* must not overwrite this.
*
* Returns:
*
* Zero on success, negative errno on failure.
*/
int (*dumb_destroy)(struct drm_file *file_priv,
	    struct drm_device *dev,
	    uint32_t handle);

431#ifdef __OpenBSD__1
int (*gem_fault)(struct drm_gem_object *,
	 struct uvm_faultinfo *, off_t, vaddr_t,
	 vm_page_t *, int, int, vm_prot_t, int);
435#endif

/** @major: driver major number */
int major;
/** @minor: driver minor number */
int minor;
/** @patchlevel: driver patch level */
int patchlevel;
/** @name: driver name */
char *name;
/** @desc: driver description */
char *desc;
/** @date: driver date */
char *date;

/**
* @driver_features:
* Driver features, see &enum drm_driver_feature. Drivers can disable
* some features on a per-instance basis using
* &drm_device.driver_features.
*/
u32 driver_features;

/**
* @ioctls:
*
* Array of driver-private IOCTL description entries. See the chapter on
* :ref:`IOCTL support in the userland interfaces
* chapter<drm_driver_ioctl>` for the full details.
*/

const struct drm_ioctl_desc *ioctls;
/** @num_ioctls: Number of entries in @ioctls. */
int num_ioctls;

/**
* @fops:
*
* File operations for the DRM device node. See the discussion in
* :ref:`file operations<drm_driver_fops>` for in-depth coverage and
* some examples.
*/
const struct file_operations *fops;

479#ifdef CONFIG_DRM_LEGACY
/* Everything below here is for legacy driver, never use! */
/* private: */

int (*firstopen) (struct drm_device *);
void (*preclose) (struct drm_device *, struct drm_file *file_priv);
int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
int (*dma_quiescent) (struct drm_device *);
int (*context_dtor) (struct drm_device *dev, int context);
irqreturn_t (*irq_handler)(int irq, void *arg);
void (*irq_preinstall)(struct drm_device *dev);
int (*irq_postinstall)(struct drm_device *dev);
void (*irq_uninstall)(struct drm_device *dev);
u32 (*get_vblank_counter)(struct drm_device *dev, unsigned int pipe);
int (*enable_vblank)(struct drm_device *dev, unsigned int pipe);
void (*disable_vblank)(struct drm_device *dev, unsigned int pipe);
int dev_priv_size;
496#endif
497};

499void *__devm_drm_dev_alloc(struct device *parent,
	   const struct drm_driver *driver,
	   size_t size, size_t offset);

503/**
* devm_drm_dev_alloc - Resource managed allocation of a &drm_device instance
* @parent: Parent device object
* @driver: DRM driver
* @type: the type of the struct which contains struct &drm_device
* @member: the name of the &drm_device within @type.
*
* This allocates and initialize a new DRM device. No device registration is done.
* Call drm_dev_register() to advertice the device to user space and register it
* with other core subsystems. This should be done last in the device
* initialization sequence to make sure userspace can't access an inconsistent
* state.
*
* The initial ref-count of the object is 1. Use drm_dev_get() and
* drm_dev_put() to take and drop further ref-counts.
*
* It is recommended that drivers embed &struct drm_device into their own device
* structure.
*
* Note that this manages the lifetime of the resulting &drm_device
* automatically using devres. The DRM device initialized with this function is
* automatically put on driver detach using drm_dev_put().
*
* RETURNS:
* Pointer to new DRM device, or ERR_PTR on failure.
*/
529#define devm_drm_dev_alloc(parent, driver, type, member)((type *) __devm_drm_dev_alloc(parent, driver, sizeof(type), __builtin_offsetof
(type, member))) \
((type *) __devm_drm_dev_alloc(parent, driver, sizeof(type), \
		       offsetof(type, member)__builtin_offsetof(type, member)))

533struct drm_device *drm_dev_alloc(const struct drm_driver *driver,
		 struct device *parent);
535int drm_dev_register(struct drm_device *dev, unsigned long flags);
536void drm_dev_unregister(struct drm_device *dev);

538void drm_dev_get(struct drm_device *dev);
539void drm_dev_put(struct drm_device *dev);
540void drm_put_dev(struct drm_device *dev);
541bool_Bool drm_dev_enter(struct drm_device *dev, int *idx);
542void drm_dev_exit(int idx);
543void drm_dev_unplug(struct drm_device *dev);

545/**
* drm_dev_is_unplugged - is a DRM device unplugged
* @dev: DRM device
*
* This function can be called to check whether a hotpluggable is unplugged.
* Unplugging itself is singalled through drm_dev_unplug(). If a device is
* unplugged, these two functions guarantee that any store before calling
* drm_dev_unplug() is visible to callers of this function after it completes
*
* WARNING: This function fundamentally races against drm_dev_unplug(). It is
* recommended that drivers instead use the underlying drm_dev_enter() and
* drm_dev_exit() function pairs.
*/
558static inline bool_Bool drm_dev_is_unplugged(struct drm_device *dev)
559{
int idx;
7
←
'idx' declared without an initial value→

if (drm_dev_enter(dev, &idx)) {
8
←
Calling 'drm_dev_enter'→
10
←
Returning from 'drm_dev_enter'→
11
←
Taking true branch→
drm_dev_exit(idx);
12
←
1st function call argument is an uninitialized value
return false0;
}

return true1;
568}

570/**
* drm_core_check_all_features - check driver feature flags mask
* @dev: DRM device to check
* @features: feature flag(s) mask
*
* This checks @dev for driver features, see &drm_driver.driver_features,
* &drm_device.driver_features, and the various &enum drm_driver_feature flags.
*
* Returns true if all features in the @features mask are supported, false
* otherwise.
*/
581static inline bool_Bool drm_core_check_all_features(const struct drm_device *dev,
			       u32 features)
583{
u32 supported = dev->driver->driver_features & dev->driver_features;

return features && (supported & features) == features;
587}

589/**
* drm_core_check_feature - check driver feature flags
* @dev: DRM device to check
* @feature: feature flag
*
* This checks @dev for driver features, see &drm_driver.driver_features,
* &drm_device.driver_features, and the various &enum drm_driver_feature flags.
*
* Returns true if the @feature is supported, false otherwise.
*/
599static inline bool_Bool drm_core_check_feature(const struct drm_device *dev,
			  enum drm_driver_feature feature)
601{
return drm_core_check_all_features(dev, feature);
603}

605/**
* drm_drv_uses_atomic_modeset - check if the driver implements
* atomic_commit()
* @dev: DRM device
*
* This check is useful if drivers do not have DRIVER_ATOMIC set but
* have atomic modesetting internally implemented.
*/
613static inline bool_Bool drm_drv_uses_atomic_modeset(struct drm_device *dev)
614{
return drm_core_check_feature(dev, DRIVER_ATOMIC) ||
(dev->mode_config.funcs && dev->mode_config.funcs->atomic_commit != NULL((void *)0));
617}


620int drm_dev_set_unique(struct drm_device *dev, const char *name);

622struct drm_file *drm_find_file_by_minor(struct drm_device *, int);
623struct drm_device *drm_get_device_from_kdev(dev_t);

625#ifdef __OpenBSD__1

627void drm_attach_platform(struct drm_driver *, bus_space_tag_t, bus_dma_tag_t,
  struct device *, struct drm_device *);
629struct drm_device *drm_attach_pci(const struct drm_driver *,
  struct pci_attach_args *, int, int, struct device *, struct drm_device *);

632int drm_pciprobe(struct pci_attach_args *, const struct pci_device_id * );
633const struct pci_device_id *drm_find_description(int, int,
  const struct pci_device_id *);

636int drm_getpciinfo(struct drm_device *, void *, struct drm_file *);

638#endif
639extern bool_Bool drm_firmware_drivers_only(void);

641#endif