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