xref: /linux/drivers/gpu/drm/drm_drv.c (revision 2c1ed907520c50326b8f604907a8478b27881a2e)
1 /*
2  * Created: Fri Jan 19 10:48:35 2001 by faith@acm.org
3  *
4  * Copyright 2001 VA Linux Systems, Inc., Sunnyvale, California.
5  * All Rights Reserved.
6  *
7  * Author Rickard E. (Rik) Faith <faith@valinux.com>
8  *
9  * Permission is hereby granted, free of charge, to any person obtaining a
10  * copy of this software and associated documentation files (the "Software"),
11  * to deal in the Software without restriction, including without limitation
12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13  * and/or sell copies of the Software, and to permit persons to whom the
14  * Software is furnished to do so, subject to the following conditions:
15  *
16  * The above copyright notice and this permission notice (including the next
17  * paragraph) shall be included in all copies or substantial portions of the
18  * Software.
19  *
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
23  * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
24  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
25  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26  * DEALINGS IN THE SOFTWARE.
27  */
28 
29 #include <linux/cgroup_dmem.h>
30 #include <linux/debugfs.h>
31 #include <linux/fs.h>
32 #include <linux/module.h>
33 #include <linux/moduleparam.h>
34 #include <linux/mount.h>
35 #include <linux/pseudo_fs.h>
36 #include <linux/slab.h>
37 #include <linux/srcu.h>
38 #include <linux/xarray.h>
39 
40 #include <drm/drm_accel.h>
41 #include <drm/drm_cache.h>
42 #include <drm/drm_client_event.h>
43 #include <drm/drm_color_mgmt.h>
44 #include <drm/drm_drv.h>
45 #include <drm/drm_file.h>
46 #include <drm/drm_managed.h>
47 #include <drm/drm_mode_object.h>
48 #include <drm/drm_panic.h>
49 #include <drm/drm_print.h>
50 #include <drm/drm_privacy_screen_machine.h>
51 
52 #include "drm_crtc_internal.h"
53 #include "drm_internal.h"
54 
55 MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl");
56 MODULE_DESCRIPTION("DRM shared core routines");
57 MODULE_LICENSE("GPL and additional rights");
58 
59 DEFINE_XARRAY_ALLOC(drm_minors_xa);
60 
61 /*
62  * If the drm core fails to init for whatever reason,
63  * we should prevent any drivers from registering with it.
64  * It's best to check this at drm_dev_init(), as some drivers
65  * prefer to embed struct drm_device into their own device
66  * structure and call drm_dev_init() themselves.
67  */
68 static bool drm_core_init_complete;
69 
70 static struct dentry *drm_debugfs_root;
71 
72 DEFINE_STATIC_SRCU(drm_unplug_srcu);
73 
74 /*
75  * DRM Minors
76  * A DRM device can provide several char-dev interfaces on the DRM-Major. Each
77  * of them is represented by a drm_minor object. Depending on the capabilities
78  * of the device-driver, different interfaces are registered.
79  *
80  * Minors can be accessed via dev->$minor_name. This pointer is either
81  * NULL or a valid drm_minor pointer and stays valid as long as the device is
82  * valid. This means, DRM minors have the same life-time as the underlying
83  * device. However, this doesn't mean that the minor is active. Minors are
84  * registered and unregistered dynamically according to device-state.
85  */
86 
drm_minor_get_xa(enum drm_minor_type type)87 static struct xarray *drm_minor_get_xa(enum drm_minor_type type)
88 {
89 	if (type == DRM_MINOR_PRIMARY || type == DRM_MINOR_RENDER)
90 		return &drm_minors_xa;
91 #if IS_ENABLED(CONFIG_DRM_ACCEL)
92 	else if (type == DRM_MINOR_ACCEL)
93 		return &accel_minors_xa;
94 #endif
95 	else
96 		return ERR_PTR(-EOPNOTSUPP);
97 }
98 
drm_minor_get_slot(struct drm_device * dev,enum drm_minor_type type)99 static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
100 					     enum drm_minor_type type)
101 {
102 	switch (type) {
103 	case DRM_MINOR_PRIMARY:
104 		return &dev->primary;
105 	case DRM_MINOR_RENDER:
106 		return &dev->render;
107 	case DRM_MINOR_ACCEL:
108 		return &dev->accel;
109 	default:
110 		BUG();
111 	}
112 }
113 
drm_minor_alloc_release(struct drm_device * dev,void * data)114 static void drm_minor_alloc_release(struct drm_device *dev, void *data)
115 {
116 	struct drm_minor *minor = data;
117 
118 	WARN_ON(dev != minor->dev);
119 
120 	put_device(minor->kdev);
121 
122 	xa_erase(drm_minor_get_xa(minor->type), minor->index);
123 }
124 
125 /*
126  * DRM used to support 64 devices, for backwards compatibility we need to maintain the
127  * minor allocation scheme where minors 0-63 are primary nodes, 64-127 are control nodes,
128  * and 128-191 are render nodes.
129  * After reaching the limit, we're allocating minors dynamically - first-come, first-serve.
130  * Accel nodes are using a distinct major, so the minors are allocated in continuous 0-MAX
131  * range.
132  */
133 #define DRM_MINOR_LIMIT(t) ({ \
134 	typeof(t) _t = (t); \
135 	_t == DRM_MINOR_ACCEL ? XA_LIMIT(0, ACCEL_MAX_MINORS) : XA_LIMIT(64 * _t, 64 * _t + 63); \
136 })
137 #define DRM_EXTENDED_MINOR_LIMIT XA_LIMIT(192, (1 << MINORBITS) - 1)
138 
drm_minor_alloc(struct drm_device * dev,enum drm_minor_type type)139 static int drm_minor_alloc(struct drm_device *dev, enum drm_minor_type type)
140 {
141 	struct drm_minor *minor;
142 	int r;
143 
144 	minor = drmm_kzalloc(dev, sizeof(*minor), GFP_KERNEL);
145 	if (!minor)
146 		return -ENOMEM;
147 
148 	minor->type = type;
149 	minor->dev = dev;
150 
151 	r = xa_alloc(drm_minor_get_xa(type), &minor->index,
152 		     NULL, DRM_MINOR_LIMIT(type), GFP_KERNEL);
153 	if (r == -EBUSY && (type == DRM_MINOR_PRIMARY || type == DRM_MINOR_RENDER))
154 		r = xa_alloc(&drm_minors_xa, &minor->index,
155 			     NULL, DRM_EXTENDED_MINOR_LIMIT, GFP_KERNEL);
156 	if (r < 0)
157 		return r;
158 
159 	r = drmm_add_action_or_reset(dev, drm_minor_alloc_release, minor);
160 	if (r)
161 		return r;
162 
163 	minor->kdev = drm_sysfs_minor_alloc(minor);
164 	if (IS_ERR(minor->kdev))
165 		return PTR_ERR(minor->kdev);
166 
167 	*drm_minor_get_slot(dev, type) = minor;
168 	return 0;
169 }
170 
drm_minor_register(struct drm_device * dev,enum drm_minor_type type)171 static int drm_minor_register(struct drm_device *dev, enum drm_minor_type type)
172 {
173 	struct drm_minor *minor;
174 	void *entry;
175 	int ret;
176 
177 	DRM_DEBUG("\n");
178 
179 	minor = *drm_minor_get_slot(dev, type);
180 	if (!minor)
181 		return 0;
182 
183 	if (minor->type != DRM_MINOR_ACCEL) {
184 		ret = drm_debugfs_register(minor, minor->index,
185 					   drm_debugfs_root);
186 		if (ret) {
187 			DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
188 			goto err_debugfs;
189 		}
190 	}
191 
192 	ret = device_add(minor->kdev);
193 	if (ret)
194 		goto err_debugfs;
195 
196 	/* replace NULL with @minor so lookups will succeed from now on */
197 	entry = xa_store(drm_minor_get_xa(type), minor->index, minor, GFP_KERNEL);
198 	if (xa_is_err(entry)) {
199 		ret = xa_err(entry);
200 		goto err_debugfs;
201 	}
202 	WARN_ON(entry);
203 
204 	DRM_DEBUG("new minor registered %d\n", minor->index);
205 	return 0;
206 
207 err_debugfs:
208 	drm_debugfs_unregister(minor);
209 	return ret;
210 }
211 
drm_minor_unregister(struct drm_device * dev,enum drm_minor_type type)212 static void drm_minor_unregister(struct drm_device *dev, enum drm_minor_type type)
213 {
214 	struct drm_minor *minor;
215 
216 	minor = *drm_minor_get_slot(dev, type);
217 	if (!minor || !device_is_registered(minor->kdev))
218 		return;
219 
220 	/* replace @minor with NULL so lookups will fail from now on */
221 	xa_store(drm_minor_get_xa(type), minor->index, NULL, GFP_KERNEL);
222 
223 	device_del(minor->kdev);
224 	dev_set_drvdata(minor->kdev, NULL); /* safety belt */
225 	drm_debugfs_unregister(minor);
226 }
227 
228 /*
229  * Looks up the given minor-ID and returns the respective DRM-minor object. The
230  * refence-count of the underlying device is increased so you must release this
231  * object with drm_minor_release().
232  *
233  * As long as you hold this minor, it is guaranteed that the object and the
234  * minor->dev pointer will stay valid! However, the device may get unplugged and
235  * unregistered while you hold the minor.
236  */
drm_minor_acquire(struct xarray * minor_xa,unsigned int minor_id)237 struct drm_minor *drm_minor_acquire(struct xarray *minor_xa, unsigned int minor_id)
238 {
239 	struct drm_minor *minor;
240 
241 	xa_lock(minor_xa);
242 	minor = xa_load(minor_xa, minor_id);
243 	if (minor)
244 		drm_dev_get(minor->dev);
245 	xa_unlock(minor_xa);
246 
247 	if (!minor) {
248 		return ERR_PTR(-ENODEV);
249 	} else if (drm_dev_is_unplugged(minor->dev)) {
250 		drm_dev_put(minor->dev);
251 		return ERR_PTR(-ENODEV);
252 	}
253 
254 	return minor;
255 }
256 
drm_minor_release(struct drm_minor * minor)257 void drm_minor_release(struct drm_minor *minor)
258 {
259 	drm_dev_put(minor->dev);
260 }
261 
262 /**
263  * DOC: driver instance overview
264  *
265  * A device instance for a drm driver is represented by &struct drm_device. This
266  * is allocated and initialized with devm_drm_dev_alloc(), usually from
267  * bus-specific ->probe() callbacks implemented by the driver. The driver then
268  * needs to initialize all the various subsystems for the drm device like memory
269  * management, vblank handling, modesetting support and initial output
270  * configuration plus obviously initialize all the corresponding hardware bits.
271  * Finally when everything is up and running and ready for userspace the device
272  * instance can be published using drm_dev_register().
273  *
274  * There is also deprecated support for initializing device instances using
275  * bus-specific helpers and the &drm_driver.load callback. But due to
276  * backwards-compatibility needs the device instance have to be published too
277  * early, which requires unpretty global locking to make safe and is therefore
278  * only support for existing drivers not yet converted to the new scheme.
279  *
280  * When cleaning up a device instance everything needs to be done in reverse:
281  * First unpublish the device instance with drm_dev_unregister(). Then clean up
282  * any other resources allocated at device initialization and drop the driver's
283  * reference to &drm_device using drm_dev_put().
284  *
285  * Note that any allocation or resource which is visible to userspace must be
286  * released only when the final drm_dev_put() is called, and not when the
287  * driver is unbound from the underlying physical struct &device. Best to use
288  * &drm_device managed resources with drmm_add_action(), drmm_kmalloc() and
289  * related functions.
290  *
291  * devres managed resources like devm_kmalloc() can only be used for resources
292  * directly related to the underlying hardware device, and only used in code
293  * paths fully protected by drm_dev_enter() and drm_dev_exit().
294  *
295  * Display driver example
296  * ~~~~~~~~~~~~~~~~~~~~~~
297  *
298  * The following example shows a typical structure of a DRM display driver.
299  * The example focus on the probe() function and the other functions that is
300  * almost always present and serves as a demonstration of devm_drm_dev_alloc().
301  *
302  * .. code-block:: c
303  *
304  *	struct driver_device {
305  *		struct drm_device drm;
306  *		void *userspace_facing;
307  *		struct clk *pclk;
308  *	};
309  *
310  *	static const struct drm_driver driver_drm_driver = {
311  *		[...]
312  *	};
313  *
314  *	static int driver_probe(struct platform_device *pdev)
315  *	{
316  *		struct driver_device *priv;
317  *		struct drm_device *drm;
318  *		int ret;
319  *
320  *		priv = devm_drm_dev_alloc(&pdev->dev, &driver_drm_driver,
321  *					  struct driver_device, drm);
322  *		if (IS_ERR(priv))
323  *			return PTR_ERR(priv);
324  *		drm = &priv->drm;
325  *
326  *		ret = drmm_mode_config_init(drm);
327  *		if (ret)
328  *			return ret;
329  *
330  *		priv->userspace_facing = drmm_kzalloc(..., GFP_KERNEL);
331  *		if (!priv->userspace_facing)
332  *			return -ENOMEM;
333  *
334  *		priv->pclk = devm_clk_get(dev, "PCLK");
335  *		if (IS_ERR(priv->pclk))
336  *			return PTR_ERR(priv->pclk);
337  *
338  *		// Further setup, display pipeline etc
339  *
340  *		platform_set_drvdata(pdev, drm);
341  *
342  *		drm_mode_config_reset(drm);
343  *
344  *		ret = drm_dev_register(drm);
345  *		if (ret)
346  *			return ret;
347  *
348  *		drm_fbdev_{...}_setup(drm, 32);
349  *
350  *		return 0;
351  *	}
352  *
353  *	// This function is called before the devm_ resources are released
354  *	static int driver_remove(struct platform_device *pdev)
355  *	{
356  *		struct drm_device *drm = platform_get_drvdata(pdev);
357  *
358  *		drm_dev_unregister(drm);
359  *		drm_atomic_helper_shutdown(drm)
360  *
361  *		return 0;
362  *	}
363  *
364  *	// This function is called on kernel restart and shutdown
365  *	static void driver_shutdown(struct platform_device *pdev)
366  *	{
367  *		drm_atomic_helper_shutdown(platform_get_drvdata(pdev));
368  *	}
369  *
370  *	static int __maybe_unused driver_pm_suspend(struct device *dev)
371  *	{
372  *		return drm_mode_config_helper_suspend(dev_get_drvdata(dev));
373  *	}
374  *
375  *	static int __maybe_unused driver_pm_resume(struct device *dev)
376  *	{
377  *		drm_mode_config_helper_resume(dev_get_drvdata(dev));
378  *
379  *		return 0;
380  *	}
381  *
382  *	static const struct dev_pm_ops driver_pm_ops = {
383  *		SET_SYSTEM_SLEEP_PM_OPS(driver_pm_suspend, driver_pm_resume)
384  *	};
385  *
386  *	static struct platform_driver driver_driver = {
387  *		.driver = {
388  *			[...]
389  *			.pm = &driver_pm_ops,
390  *		},
391  *		.probe = driver_probe,
392  *		.remove = driver_remove,
393  *		.shutdown = driver_shutdown,
394  *	};
395  *	module_platform_driver(driver_driver);
396  *
397  * Drivers that want to support device unplugging (USB, DT overlay unload) should
398  * use drm_dev_unplug() instead of drm_dev_unregister(). The driver must protect
399  * regions that is accessing device resources to prevent use after they're
400  * released. This is done using drm_dev_enter() and drm_dev_exit(). There is one
401  * shortcoming however, drm_dev_unplug() marks the drm_device as unplugged before
402  * drm_atomic_helper_shutdown() is called. This means that if the disable code
403  * paths are protected, they will not run on regular driver module unload,
404  * possibly leaving the hardware enabled.
405  */
406 
407 /**
408  * drm_put_dev - Unregister and release a DRM device
409  * @dev: DRM device
410  *
411  * Called at module unload time or when a PCI device is unplugged.
412  *
413  * Cleans up all DRM device, calling drm_lastclose().
414  *
415  * Note: Use of this function is deprecated. It will eventually go away
416  * completely.  Please use drm_dev_unregister() and drm_dev_put() explicitly
417  * instead to make sure that the device isn't userspace accessible any more
418  * while teardown is in progress, ensuring that userspace can't access an
419  * inconsistent state.
420  */
drm_put_dev(struct drm_device * dev)421 void drm_put_dev(struct drm_device *dev)
422 {
423 	DRM_DEBUG("\n");
424 
425 	if (!dev) {
426 		DRM_ERROR("cleanup called no dev\n");
427 		return;
428 	}
429 
430 	drm_dev_unregister(dev);
431 	drm_dev_put(dev);
432 }
433 EXPORT_SYMBOL(drm_put_dev);
434 
435 /**
436  * drm_dev_enter - Enter device critical section
437  * @dev: DRM device
438  * @idx: Pointer to index that will be passed to the matching drm_dev_exit()
439  *
440  * This function marks and protects the beginning of a section that should not
441  * be entered after the device has been unplugged. The section end is marked
442  * with drm_dev_exit(). Calls to this function can be nested.
443  *
444  * Returns:
445  * True if it is OK to enter the section, false otherwise.
446  */
drm_dev_enter(struct drm_device * dev,int * idx)447 bool drm_dev_enter(struct drm_device *dev, int *idx)
448 {
449 	*idx = srcu_read_lock(&drm_unplug_srcu);
450 
451 	if (dev->unplugged) {
452 		srcu_read_unlock(&drm_unplug_srcu, *idx);
453 		return false;
454 	}
455 
456 	return true;
457 }
458 EXPORT_SYMBOL(drm_dev_enter);
459 
460 /**
461  * drm_dev_exit - Exit device critical section
462  * @idx: index returned from drm_dev_enter()
463  *
464  * This function marks the end of a section that should not be entered after
465  * the device has been unplugged.
466  */
drm_dev_exit(int idx)467 void drm_dev_exit(int idx)
468 {
469 	srcu_read_unlock(&drm_unplug_srcu, idx);
470 }
471 EXPORT_SYMBOL(drm_dev_exit);
472 
473 /**
474  * drm_dev_unplug - unplug a DRM device
475  * @dev: DRM device
476  *
477  * This unplugs a hotpluggable DRM device, which makes it inaccessible to
478  * userspace operations. Entry-points can use drm_dev_enter() and
479  * drm_dev_exit() to protect device resources in a race free manner. This
480  * essentially unregisters the device like drm_dev_unregister(), but can be
481  * called while there are still open users of @dev.
482  */
drm_dev_unplug(struct drm_device * dev)483 void drm_dev_unplug(struct drm_device *dev)
484 {
485 	/*
486 	 * After synchronizing any critical read section is guaranteed to see
487 	 * the new value of ->unplugged, and any critical section which might
488 	 * still have seen the old value of ->unplugged is guaranteed to have
489 	 * finished.
490 	 */
491 	dev->unplugged = true;
492 	synchronize_srcu(&drm_unplug_srcu);
493 
494 	drm_dev_unregister(dev);
495 
496 	/* Clear all CPU mappings pointing to this device */
497 	unmap_mapping_range(dev->anon_inode->i_mapping, 0, 0, 1);
498 }
499 EXPORT_SYMBOL(drm_dev_unplug);
500 
501 /*
502  * DRM internal mount
503  * We want to be able to allocate our own "struct address_space" to control
504  * memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow
505  * stand-alone address_space objects, so we need an underlying inode. As there
506  * is no way to allocate an independent inode easily, we need a fake internal
507  * VFS mount-point.
508  *
509  * The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free()
510  * frees it again. You are allowed to use iget() and iput() to get references to
511  * the inode. But each drm_fs_inode_new() call must be paired with exactly one
512  * drm_fs_inode_free() call (which does not have to be the last iput()).
513  * We use drm_fs_inode_*() to manage our internal VFS mount-point and share it
514  * between multiple inode-users. You could, technically, call
515  * iget() + drm_fs_inode_free() directly after alloc and sometime later do an
516  * iput(), but this way you'd end up with a new vfsmount for each inode.
517  */
518 
519 static int drm_fs_cnt;
520 static struct vfsmount *drm_fs_mnt;
521 
drm_fs_init_fs_context(struct fs_context * fc)522 static int drm_fs_init_fs_context(struct fs_context *fc)
523 {
524 	return init_pseudo(fc, 0x010203ff) ? 0 : -ENOMEM;
525 }
526 
527 static struct file_system_type drm_fs_type = {
528 	.name		= "drm",
529 	.owner		= THIS_MODULE,
530 	.init_fs_context = drm_fs_init_fs_context,
531 	.kill_sb	= kill_anon_super,
532 };
533 
drm_fs_inode_new(void)534 static struct inode *drm_fs_inode_new(void)
535 {
536 	struct inode *inode;
537 	int r;
538 
539 	r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt);
540 	if (r < 0) {
541 		DRM_ERROR("Cannot mount pseudo fs: %d\n", r);
542 		return ERR_PTR(r);
543 	}
544 
545 	inode = alloc_anon_inode(drm_fs_mnt->mnt_sb);
546 	if (IS_ERR(inode))
547 		simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
548 
549 	return inode;
550 }
551 
drm_fs_inode_free(struct inode * inode)552 static void drm_fs_inode_free(struct inode *inode)
553 {
554 	if (inode) {
555 		iput(inode);
556 		simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
557 	}
558 }
559 
560 /**
561  * DOC: component helper usage recommendations
562  *
563  * DRM drivers that drive hardware where a logical device consists of a pile of
564  * independent hardware blocks are recommended to use the :ref:`component helper
565  * library<component>`. For consistency and better options for code reuse the
566  * following guidelines apply:
567  *
568  *  - The entire device initialization procedure should be run from the
569  *    &component_master_ops.master_bind callback, starting with
570  *    devm_drm_dev_alloc(), then binding all components with
571  *    component_bind_all() and finishing with drm_dev_register().
572  *
573  *  - The opaque pointer passed to all components through component_bind_all()
574  *    should point at &struct drm_device of the device instance, not some driver
575  *    specific private structure.
576  *
577  *  - The component helper fills the niche where further standardization of
578  *    interfaces is not practical. When there already is, or will be, a
579  *    standardized interface like &drm_bridge or &drm_panel, providing its own
580  *    functions to find such components at driver load time, like
581  *    drm_of_find_panel_or_bridge(), then the component helper should not be
582  *    used.
583  */
584 
drm_dev_init_release(struct drm_device * dev,void * res)585 static void drm_dev_init_release(struct drm_device *dev, void *res)
586 {
587 	drm_fs_inode_free(dev->anon_inode);
588 
589 	put_device(dev->dev);
590 	/* Prevent use-after-free in drm_managed_release when debugging is
591 	 * enabled. Slightly awkward, but can't really be helped. */
592 	dev->dev = NULL;
593 	mutex_destroy(&dev->master_mutex);
594 	mutex_destroy(&dev->clientlist_mutex);
595 	mutex_destroy(&dev->filelist_mutex);
596 	mutex_destroy(&dev->struct_mutex);
597 }
598 
drm_dev_init(struct drm_device * dev,const struct drm_driver * driver,struct device * parent)599 static int drm_dev_init(struct drm_device *dev,
600 			const struct drm_driver *driver,
601 			struct device *parent)
602 {
603 	struct inode *inode;
604 	int ret;
605 
606 	if (!drm_core_init_complete) {
607 		DRM_ERROR("DRM core is not initialized\n");
608 		return -ENODEV;
609 	}
610 
611 	if (WARN_ON(!parent))
612 		return -EINVAL;
613 
614 	kref_init(&dev->ref);
615 	dev->dev = get_device(parent);
616 	dev->driver = driver;
617 
618 	INIT_LIST_HEAD(&dev->managed.resources);
619 	spin_lock_init(&dev->managed.lock);
620 
621 	/* no per-device feature limits by default */
622 	dev->driver_features = ~0u;
623 
624 	if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL) &&
625 				(drm_core_check_feature(dev, DRIVER_RENDER) ||
626 				drm_core_check_feature(dev, DRIVER_MODESET))) {
627 		DRM_ERROR("DRM driver can't be both a compute acceleration and graphics driver\n");
628 		return -EINVAL;
629 	}
630 
631 	INIT_LIST_HEAD(&dev->filelist);
632 	INIT_LIST_HEAD(&dev->filelist_internal);
633 	INIT_LIST_HEAD(&dev->clientlist);
634 	INIT_LIST_HEAD(&dev->vblank_event_list);
635 
636 	spin_lock_init(&dev->event_lock);
637 	mutex_init(&dev->struct_mutex);
638 	mutex_init(&dev->filelist_mutex);
639 	mutex_init(&dev->clientlist_mutex);
640 	mutex_init(&dev->master_mutex);
641 	raw_spin_lock_init(&dev->mode_config.panic_lock);
642 
643 	ret = drmm_add_action_or_reset(dev, drm_dev_init_release, NULL);
644 	if (ret)
645 		return ret;
646 
647 	inode = drm_fs_inode_new();
648 	if (IS_ERR(inode)) {
649 		ret = PTR_ERR(inode);
650 		DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret);
651 		goto err;
652 	}
653 
654 	dev->anon_inode = inode;
655 
656 	if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL)) {
657 		ret = drm_minor_alloc(dev, DRM_MINOR_ACCEL);
658 		if (ret)
659 			goto err;
660 	} else {
661 		if (drm_core_check_feature(dev, DRIVER_RENDER)) {
662 			ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
663 			if (ret)
664 				goto err;
665 		}
666 
667 		ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY);
668 		if (ret)
669 			goto err;
670 	}
671 
672 	if (drm_core_check_feature(dev, DRIVER_GEM)) {
673 		ret = drm_gem_init(dev);
674 		if (ret) {
675 			DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
676 			goto err;
677 		}
678 	}
679 
680 	dev->unique = drmm_kstrdup(dev, dev_name(parent), GFP_KERNEL);
681 	if (!dev->unique) {
682 		ret = -ENOMEM;
683 		goto err;
684 	}
685 
686 	if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL))
687 		accel_debugfs_init(dev);
688 	else
689 		drm_debugfs_dev_init(dev, drm_debugfs_root);
690 
691 	return 0;
692 
693 err:
694 	drm_managed_release(dev);
695 
696 	return ret;
697 }
698 
devm_drm_dev_init_release(void * data)699 static void devm_drm_dev_init_release(void *data)
700 {
701 	drm_dev_put(data);
702 }
703 
devm_drm_dev_init(struct device * parent,struct drm_device * dev,const struct drm_driver * driver)704 static int devm_drm_dev_init(struct device *parent,
705 			     struct drm_device *dev,
706 			     const struct drm_driver *driver)
707 {
708 	int ret;
709 
710 	ret = drm_dev_init(dev, driver, parent);
711 	if (ret)
712 		return ret;
713 
714 	return devm_add_action_or_reset(parent,
715 					devm_drm_dev_init_release, dev);
716 }
717 
__devm_drm_dev_alloc(struct device * parent,const struct drm_driver * driver,size_t size,size_t offset)718 void *__devm_drm_dev_alloc(struct device *parent,
719 			   const struct drm_driver *driver,
720 			   size_t size, size_t offset)
721 {
722 	void *container;
723 	struct drm_device *drm;
724 	int ret;
725 
726 	container = kzalloc(size, GFP_KERNEL);
727 	if (!container)
728 		return ERR_PTR(-ENOMEM);
729 
730 	drm = container + offset;
731 	ret = devm_drm_dev_init(parent, drm, driver);
732 	if (ret) {
733 		kfree(container);
734 		return ERR_PTR(ret);
735 	}
736 	drmm_add_final_kfree(drm, container);
737 
738 	return container;
739 }
740 EXPORT_SYMBOL(__devm_drm_dev_alloc);
741 
742 /**
743  * drm_dev_alloc - Allocate new DRM device
744  * @driver: DRM driver to allocate device for
745  * @parent: Parent device object
746  *
747  * This is the deprecated version of devm_drm_dev_alloc(), which does not support
748  * subclassing through embedding the struct &drm_device in a driver private
749  * structure, and which does not support automatic cleanup through devres.
750  *
751  * RETURNS:
752  * Pointer to new DRM device, or ERR_PTR on failure.
753  */
drm_dev_alloc(const struct drm_driver * driver,struct device * parent)754 struct drm_device *drm_dev_alloc(const struct drm_driver *driver,
755 				 struct device *parent)
756 {
757 	struct drm_device *dev;
758 	int ret;
759 
760 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
761 	if (!dev)
762 		return ERR_PTR(-ENOMEM);
763 
764 	ret = drm_dev_init(dev, driver, parent);
765 	if (ret) {
766 		kfree(dev);
767 		return ERR_PTR(ret);
768 	}
769 
770 	drmm_add_final_kfree(dev, dev);
771 
772 	return dev;
773 }
774 EXPORT_SYMBOL(drm_dev_alloc);
775 
drm_dev_release(struct kref * ref)776 static void drm_dev_release(struct kref *ref)
777 {
778 	struct drm_device *dev = container_of(ref, struct drm_device, ref);
779 
780 	/* Just in case register/unregister was never called */
781 	drm_debugfs_dev_fini(dev);
782 
783 	if (dev->driver->release)
784 		dev->driver->release(dev);
785 
786 	drm_managed_release(dev);
787 
788 	kfree(dev->managed.final_kfree);
789 }
790 
791 /**
792  * drm_dev_get - Take reference of a DRM device
793  * @dev: device to take reference of or NULL
794  *
795  * This increases the ref-count of @dev by one. You *must* already own a
796  * reference when calling this. Use drm_dev_put() to drop this reference
797  * again.
798  *
799  * This function never fails. However, this function does not provide *any*
800  * guarantee whether the device is alive or running. It only provides a
801  * reference to the object and the memory associated with it.
802  */
drm_dev_get(struct drm_device * dev)803 void drm_dev_get(struct drm_device *dev)
804 {
805 	if (dev)
806 		kref_get(&dev->ref);
807 }
808 EXPORT_SYMBOL(drm_dev_get);
809 
810 /**
811  * drm_dev_put - Drop reference of a DRM device
812  * @dev: device to drop reference of or NULL
813  *
814  * This decreases the ref-count of @dev by one. The device is destroyed if the
815  * ref-count drops to zero.
816  */
drm_dev_put(struct drm_device * dev)817 void drm_dev_put(struct drm_device *dev)
818 {
819 	if (dev)
820 		kref_put(&dev->ref, drm_dev_release);
821 }
822 EXPORT_SYMBOL(drm_dev_put);
823 
drmm_cg_unregister_region(struct drm_device * dev,void * arg)824 static void drmm_cg_unregister_region(struct drm_device *dev, void *arg)
825 {
826 	dmem_cgroup_unregister_region(arg);
827 }
828 
829 /**
830  * drmm_cgroup_register_region - Register a region of a DRM device to cgroups
831  * @dev: device for region
832  * @region_name: Region name for registering
833  * @size: Size of region in bytes
834  *
835  * This decreases the ref-count of @dev by one. The device is destroyed if the
836  * ref-count drops to zero.
837  */
drmm_cgroup_register_region(struct drm_device * dev,const char * region_name,u64 size)838 struct dmem_cgroup_region *drmm_cgroup_register_region(struct drm_device *dev, const char *region_name, u64 size)
839 {
840 	struct dmem_cgroup_region *region;
841 	int ret;
842 
843 	region = dmem_cgroup_register_region(size, "drm/%s/%s", dev->unique, region_name);
844 	if (IS_ERR_OR_NULL(region))
845 		return region;
846 
847 	ret = drmm_add_action_or_reset(dev, drmm_cg_unregister_region, region);
848 	if (ret)
849 		return ERR_PTR(ret);
850 
851 	return region;
852 }
853 EXPORT_SYMBOL_GPL(drmm_cgroup_register_region);
854 
create_compat_control_link(struct drm_device * dev)855 static int create_compat_control_link(struct drm_device *dev)
856 {
857 	struct drm_minor *minor;
858 	char *name;
859 	int ret;
860 
861 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
862 		return 0;
863 
864 	minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
865 	if (!minor)
866 		return 0;
867 
868 	/*
869 	 * Some existing userspace out there uses the existing of the controlD*
870 	 * sysfs files to figure out whether it's a modeset driver. It only does
871 	 * readdir, hence a symlink is sufficient (and the least confusing
872 	 * option). Otherwise controlD* is entirely unused.
873 	 *
874 	 * Old controlD chardev have been allocated in the range
875 	 * 64-127.
876 	 */
877 	name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);
878 	if (!name)
879 		return -ENOMEM;
880 
881 	ret = sysfs_create_link(minor->kdev->kobj.parent,
882 				&minor->kdev->kobj,
883 				name);
884 
885 	kfree(name);
886 
887 	return ret;
888 }
889 
remove_compat_control_link(struct drm_device * dev)890 static void remove_compat_control_link(struct drm_device *dev)
891 {
892 	struct drm_minor *minor;
893 	char *name;
894 
895 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
896 		return;
897 
898 	minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
899 	if (!minor)
900 		return;
901 
902 	name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);
903 	if (!name)
904 		return;
905 
906 	sysfs_remove_link(minor->kdev->kobj.parent, name);
907 
908 	kfree(name);
909 }
910 
911 /**
912  * drm_dev_register - Register DRM device
913  * @dev: Device to register
914  * @flags: Flags passed to the driver's .load() function
915  *
916  * Register the DRM device @dev with the system, advertise device to user-space
917  * and start normal device operation. @dev must be initialized via drm_dev_init()
918  * previously.
919  *
920  * Never call this twice on any device!
921  *
922  * NOTE: To ensure backward compatibility with existing drivers method this
923  * function calls the &drm_driver.load method after registering the device
924  * nodes, creating race conditions. Usage of the &drm_driver.load methods is
925  * therefore deprecated, drivers must perform all initialization before calling
926  * drm_dev_register().
927  *
928  * RETURNS:
929  * 0 on success, negative error code on failure.
930  */
drm_dev_register(struct drm_device * dev,unsigned long flags)931 int drm_dev_register(struct drm_device *dev, unsigned long flags)
932 {
933 	const struct drm_driver *driver = dev->driver;
934 	int ret;
935 
936 	if (!driver->load)
937 		drm_mode_config_validate(dev);
938 
939 	WARN_ON(!dev->managed.final_kfree);
940 
941 	if (drm_dev_needs_global_mutex(dev))
942 		mutex_lock(&drm_global_mutex);
943 
944 	if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL))
945 		accel_debugfs_register(dev);
946 	else
947 		drm_debugfs_dev_register(dev);
948 
949 	ret = drm_minor_register(dev, DRM_MINOR_RENDER);
950 	if (ret)
951 		goto err_minors;
952 
953 	ret = drm_minor_register(dev, DRM_MINOR_PRIMARY);
954 	if (ret)
955 		goto err_minors;
956 
957 	ret = drm_minor_register(dev, DRM_MINOR_ACCEL);
958 	if (ret)
959 		goto err_minors;
960 
961 	ret = create_compat_control_link(dev);
962 	if (ret)
963 		goto err_minors;
964 
965 	dev->registered = true;
966 
967 	if (driver->load) {
968 		ret = driver->load(dev, flags);
969 		if (ret)
970 			goto err_minors;
971 	}
972 
973 	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
974 		ret = drm_modeset_register_all(dev);
975 		if (ret)
976 			goto err_unload;
977 	}
978 	drm_panic_register(dev);
979 
980 	DRM_INFO("Initialized %s %d.%d.%d for %s on minor %d\n",
981 		 driver->name, driver->major, driver->minor,
982 		 driver->patchlevel,
983 		 dev->dev ? dev_name(dev->dev) : "virtual device",
984 		 dev->primary ? dev->primary->index : dev->accel->index);
985 
986 	goto out_unlock;
987 
988 err_unload:
989 	if (dev->driver->unload)
990 		dev->driver->unload(dev);
991 err_minors:
992 	remove_compat_control_link(dev);
993 	drm_minor_unregister(dev, DRM_MINOR_ACCEL);
994 	drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
995 	drm_minor_unregister(dev, DRM_MINOR_RENDER);
996 out_unlock:
997 	if (drm_dev_needs_global_mutex(dev))
998 		mutex_unlock(&drm_global_mutex);
999 	return ret;
1000 }
1001 EXPORT_SYMBOL(drm_dev_register);
1002 
1003 /**
1004  * drm_dev_unregister - Unregister DRM device
1005  * @dev: Device to unregister
1006  *
1007  * Unregister the DRM device from the system. This does the reverse of
1008  * drm_dev_register() but does not deallocate the device. The caller must call
1009  * drm_dev_put() to drop their final reference, unless it is managed with devres
1010  * (as devices allocated with devm_drm_dev_alloc() are), in which case there is
1011  * already an unwind action registered.
1012  *
1013  * A special form of unregistering for hotpluggable devices is drm_dev_unplug(),
1014  * which can be called while there are still open users of @dev.
1015  *
1016  * This should be called first in the device teardown code to make sure
1017  * userspace can't access the device instance any more.
1018  */
drm_dev_unregister(struct drm_device * dev)1019 void drm_dev_unregister(struct drm_device *dev)
1020 {
1021 	dev->registered = false;
1022 
1023 	drm_panic_unregister(dev);
1024 
1025 	drm_client_dev_unregister(dev);
1026 
1027 	if (drm_core_check_feature(dev, DRIVER_MODESET))
1028 		drm_modeset_unregister_all(dev);
1029 
1030 	if (dev->driver->unload)
1031 		dev->driver->unload(dev);
1032 
1033 	remove_compat_control_link(dev);
1034 	drm_minor_unregister(dev, DRM_MINOR_ACCEL);
1035 	drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
1036 	drm_minor_unregister(dev, DRM_MINOR_RENDER);
1037 	drm_debugfs_dev_fini(dev);
1038 }
1039 EXPORT_SYMBOL(drm_dev_unregister);
1040 
1041 /*
1042  * DRM Core
1043  * The DRM core module initializes all global DRM objects and makes them
1044  * available to drivers. Once setup, drivers can probe their respective
1045  * devices.
1046  * Currently, core management includes:
1047  *  - The "DRM-Global" key/value database
1048  *  - Global ID management for connectors
1049  *  - DRM major number allocation
1050  *  - DRM minor management
1051  *  - DRM sysfs class
1052  *  - DRM debugfs root
1053  *
1054  * Furthermore, the DRM core provides dynamic char-dev lookups. For each
1055  * interface registered on a DRM device, you can request minor numbers from DRM
1056  * core. DRM core takes care of major-number management and char-dev
1057  * registration. A stub ->open() callback forwards any open() requests to the
1058  * registered minor.
1059  */
1060 
drm_stub_open(struct inode * inode,struct file * filp)1061 static int drm_stub_open(struct inode *inode, struct file *filp)
1062 {
1063 	const struct file_operations *new_fops;
1064 	struct drm_minor *minor;
1065 	int err;
1066 
1067 	DRM_DEBUG("\n");
1068 
1069 	minor = drm_minor_acquire(&drm_minors_xa, iminor(inode));
1070 	if (IS_ERR(minor))
1071 		return PTR_ERR(minor);
1072 
1073 	new_fops = fops_get(minor->dev->driver->fops);
1074 	if (!new_fops) {
1075 		err = -ENODEV;
1076 		goto out;
1077 	}
1078 
1079 	replace_fops(filp, new_fops);
1080 	if (filp->f_op->open)
1081 		err = filp->f_op->open(inode, filp);
1082 	else
1083 		err = 0;
1084 
1085 out:
1086 	drm_minor_release(minor);
1087 
1088 	return err;
1089 }
1090 
1091 static const struct file_operations drm_stub_fops = {
1092 	.owner = THIS_MODULE,
1093 	.open = drm_stub_open,
1094 	.llseek = noop_llseek,
1095 };
1096 
drm_core_exit(void)1097 static void drm_core_exit(void)
1098 {
1099 	drm_privacy_screen_lookup_exit();
1100 	drm_panic_exit();
1101 	accel_core_exit();
1102 	unregister_chrdev(DRM_MAJOR, "drm");
1103 	debugfs_remove(drm_debugfs_root);
1104 	drm_sysfs_destroy();
1105 	WARN_ON(!xa_empty(&drm_minors_xa));
1106 	drm_connector_ida_destroy();
1107 }
1108 
drm_core_init(void)1109 static int __init drm_core_init(void)
1110 {
1111 	int ret;
1112 
1113 	drm_connector_ida_init();
1114 	drm_memcpy_init_early();
1115 
1116 	ret = drm_sysfs_init();
1117 	if (ret < 0) {
1118 		DRM_ERROR("Cannot create DRM class: %d\n", ret);
1119 		goto error;
1120 	}
1121 
1122 	drm_debugfs_root = debugfs_create_dir("dri", NULL);
1123 
1124 	ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops);
1125 	if (ret < 0)
1126 		goto error;
1127 
1128 	ret = accel_core_init();
1129 	if (ret < 0)
1130 		goto error;
1131 
1132 	drm_panic_init();
1133 
1134 	drm_privacy_screen_lookup_init();
1135 
1136 	drm_core_init_complete = true;
1137 
1138 	DRM_DEBUG("Initialized\n");
1139 	return 0;
1140 
1141 error:
1142 	drm_core_exit();
1143 	return ret;
1144 }
1145 
1146 module_init(drm_core_init);
1147 module_exit(drm_core_exit);
1148