Merge tag 'drm-accel-2022-11-22' of https://git.kernel.org/pub/scm/linux/kernel/git...

[platform/kernel/linux-rpi.git] / drivers / gpu / drm / drm_drv.c

diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 203bf8d..73b845a 100644 (file)
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -35,6 +35,7 @@
 #include <linux/slab.h>
 #include <linux/srcu.h>
 
+#include <drm/drm_accel.h>
 #include <drm/drm_cache.h>
 #include <drm/drm_client.h>
 #include <drm/drm_color_mgmt.h>
@@ -90,6 +91,8 @@ static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
                return &dev->primary;
        case DRM_MINOR_RENDER:
                return &dev->render;
+       case DRM_MINOR_ACCEL:
+               return &dev->accel;
        default:
                BUG();
        }
@@ -104,9 +107,13 @@ static void drm_minor_alloc_release(struct drm_device *dev, void *data)
 
        put_device(minor->kdev);
 
-       spin_lock_irqsave(&drm_minor_lock, flags);
-       idr_remove(&drm_minors_idr, minor->index);
-       spin_unlock_irqrestore(&drm_minor_lock, flags);
+       if (minor->type == DRM_MINOR_ACCEL) {
+               accel_minor_remove(minor->index);
+       } else {
+               spin_lock_irqsave(&drm_minor_lock, flags);
+               idr_remove(&drm_minors_idr, minor->index);
+               spin_unlock_irqrestore(&drm_minor_lock, flags);
+       }
 }
 
 static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
@@ -123,13 +130,17 @@ static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
        minor->dev = dev;
 
        idr_preload(GFP_KERNEL);
-       spin_lock_irqsave(&drm_minor_lock, flags);
-       r = idr_alloc(&drm_minors_idr,
-                     NULL,
-                     64 * type,
-                     64 * (type + 1),
-                     GFP_NOWAIT);
-       spin_unlock_irqrestore(&drm_minor_lock, flags);
+       if (type == DRM_MINOR_ACCEL) {
+               r = accel_minor_alloc();
+       } else {
+               spin_lock_irqsave(&drm_minor_lock, flags);
+               r = idr_alloc(&drm_minors_idr,
+                       NULL,
+                       64 * type,
+                       64 * (type + 1),
+                       GFP_NOWAIT);
+               spin_unlock_irqrestore(&drm_minor_lock, flags);
+       }
        idr_preload_end();
 
        if (r < 0)
@@ -161,10 +172,14 @@ static int drm_minor_register(struct drm_device *dev, unsigned int type)
        if (!minor)
                return 0;
 
-       ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
-       if (ret) {
-               DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
-               goto err_debugfs;
+       if (minor->type == DRM_MINOR_ACCEL) {
+               accel_debugfs_init(minor, minor->index);
+       } else {
+               ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
+               if (ret) {
+                       DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
+                       goto err_debugfs;
+               }
        }
 
        ret = device_add(minor->kdev);
@@ -172,9 +187,13 @@ static int drm_minor_register(struct drm_device *dev, unsigned int type)
                goto err_debugfs;
 
        /* replace NULL with @minor so lookups will succeed from now on */
-       spin_lock_irqsave(&drm_minor_lock, flags);
-       idr_replace(&drm_minors_idr, minor, minor->index);
-       spin_unlock_irqrestore(&drm_minor_lock, flags);
+       if (minor->type == DRM_MINOR_ACCEL) {
+               accel_minor_replace(minor, minor->index);
+       } else {
+               spin_lock_irqsave(&drm_minor_lock, flags);
+               idr_replace(&drm_minors_idr, minor, minor->index);
+               spin_unlock_irqrestore(&drm_minor_lock, flags);
+       }
 
        DRM_DEBUG("new minor registered %d\n", minor->index);
        return 0;
@@ -194,9 +213,13 @@ static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
                return;
 
        /* replace @minor with NULL so lookups will fail from now on */
-       spin_lock_irqsave(&drm_minor_lock, flags);
-       idr_replace(&drm_minors_idr, NULL, minor->index);
-       spin_unlock_irqrestore(&drm_minor_lock, flags);
+       if (minor->type == DRM_MINOR_ACCEL) {
+               accel_minor_replace(NULL, minor->index);
+       } else {
+               spin_lock_irqsave(&drm_minor_lock, flags);
+               idr_replace(&drm_minors_idr, NULL, minor->index);
+               spin_unlock_irqrestore(&drm_minor_lock, flags);
+       }
 
        device_del(minor->kdev);
        dev_set_drvdata(minor->kdev, NULL); /* safety belt */
@@ -603,6 +626,13 @@ static int drm_dev_init(struct drm_device *dev,
        /* no per-device feature limits by default */
        dev->driver_features = ~0u;
 
+       if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL) &&
+                               (drm_core_check_feature(dev, DRIVER_RENDER) ||
+                               drm_core_check_feature(dev, DRIVER_MODESET))) {
+               DRM_ERROR("DRM driver can't be both a compute acceleration and graphics driver\n");
+               return -EINVAL;
+       }
+
        drm_legacy_init_members(dev);
        INIT_LIST_HEAD(&dev->filelist);
        INIT_LIST_HEAD(&dev->filelist_internal);
@@ -628,15 +658,21 @@ static int drm_dev_init(struct drm_device *dev,
 
        dev->anon_inode = inode;
 
-       if (drm_core_check_feature(dev, DRIVER_RENDER)) {
-               ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
+       if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL)) {
+               ret = drm_minor_alloc(dev, DRM_MINOR_ACCEL);
                if (ret)
                        goto err;
-       }
+       } else {
+               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_minor_alloc(dev, DRM_MINOR_PRIMARY);
+               if (ret)
+                       goto err;
+       }
 
        ret = drm_legacy_create_map_hash(dev);
        if (ret)
@@ -883,6 +919,10 @@ int drm_dev_register(struct drm_device *dev, unsigned long flags)
        if (ret)
                goto err_minors;
 
+       ret = drm_minor_register(dev, DRM_MINOR_ACCEL);
+       if (ret)
+               goto err_minors;
+
        ret = create_compat_control_link(dev);
        if (ret)
                goto err_minors;
@@ -902,12 +942,13 @@ int drm_dev_register(struct drm_device *dev, unsigned long flags)
                 driver->name, driver->major, driver->minor,
                 driver->patchlevel, driver->date,
                 dev->dev ? dev_name(dev->dev) : "virtual device",
-                dev->primary->index);
+                dev->primary ? dev->primary->index : dev->accel->index);
 
        goto out_unlock;
 
 err_minors:
        remove_compat_control_link(dev);
+       drm_minor_unregister(dev, DRM_MINOR_ACCEL);
        drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
        drm_minor_unregister(dev, DRM_MINOR_RENDER);
 out_unlock:
@@ -950,6 +991,7 @@ void drm_dev_unregister(struct drm_device *dev)
        drm_legacy_rmmaps(dev);
 
        remove_compat_control_link(dev);
+       drm_minor_unregister(dev, DRM_MINOR_ACCEL);
        drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
        drm_minor_unregister(dev, DRM_MINOR_RENDER);
 }
@@ -1034,6 +1076,7 @@ static const struct file_operations drm_stub_fops = {
 static void drm_core_exit(void)
 {
        drm_privacy_screen_lookup_exit();
+       accel_core_exit();
        unregister_chrdev(DRM_MAJOR, "drm");
        debugfs_remove(drm_debugfs_root);
        drm_sysfs_destroy();
@@ -1061,6 +1104,10 @@ static int __init drm_core_init(void)
        if (ret < 0)
                goto error;
 
+       ret = accel_core_init();
+       if (ret < 0)
+               goto error;
+
        drm_privacy_screen_lookup_init();
 
        drm_core_init_complete = true;