/* disallow for drivers not supporting atomic: */
        if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        /* disallow for userspace that has not enabled atomic cap (even
         * though this may be a bit overkill, since legacy userspace
 
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        err = drm_addmap_core(dev, map->offset, map->size, map->type,
                              map->flags, &maplist);
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        idx = map->offset;
        if (idx < 0)
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        mutex_lock(&dev->struct_mutex);
        list_for_each_entry(r_list, &dev->maplist, head) {
        struct drm_buf **temp_buflist;
 
        if (!drm_core_check_feature(dev, DRIVER_PCI_DMA))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!dma)
                return -EINVAL;
        struct drm_buf **temp_buflist;
 
        if (!drm_core_check_feature(dev, DRIVER_SG))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!dma)
                return -EINVAL;
        int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
 #if IS_ENABLED(CONFIG_AGP)
        if (request->flags & _DRM_AGP_BUFFER)
        int count;
 
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!dma)
                return -EINVAL;
        struct drm_buf_entry *entry;
 
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!dma)
                return -EINVAL;
        struct drm_buf *buf;
 
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!dma)
                return -EINVAL;
        int i;
 
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!dma)
                return -EINVAL;
                  struct drm_file *file_priv)
 {
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (dev->driver->dma_ioctl)
                return dev->driver->dma_ioctl(dev, data, file_priv);
 
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET) ||
            !dev->driver->dumb_create || !dev->driver->gem_prime_vmap)
-               return -ENOTSUPP;
+               return -EOPNOTSUPP;
 
        if (funcs && !try_module_get(funcs->owner))
                return -ENODEV;
 
        int ret = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        crtc = drm_crtc_find(dev, file_priv, crtc_lut->crtc_id);
        if (!crtc)
        int ret = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        crtc = drm_crtc_find(dev, file_priv, crtc_lut->crtc_id);
        if (!crtc)
 
        LIST_HEAD(export_list);
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
 
 
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        mutex_lock(&dev->struct_mutex);
 
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        mutex_lock(&dev->struct_mutex);
        list_for_each_entry(r_list, &dev->maplist, head) {
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (res->count >= DRM_RESERVED_CONTEXTS) {
                memset(&ctx, 0, sizeof(ctx));
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        ctx->handle = drm_legacy_ctxbitmap_next(dev);
        if (ctx->handle == DRM_KERNEL_CONTEXT) {
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        /* This is 0, because we don't handle any context flags */
        ctx->flags = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        DRM_DEBUG("%d\n", ctx->handle);
        return drm_context_switch(dev, dev->last_context, ctx->handle);
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        DRM_DEBUG("%d\n", ctx->handle);
        drm_context_switch_complete(dev, file_priv, ctx->handle);
 
        if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) &&
            !drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        DRM_DEBUG("%d\n", ctx->handle);
        if (ctx->handle != DRM_KERNEL_CONTEXT) {
 
        struct drm_plane *plane;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        crtc = drm_crtc_find(dev, file_priv, crtc_resp->crtc_id);
        if (!crtc)
        int i;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        /*
         * Universal plane src offsets are only 16.16, prevent havoc for
 
        struct drm_crtc *crtc;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        encoder = drm_encoder_find(dev, file_priv, enc_resp->encoder_id);
        if (!encoder)
 
        struct drm_mode_fb_cmd2 r = {};
        int ret;
 
+       if (!drm_core_check_feature(dev, DRIVER_MODESET))
+               return -EOPNOTSUPP;
+
        r.pixel_format = drm_mode_legacy_fb_format(or->bpp, or->depth);
        if (r.pixel_format == DRM_FORMAT_INVALID) {
                DRM_DEBUG("bad {bpp:%d, depth:%d}\n", or->bpp, or->depth);
        struct drm_framebuffer *fb;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        fb = drm_internal_framebuffer_create(dev, r, file_priv);
        if (IS_ERR(fb))
                 * ADDFB.
                 */
                DRM_DEBUG_KMS("addfb2 broken on bigendian");
-               return -EINVAL;
+               return -EOPNOTSUPP;
        }
 #endif
        return drm_mode_addfb2(dev, data, file_priv);
        int found = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        fb = drm_framebuffer_lookup(dev, file_priv, fb_id);
        if (!fb)
        int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        fb = drm_framebuffer_lookup(dev, file_priv, r->fb_id);
        if (!fb)
        int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        fb = drm_framebuffer_lookup(dev, file_priv, r->fb_id);
        if (!fb)
 
        int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_GEM))
-               return -ENODEV;
+               return -EOPNOTSUPP;
 
        ret = drm_gem_handle_delete(file_priv, args->handle);
 
        int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_GEM))
-               return -ENODEV;
+               return -EOPNOTSUPP;
 
        obj = drm_gem_object_lookup(file_priv, args->handle);
        if (obj == NULL)
        u32 handle;
 
        if (!drm_core_check_feature(dev, DRIVER_GEM))
-               return -ENODEV;
+               return -EOPNOTSUPP;
 
        mutex_lock(&dev->object_name_lock);
        obj = idr_find(&dev->object_name_idr, (int) args->name);
 
 
        /* Other caps only work with KMS drivers */
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -ENOTSUPP;
+               return -EOPNOTSUPP;
 
        switch (req->capability) {
        case DRM_CAP_DUMB_BUFFER:
                break;
        case DRM_CLIENT_CAP_ATOMIC:
                if (!drm_core_check_feature(dev, DRIVER_ATOMIC))
-                       return -EINVAL;
+                       return -EOPNOTSUPP;
                if (req->value > 1)
                        return -EINVAL;
                file_priv->atomic = req->value;
 
        unsigned long sh_flags = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (irq == 0)
                return -EINVAL;
        int i;
 
        if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        irq_enabled = dev->irq_enabled;
        dev->irq_enabled = false;
 
 
        /* Can't lease without MODESET */
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        /* Do not allow sub-leases */
        if (lessor->lessor)
 
        /* Can't lease without MODESET */
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        DRM_DEBUG_LEASE("List lessees for %d\n", lessor->lessee_id);
 
 
        /* Can't lease without MODESET */
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        DRM_DEBUG_LEASE("get lease for %d\n", lessee->lessee_id);
 
 
        /* Can't lease without MODESET */
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        mutex_lock(&dev->mode_config.idr_mutex);
 
 
        int ret = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        ++file_priv->lock_count;
 
        struct drm_master *master = file_priv->master;
 
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (lock->context == DRM_KERNEL_CONTEXT) {
                DRM_ERROR("Process %d using kernel context %d\n",
 
        struct drm_connector_list_iter conn_iter;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
-
+               return -EOPNOTSUPP;
 
        mutex_lock(&file_priv->fbs_lock);
        count = 0;
 
        int ret = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        drm_modeset_lock_all(dev);
 
        int ret = -EINVAL;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        arg_obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);
        if (!arg_obj)
 
        struct drm_irq_busid *p = data;
 
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        /* UMS was only ever support on PCI devices. */
        if (WARN_ON(!dev->pdev))
                return -EINVAL;
 
        if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        return drm_pci_irq_by_busid(dev, p);
 }
 
        int count = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        plane_ptr = u64_to_user_ptr(plane_resp->plane_id_ptr);
 
        uint32_t __user *format_ptr;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        plane = drm_plane_find(dev, file_priv, plane_resp->plane_id);
        if (!plane)
        int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        /*
         * First, find the plane, crtc, and fb objects.  If not available,
        int ret = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags))
                return -EINVAL;
        int ret = -EINVAL;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS)
                return -EINVAL;
 
        struct drm_prime_handle *args = data;
 
        if (!drm_core_check_feature(dev, DRIVER_PRIME))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!dev->driver->prime_handle_to_fd)
                return -ENOSYS;
        struct drm_prime_handle *args = data;
 
        if (!drm_core_check_feature(dev, DRIVER_PRIME))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!dev->driver->prime_fd_to_handle)
                return -ENOSYS;
 
        uint64_t __user *values_ptr;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        property = drm_property_find(dev, file_priv, out_resp->prop_id);
        if (!property)
        int ret = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        blob = drm_property_lookup_blob(dev, out_resp->blob_id);
        if (!blob)
        int ret = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        blob = drm_property_create_blob(dev, out_resp->length, NULL);
        if (IS_ERR(blob))
        int ret = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        blob = drm_property_lookup_blob(dev, out_resp->blob_id);
        if (!blob)
 
        DRM_DEBUG("\n");
 
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!drm_core_check_feature(dev, DRIVER_SG))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (dev->sg)
                return -EINVAL;
        struct drm_sg_mem *entry;
 
        if (!drm_core_check_feature(dev, DRIVER_LEGACY))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!drm_core_check_feature(dev, DRIVER_SG))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        entry = dev->sg;
        dev->sg = NULL;
 
        struct drm_syncobj_create *args = data;
 
        if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
-               return -ENODEV;
+               return -EOPNOTSUPP;
 
        /* no valid flags yet */
        if (args->flags & ~DRM_SYNCOBJ_CREATE_SIGNALED)
        struct drm_syncobj_destroy *args = data;
 
        if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
-               return -ENODEV;
+               return -EOPNOTSUPP;
 
        /* make sure padding is empty */
        if (args->pad)
        struct drm_syncobj_handle *args = data;
 
        if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
-               return -ENODEV;
+               return -EOPNOTSUPP;
 
        if (args->pad)
                return -EINVAL;
        struct drm_syncobj_handle *args = data;
 
        if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
-               return -ENODEV;
+               return -EOPNOTSUPP;
 
        if (args->pad)
                return -EINVAL;
        int ret = 0;
 
        if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
-               return -ENODEV;
+               return -EOPNOTSUPP;
 
        if (args->flags & ~(DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL |
                            DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT))
        int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
-               return -ENODEV;
+               return -EOPNOTSUPP;
 
        if (args->pad != 0)
                return -EINVAL;
        int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ))
-               return -ENODEV;
+               return -EOPNOTSUPP;
 
        if (args->pad != 0)
                return -EINVAL;
 
        int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!dev->irq_enabled)
                return -EINVAL;
        unsigned long spin_flags;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
-               return -EINVAL;
+               return -EOPNOTSUPP;
 
        if (!dev->irq_enabled)
                return -EINVAL;