if (connector->encoder_ids[i] == 0)
                        break;
 
-               encoder = drm_encoder_find(connector->dev,
+               encoder = drm_encoder_find(connector->dev, NULL,
                                        connector->encoder_ids[i]);
                if (!encoder)
                        continue;
        for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
                if (connector->encoder_ids[i] == 0)
                        break;
-               encoder = drm_encoder_find(connector->dev,
+               encoder = drm_encoder_find(connector->dev, NULL,
                                        connector->encoder_ids[i]);
                if (!encoder)
                        continue;
 
        /* pick the encoder ids */
        if (enc_id)
-               return drm_encoder_find(connector->dev, enc_id);
+               return drm_encoder_find(connector->dev, NULL, enc_id);
        return NULL;
 }
 
                        if (connector->encoder_ids[i] == 0)
                                break;
 
-                       encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
+                       encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
                        if (!encoder)
                                continue;
 
                if (connector->encoder_ids[i] == 0)
                        break;
 
-               encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
+               encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
                if (!encoder)
                        continue;
 
        /* then check use digitial */
        /* pick the first one */
        if (enc_id)
-               return drm_encoder_find(connector->dev, enc_id);
+               return drm_encoder_find(connector->dev, NULL, enc_id);
        return NULL;
 }
 
                if (connector->encoder_ids[i] == 0)
                        break;
 
-               encoder = drm_encoder_find(connector->dev,
+               encoder = drm_encoder_find(connector->dev, NULL,
                                        connector->encoder_ids[i]);
                if (!encoder)
                        continue;
        for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
                if (connector->encoder_ids[i] == 0)
                        break;
-               encoder = drm_encoder_find(connector->dev,
+               encoder = drm_encoder_find(connector->dev, NULL,
                                        connector->encoder_ids[i]);
                if (!encoder)
                        continue;
 
                if (connector->encoder_ids[i] == 0)
                        break;
 
-               encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
+               encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
                if (!encoder)
                        continue;
 
 
        /* pick the first one */
        if (enc_id)
-               return drm_encoder_find(connector->dev, enc_id);
+               return drm_encoder_find(connector->dev, NULL, enc_id);
        return NULL;
 }
 
 
        int enc_id = connector->encoder_ids[0];
        /* pick the encoder ids */
        if (enc_id)
-               return drm_encoder_find(connector->dev, enc_id);
+               return drm_encoder_find(connector->dev, NULL, enc_id);
        return NULL;
 }
 
 
        int enc_id = connector->encoder_ids[0];
        /* pick the encoder ids */
        if (enc_id)
-               return drm_encoder_find(connector->dev, enc_id);
+               return drm_encoder_find(connector->dev, NULL, enc_id);
        return NULL;
 }
 
 
        int enc_id = connector->encoder_ids[0];
        /* pick the encoder ids */
        if (enc_id)
-               return drm_encoder_find(connector->dev, enc_id);
+               return drm_encoder_find(connector->dev, NULL, enc_id);
        return NULL;
 }
 
 
        struct drm_mode_config *config = &dev->mode_config;
 
        if (property == config->prop_fb_id) {
-               struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
+               struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, NULL, val);
                drm_atomic_set_fb_for_plane(state, fb);
                if (fb)
                        drm_framebuffer_put(fb);
                        return -EINVAL;
 
        } else if (property == config->prop_crtc_id) {
-               struct drm_crtc *crtc = drm_crtc_find(dev, val);
+               struct drm_crtc *crtc = drm_crtc_find(dev, NULL, val);
                return drm_atomic_set_crtc_for_plane(state, crtc);
        } else if (property == config->prop_crtc_x) {
                state->crtc_x = U642I64(val);
        struct drm_mode_config *config = &dev->mode_config;
 
        if (property == config->prop_crtc_id) {
-               struct drm_crtc *crtc = drm_crtc_find(dev, val);
+               struct drm_crtc *crtc = drm_crtc_find(dev, NULL, val);
                return drm_atomic_set_crtc_for_connector(state, crtc);
        } else if (property == config->dpms_property) {
                /* setting DPMS property requires special handling, which
                        goto out;
                }
 
-               obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
+               obj = drm_mode_object_find(dev, file_priv, obj_id, DRM_MODE_OBJECT_ANY);
                if (!obj) {
                        ret = -ENOENT;
                        goto out;
 
 drm_atomic_helper_best_encoder(struct drm_connector *connector)
 {
        WARN_ON(connector->encoder_ids[1]);
-       return drm_encoder_find(connector->dev, connector->encoder_ids[0]);
+       return drm_encoder_find(connector->dev, NULL, connector->encoder_ids[0]);
 }
 EXPORT_SYMBOL(drm_atomic_helper_best_encoder);
 
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
 
-       crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
+       crtc = drm_crtc_find(dev, file_priv, crtc_lut->crtc_id);
        if (!crtc)
                return -ENOENT;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
 
-       crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
+       crtc = drm_crtc_find(dev, file_priv, crtc_lut->crtc_id);
        if (!crtc)
                return -ENOENT;
 
 
 
        memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
 
-       connector = drm_connector_lookup(dev, out_resp->connector_id);
+       connector = drm_connector_lookup(dev, file_priv, out_resp->connector_id);
        if (!connector)
                return -ENOENT;
 
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
 
-       crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
+       crtc = drm_crtc_find(dev, file_priv, crtc_resp->crtc_id);
        if (!crtc)
                return -ENOENT;
 
        if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000)
                return -ERANGE;
 
-       crtc = drm_crtc_find(dev, crtc_req->crtc_id);
+       crtc = drm_crtc_find(dev, file_priv, crtc_req->crtc_id);
        if (!crtc) {
                DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
                return -ENOENT;
                        /* Make refcounting symmetric with the lookup path. */
                        drm_framebuffer_get(fb);
                } else {
-                       fb = drm_framebuffer_lookup(dev, crtc_req->fb_id);
+                       fb = drm_framebuffer_lookup(dev, file_priv, crtc_req->fb_id);
                        if (!fb) {
                                DRM_DEBUG_KMS("Unknown FB ID%d\n",
                                                crtc_req->fb_id);
                                goto out;
                        }
 
-                       connector = drm_connector_lookup(dev, out_id);
+                       connector = drm_connector_lookup(dev, file_priv, out_id);
                        if (!connector) {
                                DRM_DEBUG_KMS("Connector id %d unknown\n",
                                                out_id);
 
 void drm_mode_object_register(struct drm_device *dev,
                              struct drm_mode_object *obj);
 struct drm_mode_object *__drm_mode_object_find(struct drm_device *dev,
+                                              struct drm_file *file_priv,
                                               uint32_t id, uint32_t type);
 void drm_mode_object_unregister(struct drm_device *dev,
                                struct drm_mode_object *object);
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
 
-       encoder = drm_encoder_find(dev, enc_resp->encoder_id);
+       encoder = drm_encoder_find(dev, file_priv, enc_resp->encoder_id);
        if (!encoder)
                return -ENOENT;
 
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
 
-       fb = drm_framebuffer_lookup(dev, *id);
+       fb = drm_framebuffer_lookup(dev, file_priv, *id);
        if (!fb)
                return -ENOENT;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
 
-       fb = drm_framebuffer_lookup(dev, r->fb_id);
+       fb = drm_framebuffer_lookup(dev, file_priv, r->fb_id);
        if (!fb)
                return -ENOENT;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
 
-       fb = drm_framebuffer_lookup(dev, r->fb_id);
+       fb = drm_framebuffer_lookup(dev, file_priv, r->fb_id);
        if (!fb)
                return -ENOENT;
 
  * again, using drm_framebuffer_put().
  */
 struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
+                                              struct drm_file *file_priv,
                                               uint32_t id)
 {
        struct drm_mode_object *obj;
        struct drm_framebuffer *fb = NULL;
 
-       obj = __drm_mode_object_find(dev, id, DRM_MODE_OBJECT_FB);
+       obj = __drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_FB);
        if (obj)
                fb = obj_to_fb(obj);
        return fb;
 
 }
 
 struct drm_mode_object *__drm_mode_object_find(struct drm_device *dev,
+                                              struct drm_file *file_priv,
                                               uint32_t id, uint32_t type)
 {
        struct drm_mode_object *obj = NULL;
 
 /**
  * drm_mode_object_find - look up a drm object with static lifetime
- * @dev: drm device
+ * @file_priv: drm file
  * @id: id of the mode object
  * @type: type of the mode object
  *
  * by callind drm_mode_object_put().
  */
 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
+               struct drm_file *file_priv,
                uint32_t id, uint32_t type)
 {
        struct drm_mode_object *obj = NULL;
 
-       obj = __drm_mode_object_find(dev, id, type);
+       obj = __drm_mode_object_find(dev, file_priv, id, type);
        return obj;
 }
 EXPORT_SYMBOL(drm_mode_object_find);
 
        drm_modeset_lock_all(dev);
 
-       obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
+       obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);
        if (!obj) {
                ret = -ENOENT;
                goto out;
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
 
-       arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
+       arg_obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);
        if (!arg_obj)
                return -ENOENT;
 
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
 
-       plane = drm_plane_find(dev, plane_resp->plane_id);
+       plane = drm_plane_find(dev, file_priv, plane_resp->plane_id);
        if (!plane)
                return -ENOENT;
 
         * First, find the plane, crtc, and fb objects.  If not available,
         * we don't bother to call the driver.
         */
-       plane = drm_plane_find(dev, plane_req->plane_id);
+       plane = drm_plane_find(dev, file_priv, plane_req->plane_id);
        if (!plane) {
                DRM_DEBUG_KMS("Unknown plane ID %d\n",
                              plane_req->plane_id);
        }
 
        if (plane_req->fb_id) {
-               fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
+               fb = drm_framebuffer_lookup(dev, file_priv, plane_req->fb_id);
                if (!fb) {
                        DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
                                      plane_req->fb_id);
                        return -ENOENT;
                }
 
-               crtc = drm_crtc_find(dev, plane_req->crtc_id);
+               crtc = drm_crtc_find(dev, file_priv, plane_req->crtc_id);
                if (!crtc) {
                        drm_framebuffer_put(fb);
                        DRM_DEBUG_KMS("Unknown crtc ID %d\n",
        if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags))
                return -EINVAL;
 
-       crtc = drm_crtc_find(dev, req->crtc_id);
+       crtc = drm_crtc_find(dev, file_priv, req->crtc_id);
        if (!crtc) {
                DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
                return -ENOENT;
        if ((page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC) && !dev->mode_config.async_page_flip)
                return -EINVAL;
 
-       crtc = drm_crtc_find(dev, page_flip->crtc_id);
+       crtc = drm_crtc_find(dev, file_priv, page_flip->crtc_id);
        if (!crtc)
                return -ENOENT;
 
                goto out;
        }
 
-       fb = drm_framebuffer_lookup(dev, page_flip->fb_id);
+       fb = drm_framebuffer_lookup(dev, file_priv, page_flip->fb_id);
        if (!fb) {
                ret = -ENOENT;
                goto out;
 
 
        /* Step 2: Validate against encoders and crtcs */
        for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
-               struct drm_encoder *encoder = drm_encoder_find(dev, ids[i]);
+               struct drm_encoder *encoder = drm_encoder_find(dev, NULL, ids[i]);
                struct drm_crtc *crtc;
 
                if (!encoder)
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
 
-       property = drm_property_find(dev, out_resp->prop_id);
+       property = drm_property_find(dev, file_priv, out_resp->prop_id);
        if (!property)
                return -ENOENT;
 
        struct drm_mode_object *obj;
        struct drm_property_blob *blob = NULL;
 
-       obj = __drm_mode_object_find(dev, id, DRM_MODE_OBJECT_BLOB);
+       obj = __drm_mode_object_find(dev, NULL, id, DRM_MODE_OBJECT_BLOB);
        if (obj)
                blob = obj_to_blob(obj);
        return blob;
                if (value == 0)
                        return true;
 
-               *ref = __drm_mode_object_find(property->dev, value,
+               *ref = __drm_mode_object_find(property->dev, NULL, value,
                                              property->values[0]);
                return *ref != NULL;
        }
 
 static struct drm_encoder *
 hibmc_connector_best_encoder(struct drm_connector *connector)
 {
-       return drm_encoder_find(connector->dev, connector->encoder_ids[0]);
+       return drm_encoder_find(connector->dev, NULL, connector->encoder_ids[0]);
 }
 
 static const struct drm_connector_helper_funcs
 
        struct drm_crtc *drmmode_crtc;
        struct intel_crtc *crtc;
 
-       drmmode_crtc = drm_crtc_find(dev, pipe_from_crtc_id->crtc_id);
+       drmmode_crtc = drm_crtc_find(dev, file, pipe_from_crtc_id->crtc_id);
        if (!drmmode_crtc)
                return -ENOENT;
 
 
        if (!params)
                return -ENOMEM;
 
-       drmmode_crtc = drm_crtc_find(dev, put_image_rec->crtc_id);
+       drmmode_crtc = drm_crtc_find(dev, file_priv, put_image_rec->crtc_id);
        if (!drmmode_crtc) {
                ret = -ENOENT;
                goto out_free;
 
            set->flags & I915_SET_COLORKEY_DESTINATION)
                return -EINVAL;
 
-       plane = drm_plane_find(dev, set->plane_id);
+       plane = drm_plane_find(dev, file_priv, set->plane_id);
        if (!plane || plane->type != DRM_PLANE_TYPE_OVERLAY)
                return -ENOENT;
 
 
        int enc_id = connector->encoder_ids[0];
        /* pick the encoder ids */
        if (enc_id)
-               return drm_encoder_find(connector->dev, enc_id);
+               return drm_encoder_find(connector->dev, NULL, enc_id);
        return NULL;
 }
 
 
                if (!id)
                        break;
 
-               enc = drm_encoder_find(dev, id);
+               enc = drm_encoder_find(dev, NULL, id);
                if (!enc)
                        continue;
                nv_encoder = nouveau_encoder(enc);
                if (id == 0)
                        break;
 
-               encoder = drm_encoder_find(dev, id);
+               encoder = drm_encoder_find(dev, NULL, id);
                if (!encoder)
                        continue;
                nv_encoder = nouveau_encoder(encoder);
 
        header = radeon_get_ib_value(p, h_idx);
        crtc_id = radeon_get_ib_value(p, h_idx + 5);
        reg = R100_CP_PACKET0_GET_REG(header);
-       crtc = drm_crtc_find(p->rdev->ddev, crtc_id);
+       crtc = drm_crtc_find(p->rdev->ddev, p->filp, crtc_id);
        if (!crtc) {
                DRM_ERROR("cannot find crtc %d\n", crtc_id);
                return -ENOENT;
 
        crtc_id = radeon_get_ib_value(p, h_idx + 2 + 7 + 1);
        reg = R600_CP_PACKET0_GET_REG(header);
 
-       crtc = drm_crtc_find(p->rdev->ddev, crtc_id);
+       crtc = drm_crtc_find(p->rdev->ddev, p->filp, crtc_id);
        if (!crtc) {
                DRM_ERROR("cannot find crtc %d\n", crtc_id);
                return -ENOENT;
 
                if (connector->encoder_ids[i] == 0)
                        break;
 
-               encoder = drm_encoder_find(connector->dev,
+               encoder = drm_encoder_find(connector->dev, NULL,
                                           connector->encoder_ids[i]);
                if (!encoder)
                        continue;
                if (connector->encoder_ids[i] == 0)
                        break;
 
-               encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
+               encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
                if (!encoder)
                        continue;
 
        int enc_id = connector->encoder_ids[0];
        /* pick the encoder ids */
        if (enc_id)
-               return drm_encoder_find(connector->dev, enc_id);
+               return drm_encoder_find(connector->dev, NULL, enc_id);
        return NULL;
 }
 
                        if (connector->encoder_ids[i] == 0)
                                break;
 
-                       encoder = drm_encoder_find(connector->dev,
+                       encoder = drm_encoder_find(connector->dev, NULL,
                                                   connector->encoder_ids[i]);
                        if (!encoder)
                                continue;
                if (connector->encoder_ids[i] == 0)
                        break;
 
-               encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
+               encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
                if (!encoder)
                        continue;
 
        /* then check use digitial */
        /* pick the first one */
        if (enc_id)
-               return drm_encoder_find(connector->dev, enc_id);
+               return drm_encoder_find(connector->dev, NULL, enc_id);
        return NULL;
 }
 
                if (connector->encoder_ids[i] == 0)
                        break;
 
-               encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
+               encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
                if (!encoder)
                        continue;
 
                if (connector->encoder_ids[i] == 0)
                        break;
 
-               encoder = drm_encoder_find(connector->dev, connector->encoder_ids[i]);
+               encoder = drm_encoder_find(connector->dev, NULL, connector->encoder_ids[i]);
                if (!encoder)
                        continue;
 
 
 udl_best_single_encoder(struct drm_connector *connector)
 {
        int enc_id = connector->encoder_ids[0];
-       return drm_encoder_find(connector->dev, enc_id);
+       return drm_encoder_find(connector->dev, NULL, enc_id);
 }
 
 static int udl_connector_set_property(struct drm_connector *connector,
 
 
        drm_modeset_lock_all(dev);
 
-       fb = drm_framebuffer_lookup(dev, arg->fb_id);
+       fb = drm_framebuffer_lookup(dev, file_priv, arg->fb_id);
        if (!fb) {
                DRM_ERROR("Invalid framebuffer id.\n");
                ret = -ENOENT;
 
        drm_modeset_lock_all(dev);
 
-       fb = drm_framebuffer_lookup(dev, arg->fb_id);
+       fb = drm_framebuffer_lookup(dev, file_priv, arg->fb_id);
        if (!fb) {
                DRM_ERROR("Invalid framebuffer id.\n");
                ret = -ENOENT;
 
                return 0;
        }
 
-       crtc = drm_crtc_find(dev, arg->crtc_id);
+       crtc = drm_crtc_find(dev, file_priv, arg->crtc_id);
        if (!crtc) {
                ret = -ENOENT;
                goto out;
 
 
        /* pick the encoder ids */
        if (enc_id)
-               return drm_encoder_find(connector->dev, enc_id);
+               return drm_encoder_find(connector->dev, NULL, enc_id);
 
        return NULL;
 }
 
  * add takes a reference to it.
  */
 static inline struct drm_connector *drm_connector_lookup(struct drm_device *dev,
+               struct drm_file *file_priv,
                uint32_t id)
 {
        struct drm_mode_object *mo;
-       mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CONNECTOR);
+       mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_CONNECTOR);
        return mo ? obj_to_connector(mo) : NULL;
 }
 
 
  * userspace interface should be done using &drm_property.
  */
 static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev,
-       uint32_t id)
+               struct drm_file *file_priv,
+               uint32_t id)
 {
        struct drm_mode_object *mo;
-       mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC);
+       mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_CRTC);
        return mo ? obj_to_crtc(mo) : NULL;
 }
 
 
  * drm_mode_object_find().
  */
 static inline struct drm_encoder *drm_encoder_find(struct drm_device *dev,
+                                                  struct drm_file *file_priv,
                                                   uint32_t id)
 {
        struct drm_mode_object *mo;
 
-       mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
+       mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_ENCODER);
 
        return mo ? obj_to_encoder(mo) : NULL;
 }
 
                         struct drm_framebuffer *fb,
                         const struct drm_framebuffer_funcs *funcs);
 struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
+                                              struct drm_file *file_priv,
                                               uint32_t id);
 void drm_framebuffer_remove(struct drm_framebuffer *fb);
 void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
 
 struct drm_object_properties;
 struct drm_property;
 struct drm_device;
+struct drm_file;
 
 /**
  * struct drm_mode_object - base structure for modeset objects
        }
 
 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
+                                            struct drm_file *file_priv,
                                             uint32_t id, uint32_t type);
 void drm_mode_object_get(struct drm_mode_object *obj);
 void drm_mode_object_put(struct drm_mode_object *obj);
 
  * drm_mode_object_find().
  */
 static inline struct drm_plane *drm_plane_find(struct drm_device *dev,
+               struct drm_file *file_priv,
                uint32_t id)
 {
        struct drm_mode_object *mo;
-       mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PLANE);
+       mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_PLANE);
        return mo ? obj_to_plane(mo) : NULL;
 }
 
 
  * This function looks up the property object specified by id and returns it.
  */
 static inline struct drm_property *drm_property_find(struct drm_device *dev,
+                                                    struct drm_file *file_priv,
                                                     uint32_t id)
 {
        struct drm_mode_object *mo;
-       mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PROPERTY);
+       mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_PROPERTY);
        return mo ? obj_to_property(mo) : NULL;
 }