struct ida *connector_ida =
                &drm_connector_enum_list[connector_type].ida;
 
-       ret = drm_mode_object_get_reg(dev, &connector->base,
-                                     DRM_MODE_OBJECT_CONNECTOR,
-                                     false, drm_connector_free);
+       ret = __drm_mode_object_add(dev, &connector->base,
+                                   DRM_MODE_OBJECT_CONNECTOR,
+                                   false, drm_connector_free);
        if (ret)
                return ret;
 
 
        spin_lock_init(&crtc->commit_lock);
 
        drm_modeset_lock_init(&crtc->mutex);
-       ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
+       ret = drm_mode_object_add(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
        if (ret)
                return ret;
 
 
                               void *data, struct drm_file *file_priv);
 
 /* drm_mode_object.c */
-int drm_mode_object_get_reg(struct drm_device *dev,
-                           struct drm_mode_object *obj,
-                           uint32_t obj_type,
-                           bool register_obj,
-                           void (*obj_free_cb)(struct kref *kref));
+int __drm_mode_object_add(struct drm_device *dev, struct drm_mode_object *obj,
+                         uint32_t obj_type, bool register_obj,
+                         void (*obj_free_cb)(struct kref *kref));
+int drm_mode_object_add(struct drm_device *dev, struct drm_mode_object *obj,
+                       uint32_t obj_type);
 void drm_mode_object_register(struct drm_device *dev,
                              struct drm_mode_object *obj);
-int drm_mode_object_get(struct drm_device *dev,
-                       struct drm_mode_object *obj, uint32_t obj_type);
 struct drm_mode_object *__drm_mode_object_find(struct drm_device *dev,
                                               uint32_t id, uint32_t type);
 void drm_mode_object_unregister(struct drm_device *dev,
 
 {
        int ret;
 
-       ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
+       ret = drm_mode_object_add(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
        if (ret)
                return ret;
 
 
 
        fb->funcs = funcs;
 
-       ret = drm_mode_object_get_reg(dev, &fb->base, DRM_MODE_OBJECT_FB,
-                                     false, drm_framebuffer_free);
+       ret = __drm_mode_object_add(dev, &fb->base, DRM_MODE_OBJECT_FB,
+                                   false, drm_framebuffer_free);
        if (ret)
                goto out;
 
 
  * Internal function to assign a slot in the object idr and optionally
  * register the object into the idr.
  */
-int drm_mode_object_get_reg(struct drm_device *dev,
-                           struct drm_mode_object *obj,
-                           uint32_t obj_type,
-                           bool register_obj,
-                           void (*obj_free_cb)(struct kref *kref))
+int __drm_mode_object_add(struct drm_device *dev, struct drm_mode_object *obj,
+                         uint32_t obj_type, bool register_obj,
+                         void (*obj_free_cb)(struct kref *kref))
 {
        int ret;
 
 }
 
 /**
- * drm_mode_object_get - allocate a new modeset identifier
+ * drm_mode_object_add - allocate a new modeset identifier
  * @dev: DRM device
  * @obj: object pointer, used to generate unique ID
  * @obj_type: object type
  *
  * Create a unique identifier based on @ptr in @dev's identifier space.  Used
- * for tracking modes, CRTCs and connectors. Note that despite the _get postfix
- * modeset identifiers are _not_ reference counted. Hence don't use this for
- * reference counted modeset objects like framebuffers.
+ * for tracking modes, CRTCs and connectors.
  *
  * Returns:
  * Zero on success, error code on failure.
  */
-int drm_mode_object_get(struct drm_device *dev,
+int drm_mode_object_add(struct drm_device *dev,
                        struct drm_mode_object *obj, uint32_t obj_type)
 {
-       return drm_mode_object_get_reg(dev, obj, obj_type, true, NULL);
+       return __drm_mode_object_add(dev, obj, obj_type, true, NULL);
 }
 
 void drm_mode_object_register(struct drm_device *dev,
 
        if (!nmode)
                return NULL;
 
-       if (drm_mode_object_get(dev, &nmode->base, DRM_MODE_OBJECT_MODE)) {
+       if (drm_mode_object_add(dev, &nmode->base, DRM_MODE_OBJECT_MODE)) {
                kfree(nmode);
                return NULL;
        }
 
        struct drm_mode_config *config = &dev->mode_config;
        int ret;
 
-       ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
+       ret = drm_mode_object_add(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
        if (ret)
                return ret;
 
 
                        goto fail;
        }
 
-       ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
+       ret = drm_mode_object_add(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
        if (ret)
                goto fail;
 
        if (data)
                memcpy(blob->data, data, length);
 
-       ret = drm_mode_object_get_reg(dev, &blob->base, DRM_MODE_OBJECT_BLOB,
-                                     true, drm_property_free_blob);
+       ret = __drm_mode_object_add(dev, &blob->base, DRM_MODE_OBJECT_BLOB,
+                                   true, drm_property_free_blob);
        if (ret) {
                kfree(blob);
                return ERR_PTR(-EINVAL);